数独检查
题目来源:Google Kickstart2013 Round B Problem A
时间限制:
1000
m
s
1000ms
1000ms 内存限制:
64
m
b
64mb
64mb
题目描述
数独是一种流行的单人游戏。
目标是用数字填充
9
∗
9
9*9
9∗9 矩阵,使每列,每行和所有
9
9
9 个非重叠的
3
∗
3
3*3
3∗3 子矩阵包含从
1
1
1 到
9
9
9 的所有数字。
每个
9
∗
9
9*9
9∗9 矩阵在游戏开始时都会有部分数字已经给出,通常有一个独特的解决方案。
给定完成的
N
2
∗
N
2
N^2 ∗ N^2
N2∗N2 数独矩阵,你的任务是确定它是否是有效的解决方案。
有效的解决方案必须满足以下条件:
- 每行包含从 1 1 1 到 N 2 N^2 N2 的每个数字,每个数字一次。
- 每列包含从 1 1 1 到 N 2 N^2 N2 的每个数字,每个数字一次。
- 将 N 2 ∗ N 2 N^2 ∗ N^2 N2∗N2 矩阵划分为 N 2 N^2 N2 个非重叠 N ∗ N N ∗ N N∗N 子矩阵。 每个子矩阵包含从 1 1 1 到 N 2 N^2 N2 的每个数字,每个数字一次。
你无需担心问题答案的唯一性,只需检查给定矩阵是否是有效的解决方案即可。
输入格式
第一行包含整数
T
T
T ,表示共有
T
T
T 组测试数据。
每组数据第一行包含整数
N
N
N 。
接下来
N
2
N^2
N2 行,每行包含
N
2
N^2
N2 个数字(均不超过1000),用来描述完整的数独矩阵。
输出格式
每组数据输出一个结果,每个结果占一行。
结果表示为“Case #x: y”,其中x是组别编号(从1开始),如果给定矩阵是有效方案则y是Yes,否则y是No。
数据范围
1
≤
T
≤
100
1 ≤ T ≤ 100
1≤T≤100 ,
3
≤
N
≤
6
3 ≤ N ≤ 6
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]
[1,n2] 的数组成,且不能重复。
只需要暴力检查所有的情况就可以得到答案了。
第一步检查: 检查每一行,由于是第一个检查,所以同时检查数据规模是否在
[
1
,
n
2
]
[1,n^2]
[1,n2] 内。
用一个
H
a
s
h
S
e
t
HashSet
HashSet 来存一行中的元素,调用 HashSet.add()
将这一行的每个数数存入其中,如果数存在,就不会添加进去了。
添加完一行后,调用 HashSet.size()
判断元素个数是否为
N
2
N^2
N2 个,如果不是,则返回 false
,如果是,则进行下一步检查。
每行执行完后,记得调用 HashSet.clear()
将其清空。
第二步检查: 检查每列,方法同上。 H a s h S e t HashSet HashSet中存放的是每列的元素。
第三部检查: 检查每个
N
∗
N
N*N
N∗N 单元内的元素。
使用4层循环,将每个单元单独列出,同样使用
H
a
s
h
S
e
t
HashSet
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();
}
}