2021寒假每日一题《数独检查》

数独检查

题目来源：Google Kickstart2013 Round B Problem A
时间限制：\(1000ms\) 内存限制：\(64mb\)

题目描述

数独是一种流行的单人游戏。
目标是用数字填充 \(9*9\) 矩阵，使每列，每行和所有 \(9\) 个非重叠的 \(3*3\) 子矩阵包含从 \(1\) 到 \(9\) 的所有数字。
每个 \(9*9\) 矩阵在游戏开始时都会有部分数字已经给出，通常有一个独特的解决方案。


给定完成的 \(N^2 ∗ N^2\) 数独矩阵，你的任务是确定它是否是有效的解决方案。
有效的解决方案必须满足以下条件：

• 每行包含从 \(1\) 到 \(N^2\) 的每个数字，每个数字一次。
• 每列包含从 \(1\) 到 \(N^2\) 的每个数字，每个数字一次。
• 将 \(N^2 ∗ N^2\) 矩阵划分为 \(N^2\) 个非重叠 \(N ∗ N\) 子矩阵。 每个子矩阵包含从 \(1\) 到 \(N^2\) 的每个数字，每个数字一次。

你无需担心问题答案的唯一性，只需检查给定矩阵是否是有效的解决方案即可。

输入格式

第一行包含整数 \(T\) ，表示共有 \(T\) 组测试数据。
每组数据第一行包含整数 \(N\) 。
接下来 \(N^2\) 行，每行包含 \(N^2\) 个数字（均不超过1000），用来描述完整的数独矩阵。

输出格式

每组数据输出一个结果，每个结果占一行。
结果表示为“Case #x: y”，其中x是组别编号（从1开始），如果给定矩阵是有效方案则y是Yes，否则y是No。

数据范围

\(1 ≤ T ≤ 100\) ,
\(3 ≤ N ≤ 6\)

样例输入

3
3
5 3 4 6 7 8 9 1 2
6 7 2 1 9 5 3 4 8
1 9 8 3 4 2 5 6 7
8 5 9 7 6 1 4 2 3
4 2 6 8 5 3 7 9 1
7 1 3 9 2 4 8 5 6
9 6 1 5 3 7 2 8 4
2 8 7 4 1 9 6 3 5
3 4 5 2 8 6 1 7 9
3
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
3
5 3 4 6 7 8 9 1 2
6 7 2 1 9 5 3 4 8
1 9 8 3 4 2 5 6 7
8 5 9 7 6 1 4 2 3
4 2 6 8 999 3 7 9 1
7 1 3 9 2 4 8 5 6
9 6 1 5 3 7 2 8 4
2 8 7 4 1 9 6 3 5
3 4 5 2 8 6 1 7 9

样例输出

Case #1: Yes
Case #2: No
Case #3: No

解题思路

数独的规则就是每一行、每一列、每一个、单元都由 \([1,n^2]\) 的数组成，且不能重复。
只需要暴力检查所有的情况就可以得到答案了。
第一步检查： 检查每一行，由于是第一个检查，所以同时检查数据规模是否在 \([1,n^2]\) 内。
用一个 \(HashSet\) 来存一行中的元素，调用 HashSet.add() 将这一行的每个数数存入其中，如果数存在，就不会添加进去了。
添加完一行后，调用 HashSet.size() 判断元素个数是否为 \(N^2\) 个，如果不是，则返回 false ，如果是，则进行下一步检查。
每行执行完后，记得调用 HashSet.clear() 将其清空。

第二步检查： 检查每列，方法同上。\(HashSet\)中存放的是每列的元素。

第三部检查： 检查每个 \(N*N\) 单元内的元素。
使用4层循环，将每个单元单独列出，同样使用\(HashSet\)存放元素。

for (int i = 0; i < m; i += n) {
    for (int j = 0; j < m; j += n) {
        for (int k = i; k < i + n; k++) {
            for (int l = j; l < j + n; l++) {
                hashset.add(sudoku[k][l]);
            }
        }
        if (hashset.size() < m) {
            return false;
        }
        hashset.clear();
    }
}

如果全部检查通过，则数独成立，输出 Case #%d: Yes 即可。
如果未通过则输出 Case #%d: No 。

解题代码-Java

import java.util.Scanner;
import java.util.HashSet;

public class Main {
    static boolean verifySudoku(int n, int[][] sudoku) {
        int m = n * n;
        //检查每行是否符合要求，同时检查数据规模是否符合要求
        HashSet<Integer> hashset = new HashSet<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                if (sudoku[i][j] < 1 || sudoku[i][j] > m) {
                    return false;
                }
                hashset.add(sudoku[i][j]);
            }
            if (hashset.size() < m) {
                return false;
            }
            hashset.clear();
        }
        //检查每列是否符合要求
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < m; j++) {
                hashset.add(sudoku[j][i]);
            }
            if (hashset.size() < m) {
                return false;
            }
            hashset.clear();
        }
        //检查每个n*n格子内是否符合要求
        for (int i = 0; i < m; i += n) {
            for (int j = 0; j < m; j += n) {
                for (int k = i; k < i + n; k++) {
                    for (int l = j; l < j + n; l++) {
                        hashset.add(sudoku[k][l]);
                    }
                }
                if (hashset.size() < m) {
                    return false;
                }
                hashset.clear();
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int t = input.nextInt();
        int count = 1;
        while (count <= t) {
            int n = input.nextInt();
            int[][] sudoku = new int[n * n][n * n];
            for (int i = 0; i < n * n; i++) {
                for (int j = 0; j < n * n; j++) {
                    sudoku[i][j] = input.nextInt();
                }
            }
            String flag = "No";
            if (verifySudoku(n, sudoku)) {
                flag = "Yes";
            }
            System.out.printf("Case #%d: %s", count, flag);
            count++;
        }
        input.close();
    }
}