ACWing寒假每日一题---703. 数独检查

原题链接
数独是一种流行的单人游戏。

目标是用数字填充9x9矩阵，使每列，每行和所有9个非重叠的3x3子矩阵包含从1到9的所有数字。

每个9x9矩阵在游戏开始时都会有部分数字已经给出，通常有一个独特的解决方案。

给定完成的N2∗N2数独矩阵，你的任务是确定它是否是有效的解决方案。

有效的解决方案必须满足以下条件：

每行包含从1到N2的每个数字，每个数字一次。
每列包含从1到N2的每个数字，每个数字一次。
将N2∗N2矩阵划分为N2个非重叠N∗N子矩阵。 每个子矩阵包含从1到N2的每个数字，每个数字一次。
你无需担心问题的唯一性，只需检查给定矩阵是否是有效的解决方案即可。

输入格式
第一行包含整数T，表示共有T组测试数据。

每组数据第一行包含整数N。

接下来N2行，每行包含N2个数字（均不超过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

按照上面的要求排除情况即可

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

int t,n;
int arr[40][40];
int sign[40];
int main()
{
    int c = 0;
    cin>>t;
    while(t--)
    {
        bool flag = 1;
        cin>>n;
        int N = n*n;
        for(int i=1;i<=N;i++)
        {
            for(int j=1;j<=N;j++)
            {
                cin>>arr[i][j];
                if(arr[i][j] > N)
                flag = 0;
            }
        }
        if(!flag){
            printf("Case #%d: No\n",++c);
            continue;
        }
        
        //检查行列
        for(int i=1;i<=N;i++)
        {
            memset(sign,0,sizeof(sign));
            for(int j=1;j<=N;j++)  //检查行
            {
                sign[arr[i][j]]++;
                if(sign[arr[i][j]] > 1)
                {
                    flag = 0;break;
                }
            }
            
            if(!flag) break;
            memset(sign,0,sizeof(sign));
            
            for(int j=1;j<=N;j++)  //检查列
            {
                sign[arr[j][i]]++;
                if(sign[arr[j][i]] > 1)
                {
                    flag = 0;break;
                }
            }
        }
        
        if(!flag){
            printf("Case #%d: No\n",++c);
            continue;
        }
        //检查小矩阵n*n
        for(int i=1;i<=N;i+=n)
        {
            for(int j=1;j<=N;j+=n)
            {
                memset(sign,0,sizeof(sign));
                for(int k=i;k<=i+n-1;k++)
                {
                    for(int w=j;w<=j+n-1;w++)
                    {
                        sign[arr[k][w]]++;
                        if(sign[arr[k][w]] > 1)
                        {
                            flag = 0;break;
                        }
                    }
                }
            }
        }
        
        
        if(!flag){
            printf("Case #%d: No\n",++c);
            continue;
        }
        if(flag){
            printf("Case #%d: Yes\n",++c);
            continue;
        }
    }
    return 0;
}