三， 矩阵

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

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

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

int maximumWealth(int** accounts, int accountsSize, int* accountsColSize){
    int i, j;
    int maxv = -1, maxIdx, sumv;
    for(i = 0; i < accountsSize; ++i) {
        sumv = 0;
        for(j = 0; j < *accountsColSize; ++j) {
            sumv += accounts[i][j];             
        }
        if(sumv > maxv) {
            maxv = sumv;                       
            maxIdx = i;
        }
    }
    return maxv;
}

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

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

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

int numSpecial(int** mat, int matSize, int* matColSize){
    int *row = (int*)malloc(sizeof(int)*matSize);
    int *col = (int*)malloc(sizeof(int)*(*matColSize));
    memset( row , 0 , sizeof( int ) * matSize );
    memset( col , 0 , sizeof( int ) * ( * matColSize  ) );
    int i,j;
    for(i=0;i<matSize;i++){
        for(j=0;j<(*matColSize+0);j++){
            row[i]+=mat[i][j];
            col[j]+=mat[i][j];
        }
    }
    int cnt=0;
    for( i = 0;i < matSize;i++)
    {
        for( j = 0;j <(*matColSize+0);j++)
        {
            if(mat[i][j] == 1 && row[i] == 1 && col[j] == 1) cnt++;
        }
    }
    return cnt;
}

 832. 翻转图像

给定一个 n x n 的二进制矩阵 image ，先 水平 翻转图像，然后 反转 图像并返回 结果 。

水平翻转图片就是将图片的每一行都进行翻转，即逆序。

    例如，水平翻转 [1,1,0] 的结果是 [0,1,1]。

反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。

    例如，反转 [0,1,1] 的结果是 [1,0,0]。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
    int i, j, col;
    int **ret = (int **)malloc( sizeof(int *) * imageSize );        
    *returnColumnSizes = (int *)malloc( sizeof(int) * imageSize );  
    for(i = 0; i < imageSize; ++i) {
        col = imageColSize[i];                                      
        ret[i] = (int *)malloc( sizeof(int) * col );                
        (*returnColumnSizes)[i] = col;                              
        for(j = 0; j < col; ++j) {
            ret[i][j] = 1 - image[i][ col-1-j ];                   
        }
    }
    *returnSize = imageSize;                                       
    return ret;                                                   
}

 48. 旋转图像

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像

void rotate(int** matrix, int matrixSize, int* matrixColSize) {
    int matrix_new[matrixSize][matrixSize];
    for (int i = 0; i < matrixSize; i++) {
        for (int j = 0; j < matrixSize; j++) {
            matrix_new[i][j] = matrix[i][j];
        }
    }
    for (int i = 0; i < matrixSize; ++i) {
        for (int j = 0; j < matrixSize; ++j) {
            matrix[j][matrixSize - i - 1] = matrix_new[i][j];
        }
    }
}

 867. 转置矩阵

给你一个二维整数数组 matrix， 返回 matrix 的 转置矩阵 。

矩阵的 转置 是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes) {
    int m = matrixSize, n = matrixColSize[0];
    int** transposed = malloc(sizeof(int*) * n);
    *returnSize = n;
    *returnColumnSizes = malloc(sizeof(int) * n);
    for (int i = 0; i < n; i++) {
        transposed[i] = malloc(sizeof(int) * m);
        (*returnColumnSizes)[i] = m;
    }
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            transposed[j][i] = matrix[i][j];
        }
    }
    return transposed;
}

 2022. 将一维数组转变成二维数组

给你一个下标从 0 开始的一维整数数组 original 和两个整数 m 和  n 。你需要使用 original 中 所有 元素创建一个 m 行 n 列的二维数组。

original 中下标从 0 到 n - 1 （都 包含 ）的元素构成二维数组的第一行，下标从 n 到 2 * n - 1 （都 包含 ）的元素构成二维数组的第二行，依此类推。

请你根据上述过程返回一个 m x n 的二维数组。如果无法构成这样的二维数组，请你返回一个空的二维数组。

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
   int **myMalloc(int r, int c, int* returnSize, int** returnColumnSizes) {
    int i;
    int **ret = (int **)malloc( sizeof(int *) * r );       
    *returnColumnSizes = (int *)malloc( sizeof(int) * r );  
    *returnSize = r;                                        
    for(i = 0; i < r; ++i){
        ret[i] = (int *)malloc( sizeof(int) * c );          
        (*returnColumnSizes)[i] = c;                        
    }    
    return ret;
}
int** construct2DArray(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes){
    int **ret, i, j;
    if (originalSize != n*m) {
        *returnSize = 0;                                   
        return ret;
    }
    ret = myMalloc(m, n, returnSize, returnColumnSizes);    
    for(i = 0; i < m; ++i) {
        for(j = 0; j < n; ++j) {
            ret[i][j] = original[ i * n + j ];              
        }
    }
    return ret;                                            
}