What is the main idea behind the Flipping an Image problem?

The main idea is to flip each row horizontally using two pointers and then invert each element in place for efficiency.

Can this be done without extra space?

Yes, by scanning each row with two pointers and performing swaps and inversion simultaneously, no additional storage is needed.

How do I handle odd-length rows?

After swapping pairs with two pointers, invert the central element separately to ensure correctness.

Why use two-pointer scanning instead of built-in functions?

Two-pointer scanning allows in-place operations, combines flipping and inversion, and demonstrates clear algorithmic control for interviews.

What common mistakes should I avoid?

Avoid skipping middle elements, double-inverting values, or using extra arrays unnecessarily. Track pointers carefully for correctness.

#832

Easy

auto_awesome双·指针·invariant

LeetCode 题解工作台

翻转图像

给定一个 n x n 的二进制矩阵 image ，先水平翻转图像，然后反转图像并返回结果。水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1,1,0] 的结果是 [0,1,1] 。反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如…

数组双指针位运算矩阵模拟

题目描述

给定一个 n x n 的二进制矩阵 image ，先水平翻转图像，然后反转图像并返回结果。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。

例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。

例如，反转 [0,1,1] 的结果是 [1,0,0]。

示例 1：

输入：image = [[1,1,0],[1,0,1],[0,0,0]]
输出：[[1,0,0],[0,1,0],[1,1,1]]
解释：首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]；
     然后反转图片: [[1,0,0],[0,1,0],[1,1,1]]

示例 2：

输入：image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]
输出：[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
解释：首先翻转每一行: [[0,0,1,1],[1,0,0,1],[1,1,1,0],[0,1,0,1]]；
     然后反转图片: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]

提示：

n == image.length
n == image[i].length
1 <= n <= 20
images[i][j] == 0 或 1.

lightbulb

解题思路

方法一：双指针

我们可以遍历矩阵，对于遍历到的每一行 $\textit{row}$ ，我们使用双指针 $i$ 和 $j$ 分别指向该行的首尾元素，如果 $\textit{row}[i] = \textit{row}[j]$ ，交换后两者的值仍然保持不变，因此，我们只需要对 $\textit{row}[i]$ 和 $\textit{row}[j]$ 进行异或反转即可，然后将 $i$ 和 $j$ 分别向中间移动一位，直到 $i \geq j$ 。如果 $\textit{row}[i] \neq \textit{row}[j]$ ，此时交换后再反转两者的值，仍然保持不变，因此，可以不进行任何操作。

最后，如果 $i = j$ ，我们直接对 $\textit{row}[i]$ 进行反转即可。

时间复杂度 $O(n^2)$ ，其中 $n$ 是矩阵的行数或列数。空间复杂度 $O(1)$ 。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

class Solution:
    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
        n = len(image)
        for row in image:
            i, j = 0, n - 1
            while i < j:
                if row[i] == row[j]:
                    row[i] ^= 1
                    row[j] ^= 1
                i, j = i + 1, j - 1
            if i == j:
                row[i] ^= 1
        return image

speed

复杂度分析

指标	值
时间	complexity is O(N^2) because each of the N rows of length N is scanned once. Space complexity is O(1) since all operations are performed in place with no extra storage.
空间	O(1)

psychology

面试官常问的追问

外企场景

question_mark
Check if the candidate correctly flips rows without using extra arrays.
question_mark
Watch whether inversion is combined with swapping or done in a separate pass.
question_mark
Confirm that middle elements in odd-length rows are handled without errors.

warning

常见陷阱

外企场景

error
Swapping values without inverting them at the same time causes incorrect final results.
error
Off-by-one errors when moving two pointers can skip elements or double-invert.
error
Failing to handle odd-length rows' middle element separately leads to wrong inversion.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Apply the same two-pointer flip and invert approach on a rectangular matrix instead of a square one.
arrow_right_alt
Perform horizontal flip only, without inversion, to isolate the flipping logic.
arrow_right_alt
Invert all elements without flipping to practice bit manipulation in place.

help

常见问题

外企场景

继续练习

#861 翻转矩阵后的得分 #749 隔离病毒 #1284 转化为全零矩阵的最少反转次数