CSU 1605 数独

题目大意：

9宫格每个位置都有对应的分数，填完数独后根据对应位置的分数相加之和求个最大值，不存在输出-1

说什么用位运算加速可以解决问题，但是对着标程还是T，最近学了dlx，发现这样解决数独快了很多

位运算加速我确实写不出了，直接用dlx来做这道题目

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 #include <queue>
 #include <climits>
 #include <cmath>
 
 using namespace std;
 #define N 1000
 #define MAXNODE 1000000
 const int INF = INT_MAX;
 const double eps = 1e-;
 
 int a[][];
 char str[];
 
 int belong[][] =  {
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                         {,,,,,,,,},
                     };
 int sc[][] = {
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                     {,,,,,,,,},
                };
 
 void printM()
 {
     for(int i= ; i< ; i++)
         for(int j= ; j< ; j++){
            if(j<) printf("%d " , a[i][j]);
            else printf("%d\n" , a[i][j]);
         }
 }
 
 struct DLX{
     int n ,m , size;
     int col[MAXNODE] , row[MAXNODE];
     int U[MAXNODE] , D[MAXNODE] , L[MAXNODE] , R[MAXNODE];
     int cnt_col[N] , first[N];
     int ans[] , minv;
 
     void init(int _n , int _m)
     {
         n = _n , m = _m;
         size= m ;
         for(int i= ; i<=m ; i++){
             L[i] = i- , R[i] = i+;
             U[i] = D[i] = i;
         }
         L[] = m , R[m] = ;
         for(int i= ; i<=m ; i++) cnt_col[i] = ;
         for(int i= ; i<=n ; i++) first[i] = -;
         minv = ;
     }
 
     void link(int r , int c)
     {
         ++size;
         U[D[c]] = size , D[size] = D[c];
         U[size] = c , D[c] = size;
 
         if(first[r]<) L[size]=R[size]=first[r] = size;
         else{
             L[R[first[r]]] = size , R[size] = R[first[r]];
             L[size] = first[r] , R[first[r]] = size;
         }
         row[size] = r , col[size] = c , cnt_col[c]++;
     }
 
     void Remove(int c)
     {
         L[R[c]] = L[c] , R[L[c]] = R[c];
         for(int i=D[c] ; i!=c ; i=D[i]){
             for(int j=R[i] ; j!=i ; j=R[j]){
                 U[D[j]] = U[j] , D[U[j]] = D[j];
                 cnt_col[col[j]]--;
             }
         }
     }
 
     void Resume(int c)
     {
         for(int i=U[c] ; i!=c ; i=U[i]){
             for(int j=L[i] ; j!=i ; j=L[j]){
                 U[D[j]] = D[U[j]] = j;
                 cnt_col[col[j]]++;
             }
         }
       //  printM();
         L[R[c]] = R[L[c]] = c;
     }
 
     void Dance(int d)
     {
         if(!R[]){
             int v = ;
             for(int i= ; i<d ; i++){
                     int r = (ans[i]-)/;
                     int c = ((ans[i]-)%)/;
                     a[r][c] = ((ans[i]-)%)+;
                     v+=a[r][c]*sc[r][c];
             }
             minv=max(minv , v);
             return;
         }
         int st=R[];
         for(int i=R[] ; i!= ; i=R[i])
             if(cnt_col[i]<cnt_col[st])
                 st = i;
         Remove(st);
         for(int i=D[st] ; i!=st ; i=D[i]){
             ans[d] = row[i];
             for(int j=R[i] ; j!=i ; j=R[j]) Remove(col[j]);
             Dance(d+);
             for(int j=L[i] ; j!=i ; j=L[j]) Resume(col[j]);
         }
         Resume(st);
         return ;
     }
 
 }dlx;
 
 int main()
 {
   //  freopen("a.in" , "r" , stdin);
     int T;
     scanf("%d" , &T);
     while(T--)
     {
         for(int i= ; i< ; i++){
             for(int j= ; j< ; j++){
                 scanf("%d" , &a[i][j]);
             }
         }
         dlx.init( , );
         for(int i= ; i< ; i++)
             for(int j= ; j< ; j++)
             {
                 if(a[i][j]){
                     dlx.link((i*+j)*+a[i][j] , i*+a[i][j]);
                     dlx.link((i*+j)*+a[i][j] , +j*+a[i][j]);
                     dlx.link((i*+j)*+a[i][j] , +(belong[i][j]-)*+a[i][j]);
                     dlx.link((i*+j)*+a[i][j] , +i*+j+);
                 }
                 else{
                     for(int k= ; k<= ; k++){
                         dlx.link((i*+j)*+k , i*+k);
                         dlx.link((i*+j)*+k , +j*+k);
                         dlx.link((i*+j)*+k , +(belong[i][j]-)*+k);
                         dlx.link((i*+j)*+k , +i*+j+);
                     }
                 }
             }
         dlx.Dance();
         if(!dlx.minv) puts("-1");
         else printf("%d\n" , dlx.minv);
     }
 
     return ;
 }