【双指针】LeetCode 832. 翻转图像

832. 翻转图像

---

题目来源：力扣（LeetCode）https://leetcode-cn.com/problems/flipping-an-image/

题目

---

给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。

示例 1:

输入: [[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:

输入: [[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]]

说明:

• 1 <= A.length = A[0].length <= 20
• 0 <= A[i][j] <= 1

解题思路

---

思路：双指针（两次遍历，一次遍历）

先审题，题目给定一个二进制矩阵 $A$，要求：

• 先水平翻转图像；
• 然后反转图像。

返回操作后的结果。其中：

• 水平翻转： 指将图片每一行进行翻转，即是逆序。
• 反转： 指的是将图片中的 0 都替换为 1，而 1 变为 0。

到这里，可以发现题意所述已经非常清晰，直接按照要求操作即可。

这里提及下 异或，如果两个值不同，异或结果为 1；如果值相同，异或结果为 0。因为矩阵是二进制矩阵，元素值只包含 0 或 1，所以进行反转操作时，可以用 异或 运算。

两次遍历

先对矩阵进行水平翻转，然后反转，返回结果，这里需要对矩阵遍历两次。

具体代码实现如下。

class Solution:
    def flipAndInvertImage(self, A: List[List[int]]) -> List[List[int]]:
        for row in A:
            # 先进行水平翻转
            i = 0
            j = len(row) - 1
            while i < j:
                row[i], row[j] = row[j], row[i]
                i += 1
                j -= 1
            # 然后反转图像
            for k in range(len(row)):
                row[k] ^= 1
        
        return A

复杂度分析

• 时间复杂度：$O(n^2)$，$n$ 为矩阵的列数和行数，需要遍历两次矩阵，所需时间为 $O(2n^2)$，最终时间复杂度为 $O(n^2)$。
• 空间复杂度：$O(1)$，仅使用常数个额外空间。

一次遍历

上述的方法中，将水平翻转与反转分开考虑，需要遍历两次矩阵。

对于水平翻转的操作，上面使用的双指针的方法，定义指针初始指向每一行的头部和尾部，交换对应的值，同时向中间移动。

而反转图像操作中，每个元素值都需要进行改变。

前面我们知道，矩阵的元素值只可能是 **0 ** 或 1，那么每行中定义指针对应的值，要么相同（均为 0 或均为 1），要么不相同（其中一个为 1，另外一个为 0）。

反转操作：使用异或运算，因为 0 ^ 1 = 1， 1 ^ 1 = 0

现在我们结合水平翻转和反转操作来看，分情况讨论：

• 当指针对应的值相等时（以均为 0 举例），进行水平翻转后，因为原本值相同，所以这里值不会有变化；再进行反转，这里值均变为 1。（值均为 1 的情况同理）

  也就说，当指针对应的值相同时，决定值变化的是后面反转这一步操作。那么当判断两指针对应的数值相等时，对两者的元素值分别进行异或运算即可。

• 当值不同时，令 a = 0， b = 1 分别表示两指针对应的值，进行水平翻转后，交换两者的值，此时 a = 1，b = 0；再进行反转，此时 a = 0，b = 1。（另外一种情况同理）

  可以发现，当指针对应值不同时，经过两个操作之后，最终的元素值与原本相同。

根据上面的情况，我们仅需要遍历一次矩阵，只要对其中指针对应的值判断是否相等进行相应的操作即可。

这里需要注意，根据上面的思路进行实现时，当矩阵的行数为奇数时，最终指针会重合，虽然此时指针对应的值可看成时相等的，但是却不能当成上面第一种情况来看。

因为第一种情况需分别对两指针的值进行异或运算，这里对应的是同个元素的值，进行两次异或操作之后，这里值不会有变化。所以单独对其进行一次异或运算即可。

这里以示例 1，用图示的形式来看下实现的过程，如下图：

具体的代码实现如下。

class Solution:
    def flipAndInvertImage(self, A: List[List[int]]) -> List[List[int]]:
        n = len(A)
        
        for i in range(n):
            left = 0
            right = n - 1
            # 根据分析，元素值不同时，经过两种操作之后无变化
            # 那么主要处理元素值相同的情况，
            # 元素值相同时，决定值变化的时最后的反转操作，那么对元素值进行异或运算即可
            while left < right:
                if A[i][left] == A[i][right]:
                    A[i][left] ^= 1
                    A[i][right] ^= 1
                
                left += 1
                right -= 1
            # 可能存在行数为奇数的情况，单独处理
            if left == right:
                A[i][left] ^= 1
        
        return A

复杂度分析

• 时间复杂度：$O(n^2)$，$n$ 是矩阵的行数和列数，只需要遍历一次矩阵。
• 空间复杂度：$O(1)$，仅使用常数个额外空间。

欢迎关注

---

公众号 【书所集录】

---

如有错误，烦请指出，欢迎指点交流。若觉得写得还不错，麻烦点个赞👍，谢谢。