題目連結

數獨是一種流行的單人遊戲。

目標是用數字填充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<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int M = 55;
using namespace std;

int dp[M][M];
int vis[N];

void solve(){
    int t;
    cin>>t;
    int tot=0;
    while(t--){
        bool flag=0;
        int n;
        cin>>n;
        int nn=n*n;
        rep(i,1,nn){
            rep(j,1,nn){
                cin>>dp[i][j];
                if(dp[i][j]>nn) flag=1;
            }
        }
        if(flag){
            printf("Case #%d: No\n",++tot);
            continue;
        }
        /// 行列檢查
        rep(i,1,nn){
            memset(vis,0,sizeof(vis));
            /// 行
            rep(j,1,nn){
                vis[dp[i][j]]++;
                if(vis[dp[i][j]]>1){
                    flag=1;
                    break;
                }
            }
            if(flag) break;
            memset(vis,0,sizeof(vis));
            /// 列
            rep(j,1,nn){
                vis[dp[j][i]]++;
                if(vis[dp[j][i]]>1){
                    flag=1;
                    break;
                }
            }
        }
        if(flag){
            printf("Case #%d: No\n",++tot);
            continue;
        }
        ///小矩陣檢查
        for(int i=1;i<=nn;i+=n){
            for(int j=1;j<=nn;j+=n){
                memset(vis,0,sizeof(vis));
                rep(k,i,i+n-1){
                    rep(w,j,j+n-1){
                        vis[dp[k][w]]++;
                        if(vis[dp[k][w]]>1){
                            flag=1;
                            break;
                        }
                    }
                }
            }
        }
        if(flag){
            printf("Case #%d: No\n",++tot);
            continue;
        }
        if(!flag){
            printf("Case #%d: Yes\n",++tot);
            continue;
        }
    }
}

int main() {
    solve();
	return 0;
}