编程题-判断数独是否正确

判断数独是否正确

绪论

这个题目是我在校招面试某家大公司的在线笔试题（不是BAT），当时第一次用程序做数独，时间也来不及，就没有很好的做出来。(在这里吐槽一下，一个小时10道选择10道填空，2道编程题，确实时间有点紧了，不过编程题难度还没有美团的高)，有点难受，所以写下了这篇文章。

当然，真正的题目有差别，我这里主要是通过整型数组来实现，展示一下原理。我也是个菜鸡，有什么不正确的请联系本人，谢谢。

---

目录

判断数独是否正确

数独定义

逻辑分析

矩阵遍历

行遍历

列遍历

总代码

测试

---

数独定义

数独（shù dú）是源自18世纪瑞士的一种数学游戏。是一种运用纸、笔进行演算的逻辑游戏。玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。【摘自：百度百科】

注：该文中用 0 表示空格，未填写，因为方格中只能填入 [1,9]

 

逻辑分析

 话不多说，先上图

 

 

如果你是第一次用程序的角度来做这道题，不用每一个方格都去判断方格所在行列以及矩阵无重复元素，这样其实做了大量的重复操作，我们需要的是一步到位，简单便捷。

行列无重复元素：遍历对角线，时间复杂度O(n)，可以遍历到每一行每一列。

小矩阵无重复元素：将大矩阵划分为9个小矩阵，小矩阵中遍历一次判断有无重复元素。时间复杂度O(n*n)

行列遍历的原理：

这里通过对角线，遍历了整个每行每列。当然你可以拆分成单独遍历一次每行，一次每列。差别不大

 

矩阵遍历

 这里我将四重循环写成了双重

/**
     * 检查小矩阵内的数字
     * @return 布尔值
     */
    public static boolean checkSubMatrix(int[][] matrix){
        boolean flag = true;
        int y = 0;
        int x = 0;
        while(flag&&(y<3)){
            int startX = 3*x;
            int startY = 3*y;
            while(flag&&(startY<3*y+3)){
                Set<Integer> set = new HashSet<>();
                if (0<matrix[startY][startX]&&matrix[startY][startX]<10){
                    flag = set.add(matrix[startY][startX]);
                }
                startX++;
                if (startX>=3*x+3){
                    startY++;
                    startX = 3*x;
                }
            }
            x++;
            if (x>=3){
                y++;
                x=0;
            }
        }
        return flag;
    }

这里我解释一下上面代码的变量：

第一个小矩阵：x:[0,3) y:[0,3)

第一个小矩阵：x:[3,6) y:[3,6)

.....

 矩阵的横/纵坐标开始可表示为 3*0 3*1 3*2，当然这里因为数独，直接将3写死，因为数独是9*9的矩阵。

每个小矩阵的边长都是三，StartX和StartY为指针，通过一个while进行遍历矩阵

 

行遍历

    /**
     * 检查某行是否满足
     * @param row 一行的数组
     * @return 布尔值
     */
    public static boolean checkX(int[] row){
        Set<Integer> set = new HashSet<>();
        boolean flag = true;
        for (int i = 0;i < row.length && flag;i++){
            if (0<row[i] && row[i]<10){
                flag = set.add(row[i]);
            }
        }
        return flag;
    }

行遍历就是一个循环将1-9的元素放入set中，通过add返回的 boolean 判断是否重复

列遍历

    /**
     * 判断某一列是否满足
     * @param x 横坐标
     * @param matrix 矩阵
     * @return 布尔值
     */
    public static boolean checkY(int x,int[][] matrix){
        boolean flag = true;
        Set<Integer> set = new HashSet<>();
        for (int i = 0;i<matrix.length && flag;i++){
            if (0<matrix[i][x] && matrix[i][x]<10){
                flag = set.add(matrix[i][x]);
            }
        }
        return flag;
    }

列遍历需要我们传入一个列坐标（第几列），原理同行遍历检查的一样

 

总代码

public class CheckUtil {
    public static boolean check(int[][] matrix){
        boolean flag = true;
        flag = checkSubMatrix(matrix);
        System.out.println("小矩阵正常");
        for (int i = 0;i<matrix.length && flag;i++){
            flag = checkX(matrix[i]);
            if(!flag){break;}
            flag = checkY(i,matrix);
        }
        return flag;
    }

    /**
     * 检查某行是否满足
     * @param row 一行的数组
     * @return 布尔值
     */
    public static boolean checkX(int[] row){
        Set<Integer> set = new HashSet<>();
        boolean flag = true;
        for (int i = 0;i < row.length && flag;i++){
            if (0<row[i] && row[i]<10){
                flag = set.add(row[i]);
            }
        }
        return flag;
    }

    /**
     * 判断某一列是否满足
     * @param x 横坐标
     * @param matrix 矩阵
     * @return 布尔值
     */
    public static boolean checkY(int x,int[][] matrix){
        boolean flag = true;
        Set<Integer> set = new HashSet<>();
        for (int i = 0;i<matrix.length && flag;i++){
            if (0<matrix[i][x] && matrix[i][x]<10){
                flag = set.add(matrix[i][x]);
            }
        }
        return flag;
    }

    /**
     * 检查小矩阵内的数字
     * @return 布尔值
     */
    public static boolean checkSubMatrix(int[][] matrix){
        boolean flag = true;
        int y = 0;
        int x = 0;
        while(flag&&(y<3)){
            int startX = 3*x;
            int startY = 3*y;
            while(flag&&(startY<3*y+3)){
                Set<Integer> set = new HashSet<>();
                if (0<matrix[startY][startX]&&matrix[startY][startX]<10){
                    flag = set.add(matrix[startY][startX]);
                }
                startX++;
                if (startX>=3*x+3){
                    startY++;
                    startX = 3*x;
                }
            }
            x++;
            if (x>=3){
                y++;
                x=0;
            }
        }
        return flag;
    }

}

测试

public class ExecuteMainn {
    public static void main(String[] args) {
        int[][] matrix = new int[][]{
                {4,0,1,0,0,7,2,0,0},
                {0,0,5,0,0,6,9,0,1},
                {0,6,0,0,1,4,0,0,7},
                {6,0,9,0,3,8,0,0,0},
                {0,0,0,6,0,0,0,5,8},
                {0,5,3,7,0,0,0,9,0},
                {9,1,0,0,7,0,0,0,0},
                {0,4,0,0,2,0,1,0,0},
                {0,0,0,1,0,0,0,7,3}};
        System.out.println(check(matrix));
        int y = 0;
        int x = 0;
        while(y<9){
            System.out.print(matrix[y][x++]+"\t");
            if (x>8){
                x=0;
                y++;
                System.out.println();
            }
        }
    }
}

控制台

小矩阵正常
true
4	0	1	0	0	7	2	0	0	
0	0	5	0	0	6	9	0	1	
0	6	0	0	1	4	0	0	7	
6	0	9	0	3	8	0	0	0	
0	0	0	6	0	0	0	5	8	
0	5	3	7	0	0	0	9	0	
9	1	0	0	7	0	0	0	0	
0	4	0	0	2	0	1	0	0	
0	0	0	1	0	0	0	7	3	

Process finished with exit code 0

可以看到，首先进行的小矩阵判断，为真，才开始判断的行和列。【这里我没有对行列判断和小矩阵判断的复杂度分析，可以将复杂度低的先判断】。

明显可以看出打印出的矩阵是满足数独的。