《LeetCode零基础指南》(第八讲) 二维数组

1. 统计有序矩阵中的负数

1351. 统计有序矩阵中的负数

• 题目

给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。

请你统计并返回 grid 中 负数 的数目。

• 思路分析

双层循环遍历二维数组中的所有负数

• 源码实现

int countNegatives(int** grid, int gridSize, int* gridColSize){
    int i, j;
    int cnt = 0;
    for(i = 0; i < gridSize; ++i)
    {
        for(j = 0; j < *gridColSize; ++j)
        {
            if(grid[i][j] < 0)
            {
                cnt++;
            }
        }
    }
    return cnt;
}

2. 矩阵对角线元素的和

1572. 矩阵对角线元素的和

• 题目

给你一个正方形矩阵 mat，请你返回矩阵对角线元素的和。

请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。

• 思路分析

分别计算主对角线上元素的值，副对角线的值（注意排除重复元素的计算）。

• 源码实现

int diagonalSum(int** mat, int matSize, int* matColSize){
    int row = matSize;
    int col = matColSize[0];
    int ans = 0;

    int i;
    for(i = 0; i < row; ++i) //计算主对角线
    {
        ans += mat[i][i];
    }

    //计算副对角线
    for(i = 0; i < row; ++i)
    {
        if(col - i - 1 != i)
        {
            ans += mat[i][col - i - 1];
        }
    }

    return ans;
}

3. 最富有客户的资产总量

1672. 最富有客户的资产总量

• 题目

给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。

客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/richest-customer-wealt
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 思路分析

求资产总量，实际上就是在求每一行中所有列元素的和，然后返回一行中的所有列元素相加结果最大的值。

• 源码实现

int maximumWealth(int** accounts, int accountsSize, int* accountsColSize){
    //循环接收
    int max_sum = 0, sum; 
    for(int i = 0; i < accountsSize; ++i)
    {
        sum = 0; //总和清零，求得是每一行的总和
        for(int j = 0; j < *accountsColSize; j++)
        {
            sum += accounts[i][j];
        }
        max_sum = sum > max_sum ? sum:max_sum;
    }
    return max_sum;
}

4. 托普利茨矩阵

766. 托普利茨矩阵

• 题目

给你一个 m x n 的矩阵 matrix 。如果这个矩阵是托普利茨矩阵，返回 true ；否则，返回 false 。

如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是 托普利茨矩阵 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/toeplitz-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 思路分析

要判断左上到右下的对角线上的元素是否都相同，就需要遍历比较对应的元素。具体做法：模拟一个方向变量，每次往右下移动一步，直到遇到行边界或列边界的时候退出，正常退出表示元素都相同，否则返回false表示这不是一个托普利茨矩阵。

• 源码实现

int checkSame(int **matrix, int sr, int sc, int maxsr, int maxsc)
{
    int step = 0;
    while(1)	//模拟方向变量，使其从当前元素往右下方向走
    {
        if(sr + step >= maxsr)  //遇到行边界就停下
            break;
        if(sc + step >= maxsc)  //遇到列边界就停下
            break;
        if(matrix[sr + step][sc + step] != matrix[sr][sc])  //不相等直接返回false
            return false;
        ++step;
    }
    return true;
}

bool isToeplitzMatrix(int** matrix, int matrixSize, int* matrixColSize){
    int r = matrixSize;
    int c = matrixColSize[0];

    int i;
    for(i = 0; i < c; ++i)  //从第一行开始往右下角走
    {
        if(!checkSame(matrix, 0, i, r, c))
        {
            return false;
        }
    }

    for(i = 0; i < r; ++i)  //从第一列开始往右下角走
    {
        if(!checkSame(matrix, i, 0, r, c))
        {
            return false;
        }
    }

    return true;
}

5. 矩阵中的幸运数

1380. 矩阵中的幸运数

• 题目

给你一个 m * n 的矩阵，矩阵中的数字 各不相同 。请你按 任意 顺序返回矩阵中的所有幸运数。

幸运数是指矩阵中满足同时下列两个条件的元素：

• 在同一行的所有元素中最小
• 在同一列的所有元素中最大

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lucky-numbers-in-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

根据两个条件，可以写出两个循环分别求出当前行的最小值和当前列的最大值，然后将结果依次进行比较，判断保存的元素是否满足条件。

• 源码实现

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int min(int a, int b)
{
    return a < b ? a:b;
}

