[解题报告]《LeetCode零基础指南》(第八讲) 二维数组

最新推荐文章于 2024-09-25 13:54:13 发布

Risso

最新推荐文章于 2024-09-25 13:54:13 发布

阅读量560

点赞数 2

文章标签：算法 leetcode leetcode

本文链接：https://blog.csdn.net/weixin_45977410/article/details/121605126

版权

本文介绍了如何统计有序矩阵中的负数、计算矩阵对角线元素和、找出最富有的客户资产、验证托普利茨矩阵、寻找矩阵中的幸运数，以及解决二进制矩阵中的特殊位置问题。通过一系列算法实例，深入浅出地探讨了基础矩阵操作在信息技术中的应用。

摘要由CSDN通过智能技术生成

前言

跟着英雄哥打卡第四十天
[专题跳转->《算法零基础100讲》]
[万人千题社区跳转]
[LeetCode零基础指南]

一、统计有序矩阵中的负数

跳转力扣：1351. 统计有序矩阵中的负数
难度：★☆☆☆☆

说明：暴力，矩阵向右下递减，可以从右上到左下查找负数，若找到负数，则该数的下面所有都为负数，若非负数，则向左移动一格继续找

代码如下（示例）：

class Solution {
public:
    int countNegatives(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size(), ans = 0;
        /*
        for (int i = 0, j = n - 1; i < m && j >= 0;) {
            if (grid[i][j] >= 0)
                i ++;
            else {
                ans += m - i;
                j --;
            }
        }
        return ans;
        */
        // 暴力竟然比技巧还快...
        for (int i = 0; i < m; i ++)
            for (int j = 0; j < n; j ++)
                if (grid[i][j] < 0)
                    ans ++;
        return ans;
    }
};

二、矩阵对角线元素的和

跳转力扣：1572. 矩阵对角线元素的和
难度：★☆☆☆☆

说明：暴力，找主对角线和副对角线上的数累加即可，自然地排除了重复的数

代码如下（示例）：

class Solution {
public:
    int diagonalSum(vector<vector<int>>& mat) {
        int m = mat.size(), n = mat[0].size(), ans = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                if (i == j || n - i - 1 == j)
                    ans += mat[i][j];
            }
        }
        return ans;
    }
};

三、最富有客户的资产总量

跳转力扣：1672. 最富有客户的资产总量
难度：★☆☆☆☆

说明：暴力，将每行累加，求出最大行即为答案所求

代码如下（示例）：

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

四、托普利茨矩阵

跳转力扣：766. 托普利茨矩阵
难度：★☆☆☆☆

说明：暴力，确保每个数与左上的数相同即可

代码如下（示例）：

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

五、矩阵中的幸运数

跳转力扣：1380. 矩阵中的幸运数
难度：★☆☆☆☆

说明：暴力，找到每行最小值，每列最大值，分别放入 $r o w$ 和 $c o l$ 数组中，若 $r o w [i] = = c o l [j]$ 表示该数 $m a t r i x [i] [j]$ 是该行最小值及该列最大值，即为答案所求

代码如下（示例）：

class Solution {
public:
    vector<int> luckyNumbers (vector<vector<int>>& matrix) {
        int m = matrix.size(), n = matrix[0].size();
        vector<int> row, col, ans; // 每行最小，每列最大的元素放进数组
        for (int i = 0; i < m; i ++) {
            int minr = 100010;
            for (int j = 0; j < n; j ++)
                minr = min(minr, matrix[i][j]);
            row.push_back(minr);
        }
        for (int i = 0; i < n; i ++) {
            int maxc = 0;
            for (int j = 0; j < m; j ++)
                maxc = max(maxc, matrix[j][i]);
            col.push_back(maxc);
        }
        for (int i = 0; i < m; i ++) 
            for (int j = 0; j < n; j ++)
                if (row[i] == col[j])
                    ans.push_back(matrix[i][j]);
        return ans;
    }
};

六、二进制矩阵中的特殊位置

跳转力扣：1582. 二进制矩阵中的特殊位置
难度：★☆☆☆☆

说明：暴力，与上题相似，计算出每行，每列的累计和分别放入 $r o w$ 和 $c o l$ 数组中，若 mat[i][j] == 1 && row[i] == 1 && column[j] == 1 则表示 该行该列只有目前一个1，即为答案所求

代码如下（示例）：

class Solution {
public:
    int numSpecial(vector<vector<int>>& mat) {
        int n = mat.size(), m = mat[0].size();
        vector<int> row, column;
        int cnt = 0;
        for (int i = 0; i < n; i++){
            int t_r = 0;
            for (int j = 0; j < m; j++){
                t_r += mat[i][j];
            }
            row.push_back(t_r);
        }
        for (int i = 0; i < m; i++){
            int t_c = 0;
            for (int j = 0; j < n; j++){
                t_c += mat[j][i];
            }
            column.push_back(t_c);
        }
        for (int i = 0; i < n; i++){
            for (int j = 0; j < m; j++){
                if (mat[i][j] == 1 && row[i] == 1 && column[j] == 1)
                    cnt ++;
            }
        }
        return cnt;
    }
};

七、岛屿的周长

跳转力扣：463. 岛屿的周长
难度：★☆☆☆☆

说明：暴力，每一小块陆地初始周长为4，若上下左右四个方向相邻有其他岛屿，则相连起来的两块陆地周长互相少1

代码如下（示例）：

class Solution {
public:
    int dire[5] = {0, 1, 0, -1, 0};
    int islandPerimeter(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size(), ans = 0;
        for (int i = 0; i < m; i ++) {
            for (int j = 0; j < n; j ++) {
                int c = 0;
                if (grid[i][j] == 1) {
                    c = 4;
                    for (int k = 0; k < 4; k ++) {
                        int ni = i + dire[k], nj = j + dire[k + 1]; // 遍历上下左右四个方向的常用小技巧
                        if (ni >= 0 && ni < m && nj >= 0 && nj < n && grid[ni][nj] == 1) {
                            c --;
                        }
                    }
                }
                ans += c;
            }
        }
        return ans;
    }
};

八、翻转矩阵后的得分

跳转力扣：861. 翻转矩阵后的得分
难度：★☆☆☆☆

说明：贪心，由于二进制数每一位相差2的倍数，若使数值尽量最大，则需使最高位最大，（例：1000的二进制为8，0111的二进制为7，意味着最高位为1，无论低位有几个1都比之小），因此第一步为将最高位为0的行翻转，再根据该行是否翻转计算贡献；
翻转行使最高位为1，翻转列使1的数量比0多，可通过 $m a x (c t b, m - c t b)$ 求得最大贡献

代码如下（示例）：

class Solution {
public:
    int matrixScore(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size(), ans = 0;
        ans = m * pow(2, n - 1);
        for (int j = 1; j < n; j ++) {
            int ctb = 0;
            for (int i = 0; i < m; i ++) {
                if (grid[i][0] == 1)
                    ctb += grid[i][j];
                else {
                    ctb += (1 - grid[i][j]);
                }
            }
            int k = max(ctb, m - ctb); -- （*）
            ans += k * pow(2, n - j - 1);
        }
        return ans;
    }
};