NOIP 2009 靶形数独（DLX）

小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。
靶形数独的方格同普通数独一样，在 9 格宽×9 格高的大九宫格中有9 个3 格宽×3 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入1 到9 的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。（如图）

上图具体的分值分布是：最里面一格（黄色区域）为 10 分，黄色区域外面的一圈（红色区域）每个格子为9 分，再外面一圈（蓝色区域）每个格子为8 分，蓝色区域外面一圈（棕色区域）每个格子为7 分，最外面一圈（白色区域）每个格子为6 分，如上图所示。比赛的要求是：每个人必须完成一个给定的数独（每个给定数独可能有不同的填法），而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为2829。游戏规定，将以总分数的高低决出胜负。

由于求胜心切，小城找到了善于编程的你，让你帮他求出，对于给定的靶形数独，能够得到的最高分数。

刚学了DLX闲着没事去试了一下各种90、95的NOIP靶形数独，结果速度确实快了好几倍恩恩。

 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 using namespace std;
 
 const int MAXC =  + ;
 const int MAXR =  + ;
 const int MAXP = MAXR *  + MAXC;
 
 const int p[][] = {
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,},
 {,,,,,,,,}
 };
 
 struct DLX {
     int n, sz;//列数，结点总数
     int sum[MAXC];//每列拥有的结点数
     int row[MAXP], col[MAXP], get[MAXP];//结点所在的行和列
     int left[MAXP], right[MAXP], up[MAXP], down[MAXP];//十字链表
     int ans;
 
     void init(int nn) {
         n = nn;
         for(int i = ; i <= n; ++i) {
             up[i] = down[i] = i;
             left[i] = i - ; right[i] = i + ;
         }
         right[n] = ; left[] = n;
         sz = n + ;
         memset(sum, , sizeof(sum));
     }
 
     void add_row(int r, int _get, vector<int> columns) {
         int first = sz;
         for(int i = , len = columns.size(); i < len; ++i) {
             int c = columns[i];
             left[sz] = sz - ; right[sz] = sz + ; down[sz] = c; up[sz] = up[c];
             down[up[c]] = sz; up[c] = sz;
             row[sz] = r; col[sz] = c; get[sz] = _get;
             ++sum[c]; ++sz;
         }
         right[sz - ] = first; left[first] = sz - ;
     }
 
     void remove(int c) {
         left[right[c]] = left[c];
         right[left[c]] = right[c];
         for(int i = down[c]; i != c; i = down[i])
             for(int j = right[i]; j != i; j = right[j]) {
                 up[down[j]] = up[j]; down[up[j]] = down[j]; --sum[col[j]];
             }
     }
 
     void restore(int c) {
         for(int i = up[c]; i != c; i = up[i])
             for(int j = left[i]; j != i; j = left[j]) {
                 up[down[j]] = j; down[up[j]] = j; ++sum[col[j]];
             }
         left[right[c]] = c;
         right[left[c]] = c;
     }
 
     void dfs(int d, int score) {
         if(right[] == ) {
             ans = max(ans, score);
             return ;
         }
         int c = right[];
         for(int i = right[]; i != ; i = right[i]) if(sum[i] < sum[c]) c = i;
         remove(c);
         for(int i = down[c]; i != c; i = down[i]) {
             for(int j = right[i]; j != i; j = right[j]) remove(col[j]);
             dfs(d + , score + get[i]);
             for(int j = left[i]; j != i; j = left[j]) restore(col[j]);
         }
         restore(c);
     }
 
     int solve() {
         ans = -;
         dfs(, );
         return ans;
     }
 };
 
 DLX solver;
 
 const int SLOT = ;
 const int ROW = ;
 const int COL = ;
 const int SUB = ;
 
 inline int encode(int a, int b, int c) {
     return a *  + b *  + c + ;
 }
 
 int puzzle[][];
 
 void read() {
     for(int i = ; i < ; ++i)
         for(int j = ; j < ; ++j) scanf("%d", &puzzle[i][j]);
 }
 
 int main() {
     read();
     solver.init();
     for(int r = ; r < ; ++r)
         for(int c = ; c < ; ++c)
             for(int v = ; v < ; ++v)
                 if(puzzle[r][c] ==  || puzzle[r][c] ==  + v) {
                     vector<int> columns;
                     columns.push_back(encode(SLOT, r, c));
                     columns.push_back(encode(ROW, r, v));
                     columns.push_back(encode(COL, c, v));
                     columns.push_back(encode(SUB, (r/)*+c/, v));
                     solver.add_row(encode(r, c, v), p[r][c] * ( + v), columns);
                 }
     printf("%d\n", solver.solve());
 }