Dancing Links-----C - Square Destroyer

The left figure below shows a complete 33 grid made with 2(3*4) (=24) matchsticks. The lengths of all matchsticks are one. You can find many squares of different sizes in the grid. The size of a square is the length of its side. In the grid shown in the left figure, there are 9 squares of size one, 4 squares of size two, and 1 square of size three.

Each matchstick of the complete grid is identified with a unique number which is assigned from left to right and from top to bottom as shown in the left figure. If you take some matchsticks out from the complete grid, then some squares in the grid will be destroyed, which results in an incomplete 33 grid. The right figure illustrates an incomplete 33 grid after removing three matchsticks numbered with 12, 17 and 23. This removal destroys 5 squares of size one, 3 squares of size two, and 1 square of size three. Consequently, the incomplete grid does not have squares of size three, but still has 4 squares of size one and 1 square of size two.

As input, you are given a (complete or incomplete) nn grid made with no more than 2n(n+1) matchsticks for a natural number 5 <= n . Your task is to compute the minimum number of matchsticks taken
out to destroy all the squares existing in the input nn grid.
Input
The input consists of T test cases. The number of test cases (T ) is given in the first line of the input file.
Each test case consists of two lines: The first line contains a natural number n , not greater than 5, which implies you are given a (complete or incomplete) nn grid as input, and the second line begins with a nonnegative integer k , the number of matchsticks that are missing from the complete nn grid, followed by
k numbers specifying the matchsticks. Note that if k is equal to zero, then the input grid is a complete nn grid; otherwise, the input grid is an incomplete nn grid such that the specified k matchsticks are missing from the complete n*n grid.
Output
Print exactly one line for each test case. The line should contain the minimum number of matchsticks that have to be taken out to destroy all the squares in the input grid.
Sample Input
2
2
0
3
3 12 17 23
Sample Output
3
3

Dancing Links矩阵的行代表问题的所有情况，列代表问题的约束条件。
所以01矩阵的行是火柴编号，列是不同大小的正方形；
一直嫌找火柴编号与正方形的关系烦，一直不想自己动手找，但其实枚举正方形的左下角的点，在找找由该点延伸出来的火柴的编号，也是比较好找的
然后直接DLX的重复覆盖即可。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;
typedef long long LL;
const int inf = 0x3f3f3f3f;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
//最大行数
const int MN = 1005;
//最大列数
const int MM = 1005;
//最大点数
const int MNN = 1e5 + 5 + MM;

