题目1

36. 有效的数独【中等】

题解

如果按照规则行、列、3*3矩阵挨个试的话，工作量巨大…所以怎么才能降低复杂度呢？是这道题要重点考虑的问题

可以使用哈希表记录每一行、每一列和每一个小九宫格中，每个数字出现的次数。只需要遍历数独一次，在遍历的过程中更新哈希表中的计数，并判断是否满足有效的数独的条件即可。

class Solution {
    public boolean isValidSudoku(char[][] board) {
        int rows[][]=new int[9][9];//行
        int columns[][]=new int[9][9];//列
        int three[][][]=new int[3][3][9];//小九宫格

        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                if(board[i][j]!='.'){
                    int index=board[i][j]-'0'-1;//字符转换为数字
                    rows[i][index]++;
                    columns[index][j]++;
                    three[i/3][j/3][index]++;//注意怎么表示小九宫格的哈希表
                    if(rows[i][index]>1||columns[index][j]>1||three[i/3][j/3][index]>1)
                        return false;
                }
            }
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

时间复杂度：$O(1)$，数独大小是固定的，因此复杂度为O(1)

空间复杂度：$O(1)$，由于数独大小固定，因此哈希表大小也固定，复杂度为O(1)

题目2

73. 矩阵置零【中等】

题解

使用标记数组

使用两个数组row[]和column[]标记哪行哪列有0

class Solution {
    public void setZeroes(int[][] matrix) {
        int m=matrix.length,n=matrix[0].length;
        boolean[] row=new boolean[m];
        boolean[] column=new boolean[n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                //元素为0,行列打标记
                if(matrix[i][j]==0){
                    row[i]=true;
                    column[j]=true;
                }
            }
        }
        //根据标记,行列赋零
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(row[i]==true||column[j]==true)
                    matrix[i][j]=0;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

时间复杂度：$O(mn)$

空间复杂度：$O(m+n)$

两个标记变量

我们可以用矩阵的第一行和第一列代替方法一中的两个标记数组，以达到 O(1) 的额外空间。但这样会导致原数组的第一行和第一列被修改，无法记录它们是否原本包含 0。因此我们需要额外使用两个标记变量分别记录第一行和第一列是否原本包含 0。

class Solution {
    public void setZeroes(int[][] matrix) {
        int m=matrix.length,n=matrix[0].length;
        boolean row0=false,col0=false;
        //第一行是否包含0
        for(int i=0;i<n;i++){
            if(matrix[0][i]==0){
                row0=true;
            }
        }
        //第一列是否包含0
        for(int i=0;i<m;i++){
            if(matrix[i][0]==0){
                col0=true;
            }
        }
        //打标记
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(matrix[i][j]==0){
                    matrix[i][0]=0;
                    matrix[0][j]=0;
                }
            }
        }
        //根据标记,行列赋零
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(matrix[i][0]==0||matrix[0][j]==0)
                    matrix[i][j]=0;
            }
        }
        //特殊处理第一行
        if(row0==true){
            for(int j=0;j<n;j++){
                matrix[0][j]=0;
            }
        }
        //特殊处理第一列
        if(col0==true){
            for(int i=0;i<m;i++){
                matrix[i][0]=0;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

时间复杂度：$O(mn)$

空间复杂度：$O(1)$

一个标记变量

我们可以对方法二进一步优化，只使用一个标记变量记录第一列是否原本存在 0。这样，第一列的第一个元素 matrix[0][0] 即可以标记第一行是否出现 0。但为了防止每一列的第一个元素被提前更新，我们需要从最后一行开始，倒序地处理矩阵元素。

class Solution {
    public void setZeroes(int[][] matrix) {
        int m=matrix.length,n=matrix[0].length;
        boolean col0=false;
        for(int i=0;i<m;i++){
            //第一列是否包含0
            if(matrix[i][0]==0){
                col0=true;
            }
            //打标记
            for(int j=1;j<n;j++){
                if(matrix[i][j]==0){
                    matrix[i][0]=0;
                    matrix[0][j]=0;
                }
            }
        }
        //根据标记,行列赋零
        for(int i=m-1;i>=0;i--){
            for(int j=1;j<n;j++){
                if(matrix[i][0]==0||matrix[0][j]==0)
                    matrix[i][j]=0;
            }
            //特殊处理第一列
            if(col0==true){
                matrix[i][0]=0;
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

时间复杂度：$O(mn)$

空间复杂度：$O(1)$