面试经典150题——矩阵

文章目录

• 1、有效的数独
• • [1.1 题目链接](#1.1 题目链接)
  • [1.2 题目描述](#1.2 题目描述)
  • [1.3 解题代码](#1.3 解题代码)
  • [1.4 解题思路](#1.4 解题思路)
• 2、螺旋矩阵
• • [2.1 题目链接](#2.1 题目链接)
  • [2.2 题目描述](#2.2 题目描述)
  • [2.3 解题代码](#2.3 解题代码)
  • [2.4 解题思路](#2.4 解题思路)
• 3、旋转图像
• • [3.1 题目链接](#3.1 题目链接)
  • [3.2 题目描述](#3.2 题目描述)
  • [3.3 解题代码](#3.3 解题代码)
  • [3.4 解题思路](#3.4 解题思路)
• 4、矩阵置零
• • [4.1 题目链接](#4.1 题目链接)
  • [4.2 题目描述](#4.2 题目描述)
  • [4.3 解题代码](#4.3 解题代码)
  • [4.4 解题思路](#4.4 解题思路)
• 5、生命游戏
• • [5.1 题目链接](#5.1 题目链接)
  • [5.2 题目描述](#5.2 题目描述)
  • [5.3 解题代码](#5.3 解题代码)
  • [5.4 解题思路](#5.4 解题思路)

---

1、有效的数独

1.1 题目链接

点击跳转到题目位置

1.2 题目描述

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

注意：

• 一个有效的数独（部分已被填充）不一定是可解的。
• 只需要根据以上规则，验证已经填入的数字是否有效即可。
• 空白格用 '.' 表示。

提示：

• board.length == 9
• board[i].length == 9
• board[i][j] 是一位数字（1-9）或者 '.'

1.3 解题代码

class Solution {
    boolean judgeRow(char[][] board, int row){
        int[] hash = new int[10];
        for(int i = 0; i < 9; ++i){
            if(board[row][i] == '.'){
                continue;
            }
            int num = board[row][i] - '0';
            if(hash[num] == 1){
                return false;
            }
            hash[num] = 1;
        }
    return true;
    }

    boolean judgeCol(char[][] board, int col){
        int[] hash = new int[10];
        for(int i = 0; i < 9; ++i){
            if(board[i][col] == '.'){
                continue;
            }
            int num = board[i][col] - '0';
            if(hash[num] == 1){
                return false;
            }
            hash[num] = 1;
        }
    return true;
    }

    boolean judgeBoard(char[][] board, int row, int col){
        int[] hash = new int[10];
        for(int i = 0; i < 3; ++i){
            for(int j = 0; j < 3; ++j){
                if(board[row + i][col + j] == '.'){
                    continue;
                }
                int num = board[row + i][col + j] - '0';
                if(hash[num] == 1){
                    return false;
                }
                hash[num] = 1;
            }
        }
    return true;
    }

    public boolean isValidSudoku(char[][] board) {
        for(int i = 0; i < 9; ++i){
            if(judgeCol(board, i) == false || judgeRow(board, i) == false){
                return false;
            }
        }
        for(int i = 0; i < 9; i += 3){
            for(int j = 0; j < 9; j += 3){
                if(judgeBoard(board, i , j) == false){
                    return false;
                }
            }
        }
    return true;
    }
}

1.4 解题思路

1. 用哈希表判断一行，一列或者一个九宫格中是否有相同的数字即可。
2. 判断一行就是行值固定，列数9列；判断一列就是列值固定，行数9列；判断九宫格就是九宫格左上角固定，从左往右三列，从上往下三行。

2、螺旋矩阵

2.1 题目链接

点击跳转到题目位置

2.2 题目描述

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

提示：

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 10
• loo-100 <= matrix[i][j] <= 100

2.3 解题代码

class Solution {
    int[][] dir = {
        {0, 1},
        {1, 0},
        {0, -1},
        {-1, 0},
    };

    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] hash = new int[m][n];
        List<Integer> ret = new ArrayList<Integer>();
        int i = 0;
        int row = 0;
        int col = 0;
        int flag = 0;
        while(i < m * n){
            hash[row][col] = 1;
            ret.add(matrix[row][col]);
            int next_row = row + dir[flag][0]; 
            int next_col = col + dir[flag][1];
            if(next_row < 0 || next_row >= m || next_col < 0 || next_col >= n || 
                hash[next_row][next_col] == 1){
                flag = (flag + 1) % 4;
            } 
            row += dir[flag][0];
            col += dir[flag][1];
            ++i;
        }
    return ret;
    }
}

2.4 解题思路

1. 四方向遍历，用数组来表示从左往右，从上往下，从右往左，从下往上。
2. 用(flag + 1) % 4 来进行控制状态的变化。
3. 之后遍历二维矩阵m * n次即可。

3、旋转图像

3.1 题目链接

点击跳转到题目位置

3.2 题目描述

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

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

3.3 解题代码

3.4 解题思路

4、矩阵置零

4.1 题目链接

点击跳转到题目位置

4.2 题目描述

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

提示：

• m == matrix.length
• n == matrix[0].length
• 1 <= m, n <= 200
• -2³¹ <= matrix[i][j] <= 2³¹ - 1

4.3 解题代码

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[] row = new int[m];
        int[] line = new int[n];
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(matrix[i][j] == 0){
                    row[i] = 1;
                    line[j] = 1;
                }
            }
        }
        for(int i = 0; i < m; ++i){
            if(row[i] == 1){
                for(int j = 0; j < n; ++j){
                    matrix[i][j] = 0;
                }
            }
        }
        for(int i = 0; i < n; ++i){
            if(line[i] == 1){
                for(int j = 0; j < m; ++j){
                    matrix[j][i] = 0;
                }
            }
        }
    }
}

4.4 解题思路

1. 遍历矩阵，用哈希表row和哈希表col来表示某一行或者某一列需要全部置0.
2. 按行和列遍历矩阵，来将矩阵的一行或者一列置0。

5、生命游戏

5.1 题目链接

点击跳转到题目位置

5.2 题目描述

根据 百度百科 ， 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

1. 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
2. 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
3. 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
4. 如果死细胞周围正好有三个活细胞，则该位置死细胞复活；

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是 同时 发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。

给定当前 board 的状态，更新 board 到下一个状态。

注意 你不需要返回任何东西。

提示：

• m == board.length
• n == board[i].length
• 1 <= m, n <= 25
• board[i][j] 为 0 或 1

5.3 解题代码

5.4 解题思路