【id:502】【34分】A. 数独验证（二维数组，函数）

题目描述

数独是一种填数游戏，玩家需要根据9×9盘面上的已知数字，推理出所有剩余空格的数字，并满足每一行、每一列、每一个粗线宫（3*3）内的数字均含1-9，不重复。

每个数独有唯一解。

输入填数后的9×9盘面，写函数判断其是否是解，返回1或0。

输入

每组测试数据是1个9*9的数字阵（元素值:1~9）

输出

每组测试数据，如果满足数独要求，输出YES，否则输出NO

输入输出样例

输入样例1 <-复制
2
6 8 2 3 7 4 9 1 5
7 1 5 6 2 9 3 4 8
3 4 9 8 5 1 6 7 2
4 9 3 2 6 7 5 8 1
1 5 7 4 8 3 2 6 9
8 2 6 9 1 5 4 3 7
9 6 1 5 3 8 7 2 4
2 7 4 1 9 6 8 5 3
5 3 8 7 4 2 1 9 6
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9 1
3 4 5 6 7 8 9 1 2
4 5 6 7 8 9 1 2 3
5 6 7 8 9 1 2 3 4
6 7 8 9 1 2 3 4 5
7 8 9 1 2 3 4 5 6
8 9 1 2 3 4 5 6 7
9 1 2 3 4 5 6 7 8


输出样例1
YES
NO

AC代码

#include<stdio.h> 
#include<string.h>

// 判断数独是否满足要求
int checkSudoku(int a[10][10])
{
	int i, j;
	int b[10], c[10], d[10];
	memset(b, 0, 10 * sizeof(int));
	memset(c, 0, 10 * sizeof(int));
	memset(d, 0, 10 * sizeof(int));

	// 检查每一行是否满足要求
	for (i = 0; i < 9; i++)
	{
		for (j = 0; j < 9; j++)
		{
			if (b[a[i][j]] == -1)
				return 0;
			b[a[i][j]] = -1;
			if (j == 8)
				memset(b, 0, 10 * sizeof(int));
		}
	}

	// 检查每一列是否满足要求
	for (i = 0; i < 9; i++)
	{
		for (j = 0; j < 9; j++)
		{
			if (b[a[j][i]] == -1)
				return 0;
			b[a[j][i]] = -1;
			if (j == 8)
				memset(b, 0, 10 * sizeof(int));
		}
	}

	// 检查每一个九宫格是否满足要求
	for (i = 0; i < 9; i += 3)
	{
		for (j = 0; j < 9; j += 3)
		{
			int m, n;
			memset(b, 0, 10 * sizeof(int));
			memset(c, 0, 10 * sizeof(int));
			memset(d, 0, 10 * sizeof(int));
			for (m = i; m < i + 3; m++)
			{
				for (n = j; n < j + 3; n++)
				{
					if (b[a[m][n]] == -1 || c[a[m][n]] == -1 || d[a[m][n]] == -1)
						return 0;
					b[a[m][n]] = -1;
					c[a[m][n]] = -1;
					d[a[m][n]] = -1;
				}
			}
		}
	}

	return 1;
}

int main()
{
	int t, i, j, a[10][10];
	scanf("%d", &t);
	while (t--)
	{
		// 读取数独矩阵
		for (i = 0; i < 9; i++)
		{
			for (j = 0; j < 9; j++)
			{
				scanf("%d", &a[i][j]);
			}
		}

		// 调用函数判断数独是否满足要求
		if (checkSudoku(a) == 1)
			printf("YES\n");
		else
			printf("NO\n");
	}
	return 0;
}

该代码实现了一个函数 checkSudoku() 来判断数独是否满足要求。

首先，使用两个一维数组来检查每一行和每一列是否满足要求，如果某个数字在同一行或同一列中出现了两次以上，则不满足要求。

然后，使用一个二维数组来检查每一个九宫格是否满足要求，同样如果某个数字在同一个九宫格中出现了两次以上，则不满足要求。

在主函数中，首先读取测试次数 t，然后使用嵌套循环读取每组测试数据的数独矩阵。

每读取一组测试数据，调用 checkSudoku() 函数来判断数独是否满足要求，并根据返回值输出对应的结果。

（by 归忆）