题目：

题目链接

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

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

给定一个二进制矩阵 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

解题思路：

首先根据题目给的思路来，对数据进行一次遍历，交换对应位置上的数据。

        //获取输入数据

        int len_h = A.size();    //获取行数

        int len_w = A[0].size()-1;    //获取列数，这里为了方便后面使用，-1对应下标

之后遍历每一行的前一半的列，判断数据，先取反再交换位置
这里直接暴力实现

        for(int i = 0; i < len_h; i++){  //按行遍历
            for(int j = 0; j <= len_w/2; j++){  //遍历前一半的数据
                int temp = 0;  //用于交换位置的辅助存储
                if(A[i][j] == 0)
                    A[i][j] = 1;
                else
                    A[i][j] = 0;  //对A[i][j]取反
                if(A[i][len_w-j] == 0)
                    A[i][len_w-j] = 1;
                else
                    A[i][len_w-j] = 0;  //根据j的值定位对应位置的值，并取反
                temp = A[i][len_w-j];
                A[i][len_w-j] = A[i][j];
                A[i][j] = temp;     //交换数据
                if(j == len_w-j){   //若是长度为奇数，对上述遍历不到的最中间的一位进行取反
                    if(A[i][j] == 0)
                    A[i][j] = 1;
                else
                    A[i][j] = 0;
                }
            }
        }

这样唯一使用到的知识点就是交换数据的三行代码，ヽ(ー_ー)ノ
到这里基本就完成了，最后把二维容器A返回即可。

升级版

上述代码能够成功AC，但是时间效率和空间效率都明显略低，特别是时间效率

执行用时 : 36 ms, 在Flipping an Image的C++提交中击败了28.76% 的用户
内存消耗 : 9.4 MB, 在Flipping an Image的C++提交中击败了70.61% 的用户

接下来对代码进行优化，先从原理开始，既然想要优化就不能按照题目中描述的直接暴力解题了，需要找到其中的症结所在。
这题能够优化的内容在于，对于对应位置上相等的数据，可以不进行数据交换，直接取反即可

    class Solution {
    public:
        vector<vector<int>> flipAndInvertImage(vector<vector<int>>& A) {
             int len_h = A.size();
            int len_w = A[0].size();
            for(int i=0;i<len_h;i++)
            {
                for(int j=len_w/2;j<len_w;j++)//A[i].size()-1-j
                {
                    if(A[i][len_w-1-j]==A[i][j])
                    {
                        if(A[i][j]==1)
                        {
                            A[i][j]=0;
                            A[i][len_w-1-j]=0;
                        }                        
                        else
                        {
                            A[i][j]=1;
                            A[i][len_w-1-j]=1;
                        }
                    }
                }
            }
            return A;
        }
    };

优化后的代码时间效率有明显提升

执行用时 : 16 ms, 在Flipping an Image的C++提交中击败了96.83% 的用户
内存消耗 : 9.4 MB, 在Flipping an Image的C++提交中击败了70.61% 的用户

到此为止本题已经基本解决，感谢阅读 |ू･ω･` )