int max(int a, int b)
{
    return a > b ? a:b;
}

int* luckyNumbers (int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    //找出每一行的最小值
    int i, j;
    int r = matrixSize;
    int c = matrixColSize[0];
    int *ans = (int *)malloc(sizeof(int) * r * c);
    int rmin[100];
    int cmax[100];

    for(i = 0; i < r; ++i) //统计每一行的最小值
    {
        rmin[i] = 1000000;	//保证比它的最大值还要大
        for(j = 0; j < c; ++j)
        {
            rmin[i] = min(rmin[i], matrix[i][j]);
        }
    }
    for(j = 0; j < c; ++j)  //统计每一列的最大值
    {
        cmax[j] = 0;
        for(i = 0; i < r; ++i)
        {
            cmax[j] = max(cmax[j], matrix[i][j]);
        }
    }
    *returnSize = 0;	//每找到一个元素，数组大小就加1
    for(i = 0; i < r; ++i)
    {
        for(j = 0; j < c; ++j)
        {
            if(matrix[i][j] == rmin[i] && matrix[i][j] == cmax[j])	
            {
                ans[(*returnSize)++] = matrix[i][j];	//将满足条件的结果写入新数组
            }
        }
    }

    return ans;
}

6. 二进制矩阵中的特殊位置

1582. 二进制矩阵中的特殊位置

• 题目

给你一个大小为 rows x cols 的矩阵 mat，其中 mat[i][j] 是 0 或 1，请返回 矩阵 mat 中特殊位置的数目 。

特殊位置 定义：如果 mat[i][j] == 1 并且第 i 行和第 j 列中的所有其他元素均为 0（行和列的下标均 从 0 开始 ），则位置 (i, j) 被称为特殊位置。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/special-positions-in-a-binary-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

判断是否为特殊元素，首先找到值为1的元素的位置，然后查找当前行，当前列是否有相同的元素，最后返回结果。封装成函数是为了提高代码的可读性，便于模块性开发。

• 源码实现

bool checkNum(int **mat, int x, int y, int max_x, int max_y)
{
    int i;

    for(i = 0; i < max_y; ++i)  //检查列中是否与当前元素相同的元素
    {
        if(mat[x][i] && y != i) //排除当前的元素
        {
            return false;
        }
    }

    for(i = 0; i < max_x; ++i)  //检查行中的元素
    {
        if(mat[i][y] && x != i)
        {
            return false;
        }
    }
    
    return true;
}

int numSpecial(int** mat, int matSize, int* matColSize){
    int row = matSize;
    int col = matColSize[0];
    int cnt = 0;

    int i, j;   //找出1的位置
    for(i = 0; i < row; ++i)
    {
        for(j = 0; j < col; ++j)
        {
            if(mat[i][j] && checkNum(mat, i, j, row, col))  //判断当前i，j位置上是否有多个1
            {
                cnt++;
            }
        }
    }

    return cnt;
}

7. 岛屿的周长

463. 岛屿的周长

• 题目

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。

网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/island-perimeter
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

• 题目分析

计算岛屿的周长，实质上是求出1的个数，每个1代表的是长度是4，但根据题目的意思，岛屿在水平和垂直方向是相连的。那么我们就需要找到当前岛屿周边的相邻的岛屿数量，并减去相应的周长。注意边界情况。累计相加，求出最终结果

• 源码实现

int sumPerimeter(int **grid, int x, int y, int max_x, int max_y) //检查该岛屿周边是否存在其他岛屿
{
    int sum = 4;
    if(x - 1 >= 0 && grid[x -1][y]) //上面
    {
        --sum;
    }
    if(x + 1 < max_x && grid[x + 1][y]) //下面
    {
        --sum;
    }
    if(y - 1 >= 0 && grid[x][y - 1]) //左边
    {
        --sum;
    }
    if(y + 1 < max_y && grid[x][y + 1]) //右边
    {
        --sum;
    }

    return sum;
}

int islandPerimeter(int** grid, int gridSize, int* gridColSize){
    int row = gridSize;
    int col = gridColSize[0];
    int sum = 0;	//记得初始化，否则结果会出错

    int i, j;
    for(i = 0; i < row; ++i)
    {
        for(j = 0; j < col; ++j)
        {
            if(grid[i][j])
            {
                sum += sumPerimeter(grid, i, j, row, col);  //统计每个元素的周长
            }
        }
    }

    return sum;
}