[学习报告]《LeetCode零基础指南》(第八讲) 二级指针

 千山万水总有路，勇敢迈出第一步！！！前路很难，路已过半，何言弃，言何弃
>> 算法的魅力，在于即使，知识你门清，题目给你一闷棍。
<< 有形的代码，被无形算法来回拉扯，翻滚吧，我的脑浆。

今日套餐【7 绿 1 橙】。那个橙的，真的赶不上绿的 ~
~ 热烈祝贺 老坛算粉 Leetcode 破百题 ~
🐎🐎🐎 突击 200 + 的路上 🐎🐎🐎

 人生总有一场旅行，与 C++ 携手，说走就走~ 

很神奇的事情发生了，当你适应了 二维数组，开了七窍流了血，二维数组，so so so easy ~  【过啦~】 

接下来，欢迎大家来到，线性代数 之 矩阵 之 阅读理解，准备好有感情的阅读了吗？🤦‍ 读不懂，有没有 ~

一、吹逼

今日学习内容：https://bbs.csdn.net/topics/605731678
开始脑力训练 ~ 矩阵转转转，脑力 up up up ~~~

1. 今日第一 “牛”，1260. 二维网格迁移 👈  灵光乍现，把矩阵拉成一维，操作后，再转成矩阵，估计灵感来源是 2022. 将一维数组转变成二维数组 👈 我可真棒棒。同理，可得 566. 重塑矩阵 也得这么干！妥妥的 Triple kill 。→ 661. 图片平滑器 和 1314. 矩阵区域和 ：双层循环中，小范围上下左右扫 ~ Double Kill

2. 今日第二 “牛”，1314. 矩阵区域和，说好的 一寸光阴一寸金，看这结果，我珍爱 寸土寸金，毕竟房价真的贵 ~ 用我 10 年换 1 房，行不行 🤦‍

二、晒战绩

话不多说，上图~ 👆 

三、写解题报告

题解报告，只写让我有 

 的那道题！
>> 算法的魅力，在于，即使知识你门清，题目给你一闷棍。
<< 有形的代码，被无形算法来回拉扯，翻滚吧，我的脑浆。

2022. 将一维数组转变成二维数组：题目理解 → 很好理解

1. emplace_back，变参函数，直接用迭代器，构造 vector<int>，据说，比 push_back 快速，少了 move 的操作

class Solution {
public:
    vector<vector<int>> construct2DArray(vector<int> &original, int m, int n) {
        vector<vector<int>> ans;
        // 所有元素重构成二维数组，否则，返回 {}
        if (original.size() != m * n) {
            return ans;
        }

        // 方法1：push_back 添加 T value 
        // int  k = 0;     // k 为 original 的下标索引
        // for(int i=0; i<m; i++) {
        //     ans.push_back({});  // 构造一个 vector<int> {}，添加到 ans 中
        //     // 为 {} 添加元素
        //     for(int j=0; j<n; j++) {
        //         ans[i].push_back(original[k++]);
        //     }
        // }

        // 方法2：emplace_back 可使用两个迭代器作为参数，
        //  并利用两个迭代器，直接构造 vector<int>，并添加到 ans 最后
        for (auto it = original.begin(); it != original.end(); it += n) {
            ans.emplace_back(it, it + n);
        }
        return ans;
    }
};

 1260. 二维网格迁移：题目理解 → 按照规则，将矩阵元素迁来迁去。矩阵？看我给你拉成一条线 ~ 

class Solution {
public:
    vector<vector<int>> shiftGrid(vector<vector<int>>& grid, int k) {
        if(k==0) return grid;

        int N = grid.size();
        int M = grid[0].size();
        // 矩阵拉成一位数组
        vector<int> tmp;
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                tmp.push_back(grid[i][j]);
            }
        }

        // 操作一维 tmp
        while(k--) {
            int last = tmp[M*N-1];
            tmp.pop_back();
            tmp.insert(begin(tmp), last);
        }

        // 放回 grid 中
        int p = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                grid[i][j] = tmp[p++];
            }
        }

        return grid;
    }
};

566. 重塑矩阵：题目理解 → MatLab 中 reshape，来模拟一个，同样，拉成一条线~ 。为了避免和上面的一样，学点新东西：

1. range-for，遍历容器中的元素

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& mat, int r, int c) {

        int N = mat.size();
        int M = mat[0].size();
        if(N*M != r*c) return mat;
        if(N==r && M==c) return mat;

        // 将 mat 全部放到一个 临时数组中
        vector<int> tmp;
        for(auto c : mat) {
            for(auto x : c) tmp.push_back(x);
        }

        // 走 tmp 构造 reshape后的矩阵
        vector<vector<int>> res;
        for(auto it = tmp.begin(); it != tmp.end(); it+=c) {
            res.emplace_back(it, it+c);
        }

        return res;
    }
};

1314. 矩阵区域和：题目理解 → mat[i][j] 为中心，辐射 k*k 网格，求和。
661. 图片平滑器：题目理解 → mat[i][j] 为中心，辐射 3*3 网格，求向下取整的平均数。

class Solution {
public:
    vector<vector<int>> imageSmoother(vector<vector<int>>& img) {
        int N = img.size();
        int M = img[0].size();
        if(M*N == 1) return img;

        vector<vector<int>> res(N, vector<int>(M));
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                // 计算周围的元素和和个数
                unsigned int sum = 0;
                unsigned int cnt = 0;

                for(int k=max(i-1, 0); k<=min(i+1,N-1); k++) {
                    for(int m=max(j-1, 0); m<=min(j+1, M-1); m++) {
                        cnt ++;
                        sum += img[k][m];
                    }
                }
                res[i][j] = sum / cnt;
            }
        }

        return res;
    }
};

832. 翻转图像：题目理解 → 矩阵左右翻转，再反转 0 1 互换

class Solution {
public:
    vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {
        int N = image.size();
        int M = image[0].size();

        for(int i=0; i<N; i++) {
            // 双指针交换
            int lo = 0, hi = M - 1;
            while(lo < hi) {
                image[i][lo] = image[i][lo] ? 0 : 1;
                image[i][hi] = image[i][hi] ? 0 : 1;
                
                swap(image[i][lo], image[i][hi]);
                lo ++;
                hi --;
            }
            if(M%2) image[i][M/2] = image[i][M/2] ? 0 : 1;
        }

        return image;
    }
};

四、写给今天的自己

可以临时放下，但绝不等放过。成长就是挠头后，灵光一现的灵感 ~ 👈 找到程序员头发少的原因了 🤦‍🤦‍🤦‍

一通百通，不通则痛，今天，有时快乐的一天呀 ~