[学习报告]《LeetCode零基础指南》(第七讲) 二维数组

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

今日套餐【ALL 绿】。休息很重要，全绿利用睡眠 ~ 哈哈哈
先写两个醒醒困劲，晚点再干
~ 热烈祝贺 老坛算粉 Leetcode 破百题 ~ 

全是绿题 ，表示也撑不住呀，二维数组 - 矩阵，Python 操作起来六的很，整个 C++ ，尼玛不会了。语法糖吃多，傻掉了 🤦‍🤦‍🤦‍ 人生总有一场旅行，与 C++ 携手，收走就走~ 

一、吹逼

今日学习内容：https://bbs.csdn.net/topics/605702199
开始脑力训练

今日最 “牛”，1572. 矩阵对角线元素的和 👈  我还是很喜欢，这种小巧的思路，不难，我刚好能消化，而且，觉得蛮过瘾

class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        int N = mat.size();
        // 正方形二维矩阵 主对角线 i = j 副对角线 i + j = N -1
        // 且 N 为奇数时，主副 共有中间元素
        int sum = 0;
        for(int i = 0; i < N; i++) {
            sum += mat[i][i] + mat[i][N-i-1];
        }
        // 去除奇数时，重复计算的中间元素
        // N&1  奇数返回 0.偶数返回 1
        // 二进制 偶数最低位 0，奇数最低为 1：0&1 = 0 1&1 = 1
        int mid = N/2;
        sum -= mat[mid][mid] * (N&1);
        return sum;
    }
};

二、晒战绩

话不多说，上图~ 👆 

三、写解题报告

题解报告，只写让我有 

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

766. 托普利茨矩阵：题目理解 → 左上到右下，每一条对角线上元素都相等。和一维数组类似，但上二维，有点上难度呀，吼

class Solution {
public:
    bool isToeplitzMatrix(vector<vector<int>>& matrix) {
        int N = matrix.size();
        int M = matrix[0].size();
        for(int i = 1; i < N; i++) {
            for(int j = 1; j < M; j++) {
                if(matrix[i][j] != matrix[i-1][j-1]) return false;
            }
        }
        return true;
    }
};

1672. 最富有客户的资产总量：题目理解 → 求每行和的最大值

class Solution {
public:
    int maximumWealth(vector<vector<int>>& accounts) {
        int ans = 0;
        int MAX = 0;
        for(int i = 0; i < accounts.size(); i++) {
            int sum = 0;
            for(int j = 0; j < accounts[0].size(); j++) {
                sum += accounts[i][j];
            }
            if(sum > MAX) MAX = sum;
        }
        return MAX;
    }
};

四、睡一觉就会

有些题，脑子不清楚，怎么都觉得自己不会，然鹅，睡一觉，就会了~ 就是这么神奇
冲刷的重要性，不重来，没法成李白（理解地明明白白），哈哈~ 

463. 岛屿的周长：题目理解 →  m*n 面积的岛屿，1 表示陆地，0 表示水域，求陆地范围的周长
PS：题解写的美，可我看不懂，我缝缝补补写了下面的代码 👇  

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

        int ans = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                // 如果当前是陆地，贡献的周长
                //      边界 + 1  临水 + 1
                if(grid[i][j]) {
                    // 判断边界和上下方向
                    if(i==0) ans ++;
                    if(i==N-1) ans ++;
                    if(i>0 && grid[i-1][j] == 0) ans++;
                    if(i<N-1 && grid[i+1][j] == 0) ans++;
                    // 判断边界和左右方向
                    if(j==0) ans ++;
                    if(j==M-1) ans ++;
                    if(j>0 && grid[i][j-1] == 0) ans++;
                    if(j<M-1 && grid[i][j+1] == 0) ans++;
                }
            }
        }

        return ans;
    }
};

1582. 二进制矩阵中的特殊位置：题目理解 → m*n 矩阵，元素要么为0要么为1，要是 i 行、j 列所有元素仅 mat[i][j]  为 1 ，则称为特殊位置。

为了汇报我的不放弃不抛弃，你看 程序多懂事。

 新知识点 C++ accumulate，想要对 i 行整行求和，用 sum 报错。csdn 搜索，得到 accumulate，刚好之前曾在 《Effective STL》中看到过 推荐 accumulate 求和，趁机学习和使用一下，accumulate 主要场景：

1. accumulate(begin(vec), end(vec), init)：将 vec 的 [begin, end) 累加到 初始求和值 init 上
2. 数字求和：accumulate(begin(vec), end(vec), 0)  
3. 字符串拼接：accumulate(begin(vec), end(vec), string(' '))  

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

        int ans = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                if(mat[i][j] == 0) continue;
                
                // 验证 mat[i][j] 是 i 行 或 j 列中唯一的 1
                // 验证 i 行，直接求和 等于 1即可
                int s1 = accumulate(begin(mat[i]), end(mat[i]), 0);
                if(s1 != 1) break;

                // 验证 j 列，求和 等于 1
                int s2 = 0;
                for(int k=0; k<N; k++) s2 += mat[k][j];

                if(s2==1) ans++;
            }
        }

        return ans;
    }
};

1380. 矩阵中的幸运数：题目理解 → m*n 矩阵，元素各不相同，要是某个元素在行中最小，列中最大，则为幸运数

class Solution {
public:
    vector<int> luckyNumbers (vector<vector<int>>& matrix) {
        vector<int> ans {};
        int N = matrix.size();
        int M = matrix[0].size();
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                // matrix[i][j]
                bool isMin = true;
                bool isMax = true;
                // 验证 i 行中 matrix[i][j] 最小
                for(int k=0; k<M; k++) {
                   if(matrix[i][k] < matrix[i][j]) {
                       isMin = false;
                       break;
                   } 
                }
                // matrix[i][j] 不是i行最小，就继续验证下一个元素
                if(!isMin) continue;
                
                // 验证 j 列中 matrix[i][j] 最大
                for(int k=0; k<N; k++) {
                   if(matrix[k][j] > matrix[i][j]) {
                       isMax = false;
                       break;
                   } 
                }

                // matrix[i][j] 是j列最大
                if(isMax) ans.push_back(matrix[i][j]);
            }
        }
        return ans;
    }
};

五、写给自己

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