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

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

/**给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。 
请你统计并返回 grid 中负数的数目。 */
class Solution {//二分法
    public int countNegatives(int[][] grid) {
        int count = 0;
        for(int i = 0; i < grid.length; i++){
            int left = 0;
            int right = grid[i].length - 1;
            int index = -1;
            while(left <= right){
                int mid = (right - left) / 2 + left;//防止溢出
                if(grid[i][mid] >= 0){
                    index = mid;
                    left = mid + 1;
                }else {
                    right = mid - 1;
                }
            }
            count += grid[i].length - (index + 1);
        }
        return count;
    }
}

2.1572. 矩阵对角线元素的和

/*
1.给你一个正方形矩阵 mat，请你返回矩阵对角线元素的和。
2.请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和*/
class Solution {
    public int diagonalSum(int[][] mat) {
        int n = mat.length, sum = 0;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if(i == j || i + j == n - 1){
                    sum += mat[i][j];
                } 
            }
        }
        return sum;
    }
}

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

/*
1.给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i​​​​​​​​​​​​ 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
2.客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。 */
/*class Solution {
    public int maximumWealth(int[][] accounts) {
        int max = 0, sum = 0;
        for(int i = 0; i < accounts.length; i++){
            for(int j = 0; j < accounts[0].length; j++){
                sum += accounts[i][j];
            }
            max = Math.max(max,sum);
        }
        return max;
    }
}*/
class Solution {
    public int maximumWealth(int[][] accounts) {
        int num = 0;
        for(int i = 0; i < accounts.length; i++){
            int temp = 0;
            for(int j = 0; j < accounts[i].length; j++){
                temp += accounts[i][j];
            }
            if(num < temp){
                num = temp;
            }
        }
        return num;
    }
}

4.766. 托普利茨矩阵

/*
1.给你一个 m x n的矩阵 matrix 如果这个矩阵是托普利茨矩阵，返回 true ；否则，返回 false 
2.如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是 托普利茨矩阵 */
class Solution {
    public boolean isToeplitzMatrix(int[][] matrix) {
        int rows = matrix.length, cols = matrix[0].length;
        //得到最左边的数，调用isEquals()方法，比较对角线
        for(int i = rows - 1; i >= 0; i--){
            if(!isEquals(matrix, rows, cols, i, 0)){
                return false;
            }
        }
         //获取最上边行的每个数字，对其调用isEquals()方法，比较对角线
        for(int j=1; j<cols; j++){
            if(!isEquals(matrix, rows, cols, 0, j)){
                return false;
            }
        }
        return true;
    }
       //判断当前值是否与其对角线上所有的值相等
    private boolean isEquals(int[][] matrix, int rows, int cols, int i, int j){
        int curValue = matrix[i][j];
        int addNum = 1;
        while(i + addNum < rows && j + addNum < cols){
            if(matrix[i + addNum][j + addNum] != curValue){
                return false;
            }
            addNum++;
        }
        return true;
    }
}

5.1380. 矩阵中的幸运数

/*给你一个 m * n 的矩阵，矩阵中的数字 各不相同，请你按任意顺序返回矩阵中的所有幸运数。
幸运数是指矩阵中满足同时下列两个条件的元素：
    在同一行的所有元素中最小
    在同一列的所有元素中最大 */
class Solution {
    public List<Integer> luckyNumbers (int[][] matrix) {
       ArrayList<Integer> list = new ArrayList<>();
       for(int i = 0; i < matrix.length; i++){
           int rows = Integer.MAX_VALUE;
           int cols = Integer.MIN_VALUE;
           int index = 0;//行下标
           //遍历行寻找最小值
           for(int j = 0; j < matrix[i].length; j++){
               if(rows > matrix[i][j]){
                   rows = matrix[i][j];
                   index = j;
               }
           }
           for(int j = 0; j < matrix.length; j++){//遍历列寻找最大值..
               cols = Math.max(cols,matrix[j][index]);
           }

           if(rows == cols){//是否相同的数
               list.add(rows);//存放数据..
           }
       }
       return list;
    }
}

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

/*
1.给你一个大小为 rows x cols 的矩阵 mat，其中 mat[i][j] 是 0 或 1，请返回 矩阵 mat 中特殊位置的数目 。
2.特殊位置 定义：如果 mat[i][j] == 1 并且第 i 行和第 j 列中的所有其他元素均为 0（行和列的下标均 从 0 开始 ），则位置 (i, j) 被称为特殊位置*/
class Solution {
    public int numSpecial(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        int [] rows = new int [m];
        int [] cols = new int [n];
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                rows[i] += mat[i][j];
                cols[j] += mat[i][j];
            }
        }
        int count = 0;
        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){
                    count++;
                }
            }
        }
        return count;
    }
}

7.463. 岛屿的周长

class Solution {//新宝岛...
/*1.给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
2.网格中的格子 水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
3.岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
*/
    public int islandPerimeter(int[][] grid) {
        int sum = 0;
        for(int i = 0; i < grid.length; i++){
            for(int j = 0; j < grid[0].length; j++){
                if(grid[i][j] == 1){
                    sum += 4;
                    if(j != 0 && grid[i][j-1] == 1){
                        sum -= 2;
                    }
                    if(i != 0 && grid[i - 1][j] == 1){
                        sum -= 2;
                    }
                }
            }
        }
        return sum;
    }
}

8.861. 翻转矩阵后的得分

/*
1.有一个二维矩阵 A 其中每个元素的值为 0 或 1 。
2.移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。
3.在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。
4.返回尽可能高的分数
 */
class Solution {
    public int matrixScore(int[][] grid) {
        if(grid == null || grid.length == 0){
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;

        //更新行，使得最高位等于1
        for(int [] rows: grid){
            if(rows[0] == 0){
                for(int j = 0; j < n; j++){
                    rows[j] = 1 - rows[j];
                }
            }
        }

        // 更新列使得每一列的1的个数最多，忽略第一列
        for (int i = 1; i < n; i++) {
            //统计1的个数
            int ones = 0;
            for (int[] rows : grid) {
                ones += rows[i];
            }
            if (ones <= m / 2) {
                for (int[] rows : grid) {
                    rows[i] = 1 - rows[i];
                }
            }
        }

        // 求和
        int sum = 0;
        for (int[] rows : grid) {
            int e = 0;
            while (e < n) {
                sum += rows[n - 1 - e] * Math.pow(2, e++);
            }
        }
        return sum;
    }
}

最后

以上就是老迟到故事为你收集整理的《LeetCode零基础指南》(第八讲) 二维数组的全部内容，希望文章能够帮你解决《LeetCode零基础指南》(第八讲) 二维数组所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。