《算法零基础100讲》02 二维数组

宁玉AC

已于 2022-02-06 14:51:56 修改

阅读量508

点赞数 2

分类专栏：算法零基础文章标签：算法矩阵线性代数

于 2022-02-06 14:47:07 首次发布

本文链接：https://blog.youkuaiyun.com/EmileJiao/article/details/122695133

版权

算法零基础专栏收录该内容

8 篇文章

订阅专栏

第三讲矩阵

一、知识点

1.数学上，矩阵；程序中，二维数组。

2.矩阵的水平翻转，就是将矩阵的每一行的元素进行逆序。

ret[i][j] = image[i][ c-1-j ] c是imageColSize[0]

3.矩阵的垂直翻转，就是将矩阵的每一列的元素进行逆序。

4.矩阵的顺时针旋转，这时，行列会交换。

5.矩阵的转置：行列交换，第一列变成第一行

ret[i][j] = matrix[j][i];

二、题目

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

1672. 最富有客户的资产总量 - 力扣（LeetCode） (leetcode-cn.com)

二维数组的函数传参

int diagonalSum(int** mat, int matSize, int* matColSize){

}

matSize代表行数，int *matColSize是一个一维数组，代表列数，

matColSize[i] 代表第 i 行有 matColSize[i] 列

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

class Solution {
public:
    int maximumWealth(vector<vector<int>>& accounts) {
int max=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];
    }
    if(sum>max)
    max=sum;
}
return max;
    }
};

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

1582. 二进制矩阵中的特殊位置 - 力扣（LeetCode） (leetcode-cn.com)

int check(int** mat, int matSize, int matColSize, int r, int c) {
    int i;
    if(mat[r][c] != 1) {
        return 0;                                           
    }
    for(i = 0; i < matSize; ++i) {
        if(i != r && mat[i][c]) {
            return 0;                                       
        }
    }//(1)
    for(i = 0; i < matColSize; ++i) {
        if(i != c && mat[r][i]){
            return 0;                                       
        }
    }//(2)
    return 1;                                               
}
 
int numSpecial(int** mat, int matSize, int* matColSize){    
    int i, j;
    int sum = 0;
    for(i = 0; i < matSize; ++i) {
        for(j = 0; j < matColSize[i]; ++j) {              
            sum += check(mat, matSize, matColSize[i], i, j); 
        }
    }
    return sum;
}

(1)r行，c列， mat[r][c]为1，则mat[i][c] 中 i不等于r时，该列均为0，此时才满足题干如果 mat[i][j] == 1 并且第 i 行中的所有其他元素均为 0 而i!=r&&mat[i][c] 表示除了第r行以外的其他行与第c列的交集那几个数中如果有1则返回0，有1则不满足题干

(2)同理（1）

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

标记每行或每列有几个1即可

3.翻转图像

832. 翻转图像 - 力扣（LeetCode） (leetcode-cn.com)

 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;
}/*内存申请模板
第一个malloc所在语句   表示申请一个矩阵的内存，行数为r，首地址为ret，二维数组的类型为int **  二维数组中每个元素的类型为一级指针，即int *,对应sizeof(int *)这个表达式；

第二个malloc所在语句   为列申请一个数组记录每一行的列数，所以这个列数组的长度是r，需要作为参数返回调用方，所以调用了解引用

第三个malloc所在语句   申请矩阵每一行的内存空间，每一行长度为列数c
*/
int** flipAndInvertImage(int** image, int imageSize, int* imageColSize, int* returnSize, int** returnColumnSizes){
    int i, j;                                                 
    int r = imageSize, c = imageColSize[0];                    
    int **ret = myMalloc(r, c, returnSize, returnColumnSizes); 
    for(i = 0; i < r; ++i) {
        for(j = 0; j < c; ++j) {
            ret[i][j] = 1 - image[i][ c-1-j ];                 
        }
    }
    return ret;                                                
}

4.旋转图像

48. 旋转图像 - 力扣（LeetCode） (leetcode-cn.com)

5.转置矩阵

867. 转置矩阵 - 力扣（LeetCode） (leetcode-cn.com)

 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** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes){
    int i, j;                                                
    int r = matrixColSize[0], c = matrixSize;     //转置矩阵，行变成列，列变成行           
    int **ret = myMalloc(r, c, returnSize, returnColumnSizes);
    for(i = 0; i < r; ++i) {
        for(j = 0; j < c; ++j) {
            ret[i][j] = matrix[j][i];                         
        }
    }
    return ret;                                              
}

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

2022. 将一维数组转变成二维数组 - 力扣（LeetCode） (leetcode-cn.com)

   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;                                           
}

《算法零基础100讲》02 二维数组

第三讲 矩阵

一、知识点

二、题目

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

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

3.翻转图像

4.旋转图像

5.转置矩阵

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

7.判断矩阵经轮转后是否一致

8.二维网络迁移

9.螺旋矩阵

第三讲矩阵