struct DLX
{
    //一共n行m列，s个节点
    int n,m,s;
    //交叉十字链表组成部分
    //第i个节点的上U下D左L右R，所在位置row行col列
    int U[MNN],D[MNN],L[MNN],R[MNN],row[MNN],col[MNN];
    //H数组记录行选择指针，S数组记录覆盖个数
    int H[MN],S[MM];
    //res记录行个数，ans数组记录可行解
    int res,ans[MN];
    //初始化空表
    void init(int x,int y)
    {
        n = x,m = y;
        //其中0节点作为head节点,其他作为列首节点
        for(int i = 0;i <= m;++i){
            U[i] = D[i] = i;
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0;L[0] = m;
        s = m;
        memset(S,0,sizeof(S));
        memset(H,-1,sizeof(H));
    }
    void Insert(int r,int c)
    {
        //节点数加一，设置s节点所处位置，以及S列覆盖个数加一
        s++;row[s] = r;col[s] = c;S[c]++;
        //将s节点插入对应列中
        D[s] = D[c];U[D[c]] = s;
        U[s] = c;D[c] = s;
        if(H[r] < 0){//如果该行没有元素，H[r]标记该行起始节点
            H[r] = L[s] = R[s] = s;
        }else{
            //将该节点插入该行第一个节点后面
            R[s] = R[H[r]];
            L[R[H[r]]] = s;
            L[s] = H[r];
            R[H[r]] = s;
        }
    }
    //精确覆盖
    void Remove(int c)
    {
        //删除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];
                //将该列上的S数组减一
                --S[col[j]];
            }
        }
    }
    void resume(int c)
    {
        //恢复c列
        for(int i = U[c];i != c;i = U[i]){//枚举该列元素
            for(int j = L[i];j != i;j = L[j]){
                U[D[j]] = j;D[U[j]] = j;
                ++S[col[j]];
            }
        }
        L[R[c]] = c;R[L[c]] = c;
    }
    bool dance(int deep)
    {
        if(res < deep) return false;
        //当矩阵为空时,说明找到一个可行解，算法终止
        if(R[0] == 0){
            res = min(res,deep);
            return true;
        }
        //找到节点数最少的列，枚举这列上的所有行
        int c = R[0];
        for(int i = R[0];i != 0;i = R[i]){
            if(S[i] < S[c]){
                c = i;
            }
        }
        //删除节点数最少的列
        Remove(c);
        for(int i = D[c];i != c;i = D[i]){
            //将行r放入当前解
            ans[deep] = row[i];
            //行上节点对应的列上进行删除
            for(int j = R[i];j != i;j = R[j])
                Remove(col[j]);
            //进入下一层
            dance(deep + 1);
            //对行上的节点对应的列进行恢复
            for(int j = L[i];j != i;j = L[j])
                resume(col[j]);
        }
        //恢复节点数最少列
        resume(c);
        return false;
    }

    //重复覆盖
    //将列与矩阵完全分开
    void Remove1(int c)
    {
        for(int i = D[c];i != c;i = D[i]){
            L[R[i]] = L[i];
            R[L[i]] = R[i];
        }
    }
    void resume1(int c)
    {
        for(int i = D[c];i != c;i = D[i]){
            L[R[i]] = R[L[i]] = i;
        }
    }
    int vis[MNN];
    //估价函数，模拟删除列，H()，函数返回的是至少还需要多少行才能完成重复覆盖
    int A()
    {
        int dis = 0;
        for(int i = R[0];i != 0;i = R[i]) vis[i] = 0;
        for(int i = R[0];i != 0;i = R[i]){
            if(!vis[i]){
                dis++;vis[i] = 1;
                for(int j = D[i];j != i;j = D[j]){
                    for(int k = R[j];k != j;k = R[k]){
                        vis[col[k]] = 1;
                    }
                }
            }
        }
        return dis;
    }

    void dfs(int deep)
    {
        if(!R[0]){
            //cout << res << endl;
            res = min(res,deep);
            return ;
        }
        if(deep + A() >= res) return ;
        int c = R[0];
        for(int i = R[0];i != 0;i = R[i]){
            if(S[i] < S[c]){
                c = i;
            }
        }
        for(int i = D[c];i != c;i = D[i]){
            //每次将第i列其他节点删除，只保留第i节点，为了找该行的节点
            Remove1(i);
            //将列上的节点完全与矩阵脱离，只删列首节点是不行的
            for(int j = R[i];j != i;j = R[j]){
                Remove1(j);
            }
            dfs(deep + 1);
            for(int j = L[i];j != i;j = L[j]){
                resume1(j);
            }
            resume1(i);
        }
    }
}dlx;

//第i个火柴会影响第j个正方形
bool flag[80][105];

void init(int n)
{
    memset(flag,false,sizeof(flag));
    int cnt = 1;
    for(int s = 1;s <= n;++s){
        for(int i = 1;i <= n - s + 1;++i){
            for(int j = 1;j <= n - s + 1;++j){
                for(int k = 0;k < s;++k){
                    flag[(i - 1) * (2 * n + 1) + j + k][cnt] = true;
                    flag[(i - 1 + s) * (2 * n + 1) + j + k][cnt] = true;
                    flag[i * n + (i - 1) * (n + 1) + j + k * (2 * n + 1)][cnt] = true;
                    flag[i * n + (i - 1) * (n + 1) + j + k * (2 * n + 1) + s][cnt] = true;
                }
                cnt++;
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d",&n);
        int row = 2 * n * (n + 1);
        int col = 0;
        for(int i = 1;i <= n;++i)
            col += i * i;
        dlx.init(row,col);
        init(n);
        bool vis[105];
        memset(vis,false,sizeof(vis));
        scanf("%d",&m);
        while(m--){
            int x;
            scanf("%d",&x);
            for(int i = 1;i <= col;++i){
                if(flag[x][i] && !vis[i]){
                    vis[i] = true;
                    dlx.L[dlx.R[i]] = dlx.L[i];
                    dlx.R[dlx.L[i]] = dlx.R[i];
                    dlx.L[i] = dlx.R[i] = 0;
                }
            }
        }
        for(int i = 1;i <= row;++i){
            for(int j = 1;j <= col;++j){
                if(flag[i][j] && !vis[j]){
                    dlx.Insert(i,j);
                }
            }
        }
        dlx.res = inf;
        dlx.dfs(0);
        printf("%d\n",dlx.res);
    }
    return 0;
}