【九日集训】第七天：二维数组

二维数组就是一个矩阵，它有两个参数，像这样a[i][j]，其中i表示第几行，j表示第几列（注意下标从0开始）
一维数组的传参用的一个*，int a(int * nums);
二维数组的传参用的两个**，int a(int ** nums);知道这个就可以了

第一题

https://leetcode.cn/problems/count-negative-numbers-in-a-sorted-matrix/description/

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

第二题

https://leetcode.cn/problems/matrix-diagonal-sum/

int diagonalSum(int** mat, int matSize, int* matColSize){
    int sum = 0;
    // 加主对角线元素
    for(int i = 0; i < matSize; i++) {
        sum += mat[i][i];
    }
    // 加副对角线元素
    int n = 0;
    for(int i = matSize - 1; i >= 0; i--) {
        sum += mat[n++][i];
    }
    // 如果为奇数,则需要去掉一个中间元素
    if(matSize % 2 != 0) sum -= mat[matSize / 2][matSize / 2];
    return sum; 
}

第二种我之前做过的方法，应该也不难理解：

int diagonalSum(int** mat, int matSize, int* matColSize){
    int sum = 0;
    int sec = matSize - 1;
    for(int i = 0; i < matSize; i++) {
        sum += mat[i][i];
        if(i != sec) sum += mat[i][sec];
        sec--;
    }
    return sum;
}

第三题

https://leetcode.cn/problems/richest-customer-wealth/description/

int maximumWealth(int** accounts, int accountsSize, int* accountsColSize) {
    int r = accountsSize;
    int c = accountsColSize[0];
    int ans = 0;
    for(int i = 0; i < r; i++) {
        int sum = 0;
        for(int j = 0; j < c; j++) {
            sum += accounts[i][j];
        }
        if(sum > ans) ans = sum;
    }    
    return ans;
}

第四题

https://leetcode.cn/problems/toeplitz-matrix/description/
刚开始还想用对角线来解决，发现难度有点大；
这题只要仔细看每个元素存在条件可知，每个元素左上角元素和它一定是相等的。

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

    for(int i = 1; i < r; i++) {
        for(int j = 1; j < c; j++) {
            if(matrix[i][j] != matrix[i - 1][j - 1]) return false;
        }
    }
    return true;
}

第五题

https://leetcode.cn/problems/lucky-numbers-in-a-matrix/
模拟题实际上不难，就是需要自己在脑中运算，然后实现在代码上。
具体思路是：1、先遍历数组的行，找到最小的数；
2、然后紧接着根据找到这个最小元素的列进行比较，如果这个数字是列中最大的，则保存到数组中。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* luckyNumbers (int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    int * res = (int *)malloc(sizeof(int) * matrixSize * matrixColSize[0]);
    int r = matrixSize;
    int c = matrixColSize[0];

    int retSize = 0;

    for(int i = 0; i < r; i++) {
        int min = matrix[i][0];
        int tc = 0;
        for(int j = 1; j < c; j++) {
            if(matrix[i][j] < min) {
                min = matrix[i][j];
                tc = j;
            }
        }
        int flag = 1;
        for(int z = 0; z < r; z++) {
            if(min < matrix[z][tc]) {
                flag = 0;
            }
        }

        if(flag) {
            res[0] = min;
            retSize++;
        }
    }

    *returnSize = retSize;
    return res;
}

第六题

https://leetcode.cn/problems/special-positions-in-a-binary-matrix/description/
和上一题大同小异

int numSpecial(int** mat, int matSize, int* matColSize){
    int r = matSize;
    int c = matColSize[0];
    int ans = 0;
    for(int i = 0; i < r; i++) {
        for(int j = 0; j < c; j++) {
            if(mat[i][j] == 1) {
                int flag = 1;
                for(int z = 0; z < r; z++) {
                    if(z == i) continue;
                    if(mat[z][j] == 1) {
                        flag = 0;
                        break;
                    }
                }
                for(int x = 0; x < c; x++) {
                    if(x == j) continue;
                    if(mat[i][x] == 1) {
                        flag = 0;
                        break;
                    }
                }

                if(flag) ans++;
                break;
            }
        }
    }
    return ans;
}

第七题

https://leetcode.cn/problems/island-perimeter/description/
这题不知为什么内存总是溢出，但在我把循环中的i++换为++i就好了。

const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};

int islandPerimeter(int** grid, int gridSize, int* gridColSize) {
    int r = gridSize;
    int c = gridColSize[0];
    int ans = 0;
    for(int i = 0; i < r; ++i) {
        for(int j = 0; j < c; ++j) {
            if(grid[i][j]) {
                int cnt = 0;
                for(int a = 0; a < 4; ++a) {
                    int tx = i + dx[a];
                    int ty = j + dy[a];
                    if(tx < 0 || tx >= r || ty < 0 || ty >= c || !grid[tx][ty]) {
                        cnt++;
                    }
                }
                ans += cnt;
            }
        }
    }
    return ans;
}