kuangbin专题三DancingLinks总结

于 2018-01-19 11:24:21 发布
阅读量266 收藏
点赞数
分类专栏： kuangbin专题总结 文章标签： acm kuangbin专题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34921856/article/details/79104788
版权

该专题主要分成两个问题：一是精准覆盖问题，二是重复覆盖问题。概括来说精准覆盖问题就是01矩阵中选一些行行使每列有且仅有一个1，而重复覆盖问题就是选最少行使每列至少有一个1。只要想好如何建矩阵，剩下的就是套模板了。
精准覆盖问题:
A - Treasure Map
要覆盖所有的格子，容易想到列为格子的编号，行则为地图的编号，这样就转换成了精准覆盖问题了。
代码如下:

#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 450100;
const int maxn = 505;
const int maxm = 905;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1
    char cans[16*16+10];
    int minans;
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        memset(cans, '\0', sizeof(cans));
        minans = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void remove(int c)//删除节点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[Col[j]];
            }
    }

    void resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    void dance(int d)//深度
    {
        if (R[0] == 0)
        {
            if (d < minans)
                minans = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                remove(Col[j]);
            dance(d + 1);
            for (int j = L[i];j != i;j = L[j])
                resume(Col[j]);
        }
        resume(c);
    }

};

DLX x;



int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        int n, m, p;
        scanf("%d %d %d", &n, &m, &p);
        x.init(p, n*m);
        int x1, y1, x2, y2;
        for (int k = 1;k <= p;k++)
        {
            scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
            for (int i = x1;i < x2;i++)
                for (int j = y1;j < y2;j++)
                    x.link(k, j*n + i + 1);
        }
        x.dance(0);
        if (x.minans == inf)
            puts("-1");
        else
            printf("%d\n", x.minans);
    }
    return 0;
}

D - Sudoku
数独问题的最好的解决方法当然是DLX，对于9*9的数独来说，行为9 * 9 * 9，意为每个格子有9个选择方式，列为(9+9+9) * 9+81意为每行，每列，每个格子都有9个选择方式，而81则限制没一个格子只能选一次。(可以仔细思考思考)

#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 60000;
const int maxn = 800;
const int maxm = 350;

struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1
    char cans[9 * 9 + 10];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        memset(cans, '\0', sizeof(cans));
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void remove(int c)//删除节点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[Col[j]];
            }
    }

    void resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    bool dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansd = d;
            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);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                remove(Col[j]);
            if (dance(d + 1))return true;
            for (int j = L[i];j != i;j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return false;
    }
    void out()
    {
        int kinds, num;
        for (int i = 0;i < ansd;i++)
        {
            kinds = (ans[i]-1) % 9+1;
            num = (ans[i]-1) / 9+1;
            cans[num] = kinds + '0';
        }
        printf("%s\n", cans+1);
    }
};

DLX x;


int main()
{
    char s[9 * 9 + 10];
    while (~scanf("%s",s+1))
    {
        if (s[1] == 'e')break;
        x.init(9 * 9 * 9, 324);
        int Size = strlen(s + 1);
        for (int i = 1;i <= Size;i++)
        {
            int row = (i - 1) / 9 + 1;
            int col = (i - 1) % 9 + 1;
            int grid = ((row - 1) / 3) * 3 + (col - 1) / 3 + 1;
            if (s[i] == '.')
            {
                for (int k = 1;k <= 9;k++)
                {
                    x.link((i - 1) * 9 + k, i);
                    x.link((i - 1) * 9 + k, 81 + (row - 1) * 9+k);
                    x.link((i - 1) * 9 + k, 81 * 2 + (col - 1) * 9+k);
                    x.link((i - 1) * 9 + k, 81 * 3 + (grid - 1) * 9 + k);
                }
            }
            else
            {
                int temp = s[i] - '0';
                x.link((i - 1) * 9 + temp, i);
                x.link((i - 1) * 9 + temp, 81+(row - 1) * 9 + temp);
                x.link((i - 1) * 9 + temp, 81 * 2 + (col - 1) * 9 + temp);
                x.link((i - 1) * 9 + temp, 81 * 3 + (grid - 1) * 9 + temp);
            }
        }
        x.dance(0);
        x.out();

    }
}

E - Sudoku
同上题,代码如下:

#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 60000;
const int maxn = 4100;
const int maxm = 1100;

struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1
    char cans[16*16+10];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        memset(cans, '\0', sizeof(cans));
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void remove(int c)//删除节点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[Col[j]];
            }
    }

    void resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    bool dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansd = d;
            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);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                remove(Col[j]);
            if (dance(d + 1))return true;
            for (int j = L[i];j != i;j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return false;
    }
    void out()
    {
        int kinds, num;
        for (int i = 0;i < ansd;i++)
        {
            kinds = (ans[i] - 1) % 16 + 1;
            num = (ans[i] - 1) / 16 + 1;
            cans[num] = kinds-1+'A';
        }
        int now = 1;
        for (int i = 1;i <= 16;i++)
        {
            for (int j = 1;j <= 16;j++)
                printf("%c", cans[now++]);
            printf("\n");
        }
    }
};

DLX x;
char s[20][20];
bool init()
{
    char c;
    while (((c = getchar()) < 'A' || c > 'P') && c != '-'&&c != EOF);
    if (c == EOF)return 0;
    for(int i=1;i<=16;i++)
        for (int j = 1;j <= 16;j++)
        {
            if (i == 1 && j == 1)s[i][j] = c;
            else
            {
                while (((c = getchar()) < 'A' || c > 'P') && c != '-');
                s[i][j] = c;
            }
        }
    return 1;
}

int main()
{
    int T = 0;
    while (init())
    {
        if (T++)puts("");
        x.init(4096, 1024);

        for (int i = 1;i <= 16;i++)
            for (int j = 1;j <= 16;j++)
            {
                int num = (i - 1) * 16 + j;
                int grid = (i - 1) / 4 * 4 + (j - 1) / 4 + 1;
                if (s[i][j] == '-')
                {
                    for (int k = 1;k <= 16;k++)
                    {
                        x.link((num - 1) * 16 + k, num);
                        x.link((num - 1) * 16 + k, 16 * 16 + (i - 1) * 16 + k);
                        x.link((num - 1) * 16 + k, 16 * 16 * 2 + (j - 1) * 16 + k);
                        x.link((num - 1) * 16 + k, 16 * 16 * 3 + (grid - 1) * 16 + k);
                    }
                }
                else
                {
                    int k = s[i][j] - 'A' + 1;
                    x.link((num - 1) * 16 + k, num);
                    x.link((num - 1) * 16 + k, 16 * 16 + (i - 1) * 16 + k);
                    x.link((num - 1) * 16 + k, 16 * 16 * 2 + (j - 1) * 16 + k);
                    x.link((num - 1) * 16 + k, 16 * 16 * 3 + (grid - 1) * 16 + k);
                }
            }

        x.dance(0);
        x.out();
    }
}

F - Squiggly Sudoku
解释一下题意:题意仍然是数独，但它的输入让博主迟迟没看懂。。根据题意，它输入是0-9,16,32,64,128中的一些值的和，而根据这个值可以推出和这个格子同属于一个块的格子，比如144,144=128+16+0,它没有64和32，代表它的下面的格子和右边的格子和他是一个块的。0代表他的那个格子是空的。
因此，与一般的数独不同的是，我们先得求出每个格子在哪个块的，之后就和普通的数独一样了。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<map>   
#include<math.h>
using namespace std;
const int maxnode = 262500;
const int maxn = 750;
const int maxm = 350;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1

    int ansnum;
    int theans[maxn];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        ansnum = 0;
        ansd = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void exact_remove(int c)//删除节点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[Col[j]];
            }
    }

    void repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    void repeat_resume(int c)
    {
        for (int i = U[c];i != c;i = U[i])
            L[R[i]] = R[L[i]] = i;
    }

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansnum++;
            memcpy(theans, ans, sizeof(ans));
            ansd = d;
            return;
        }
        if (ansnum > 2)return;
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                exact_remove(Col[j]);
            exact_dance(d + 1);

            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])vv[c] = 1;
        for(c=R[0];c!=0;c=R[c])
            if (vv[c])
            {
                ret++, vv[c] = 0;
                for (i = D[c];i != c;i = D[i])
                    for (j = R[i];j != i;j = R[j])
                        vv[Col[j]] = 0;
            }
        return ret;
    }

    void repeat_dance(int d)
    {
        if (d + f() >= ansd)return;
        if (R[0] == 0)
        {
            if (d < ansd)ansd = d;
            return;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            repeat_dance(d + 1);
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
    }

    void out()
    {
        if (ansnum == 0)
            printf("No solution\n");
        else if (ansnum > 1)
            printf("Multiple Solutions\n");
        else
        {
            int Out[maxn];
            int kind, num;
            int now = 0;
            for (int now = 0;now < ansd;now++)
            {
                kind = (theans[now] - 1) % 9 + 1;
                num = (theans[now] - 1) / 9 + 1;

                Out[num] = kind;
            }
            now = 1;
            for (int i = 1;i <= 9;i++)
            {
                for (int j = 1;j <= 9;j++)
                    printf("%d", Out[now++]);
                printf("\n");
            }
        }
    }

};
DLX x;
int belong[10][10];
int Map[10][10];
int num;
void dfs(int x, int y)
{
    belong[x][y] = num;
    int &temp = Map[x][y];
    if (temp >= 128)temp -= 128;
    else
    {
        if (!belong[x][y - 1])dfs(x, y - 1);
    }
    if (temp >= 64)temp -= 64;
    else
    {
        if (!belong[x + 1][y])dfs(x + 1, y);
    }
    if (temp >= 32)temp -= 32;
    else
    {
        if (!belong[x][y + 1])dfs(x, y + 1);
    }
    if (temp >= 16)temp -= 16;
    else
    {
        if (!belong[x - 1][y])dfs(x - 1, y);
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    int cas = 1;
    while (T--)
    {
        x.init(9 * 9 * 9, 27 * 9 + 81);
        memset(belong, 0, sizeof(belong));
        for (int i = 1;i <= 9;i++)
            for (int j = 1;j <= 9;j++)
                scanf("%d", &Map[i][j]);
        num = 0;
        for(int i=1;i<=9;i++)
            for (int j = 1;j <= 9;j++)
            {
                if (!belong[i][j])
                {
                    num++;
                    dfs(i, j);
                }
            }
        for(int i=1;i<=9;i++)
            for (int j = 1;j <= 9;j++)
            {
                int grid = belong[i][j];
                int num = (i - 1) * 9 + j;
                if (Map[i][j] == 0)
                {
                    for (int k = 1;k <= 9;k++)
                    {
                        x.link((num - 1) * 9 + k, num);
                        x.link((num - 1) * 9 + k, 81+(i - 1) * 9 + k);
                        x.link((num - 1) * 9 + k, 81*2+(j - 1) * 9 + k);
                        x.link((num - 1) * 9 + k, 81*3+(grid - 1) * 9 + k);
                    }
                }
                else
                {
                    int k = Map[i][j];
                    x.link((num - 1) * 9 + k, num);
                    x.link((num - 1) * 9 + k, 81 + (i - 1) * 9 + k);
                    x.link((num - 1) * 9 + k, 81 * 2 + (j - 1) * 9 + k);
                    x.link((num - 1) * 9 + k, 81 * 3 + (grid - 1) * 9 + k);
                }
            }
        x.exact_dance(0);
        printf("Case %d:\n", cas++);
        x.out();
    }
    return 0;
}

J - Easy Finding
模板题。。

#include<iostream>
#include<stdio.h>
#include<cstring>

using namespace std;
const int maxnode = 60000;
const int maxn = 20;
const int maxm = 305;

struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1

    void init(int _n, int _m)
    {
        n = _n, m = _m;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void remove(int c)//删除节点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[Col[j]];
            }
    }

    void resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    bool dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansd = d;
            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);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                remove(Col[j]);
            if (dance(d + 1))return true;
            for (int j = L[i];j != i;j = L[j])
                resume(Col[j]);
        }
        resume(c);
        return false;
    }

};

DLX x;


int main()
{
    int M, N;
    while (~scanf("%d %d",&M,&N))
    {
        x.init(M, N);
        int num;
        for(int i=1;i<=M;i++)
            for (int j = 1;j <= N;j++)
            {
                scanf("%d", &num);
                if(num)x.link(i, j);
            }
        if (!x.dance(0))
            puts("It is impossible");
        else
            puts("Yes, I found it");
    }
    return 0;


}

重复覆盖问题:
B - Radar
一看求距离就知道二分距离，然后根据距离可以建立雷达和城市的01矩阵，接着套模板即可。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<map>   
#include<math.h>
using namespace std;
const int maxnode = 90000;
const int maxn = 300;
const int maxm = 300;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1
    char cans[16*16+10];
    int minans;
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        minans = inf;
        ansd = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void exact_remove(int c)//删除节点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[Col[j]];
            }
    }

    void repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    void repeat_resume(int c)
    {
        for (int i = U[c];i != c;i = U[i])
            L[R[i]] = R[L[i]] = i;
    }

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            if (d < minans)
                minans = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                exact_remove(Col[j]);
            exact_dance(d + 1);
            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])vv[c] = 1;
        for(c=R[0];c!=0;c=R[c])
            if (vv[c])
            {
                ret++, vv[c] = 0;
                for (i = D[c];i != c;i = D[i])
                    for (j = R[i];j != i;j = R[j])
                        vv[Col[j]] = 0;
            }
        return ret;
    }

    void repeat_dance(int d)
    {
        if (d + f() >= ansd)return;
        if (R[0] == 0)
        {
            if (d < ansd)ansd = d;
            return;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            repeat_dance(d + 1);
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
    }


};

DLX x;
int N, M, K;
struct node
{
    int x, y;
    node(){}
    node(int _x,int _y):x(_x),y(_y){}
}City[55], Rata[55];

double Dis(node a, node b)
{
    return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d %d %d", &N, &M, &K);
        for (int i = 1;i <= N;i++)
            scanf("%d %d", &City[i].x, &City[i].y);
        for (int i = 1;i <= M;i++)
            scanf("%d %d", &Rata[i].x, &Rata[i].y);

        double L = 0, R = 1500, mid;
        for (int t = 1;t <= 100;t++)
        {
            mid = (L + R) / 2;
            x.init(M, N);
            for(int i=1;i<=M;i++)
                for (int j = 1;j <= N;j++)
                {
                    double dis = Dis(Rata[i], City[j]);
                    if (dis <= mid)x.link(i, j);
                }
            x.repeat_dance(0);
            if (x.ansd == inf || x.ansd > K)
                L = mid;
            else
                R = mid;
        }
        printf("%.6f\n", mid);
    }
    return 0;

}

C - 神龙的难题
要消灭所有魔物，那么魔物肯定就是用列来代表了。这里我们可以用一个map来处理坐标和id的映射。行则可以用火球的攻击矩阵的位置代表。其中的数学关系读者可以自己画一画。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<map>
using namespace std;
const int maxnode = 90000;
const int maxn = 300;
const int maxm = 300;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1
    char cans[16*16+10];
    int minans;
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        minans = inf;
        ansd = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void exact_remove(int c)//删除节点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[Col[j]];
            }
    }

    void repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    bool repeat_resume(int c)
    {
        for (int i = U[c];i != c;i = U[i])
            L[R[i]] = R[L[i]] = i;
    }

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            if (d < minans)
                minans = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                exact_remove(Col[j]);
            exact_dance(d + 1);
            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])vv[c] = 1;
        for(c=R[0];c!=0;c=R[c])
            if (vv[c])
            {
                ret++, vv[c] = 0;
                for (i = D[c];i != c;i = D[i])
                    for (j = R[i];j != i;j = R[j])
                        vv[Col[j]] = 0;
            }
        return ret;
    }

    void repeat_dance(int d)
    {
        if (d + f() >= ansd)return;
        if (R[0] == 0)
        {
            if (d < ansd)ansd = d;
            return;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            repeat_dance(d + 1);
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
    }


};

DLX x;


typedef pair<int, int>pii;
map<pii, int>M;
int id;
int Map[20][20];
int n, m,n1,m1;

int main()
{

    while (~scanf("%d %d",&n,&m))
    {
        memset(Map, 0, sizeof(Map));
        id = 1;
        int temp;
        for(int i=1;i<=n;i++)
            for (int j = 1;j <= m;j++)
            {
                scanf("%d", &temp);
                Map[i][j] = temp;
                if (temp)
                {
                    pii tmp = make_pair(i, j);
                    M[tmp] = id++;
                }
            }
        scanf("%d %d", &n1, &m1);
        x.init(n*m, id - 1);
        for(int i=1;i<=n-n1+1;i++)
            for (int j = 1;j <= m - m1 + 1;j++)
            {
                int loc = (i - 1)*(m - m1 + 1) + j;
                for(int k=0;k<n1;k++)
                    for (int t = 0;t < m1;t++)
                    {
                        int r = i + k, c = j + t;
                        if (Map[r][c])
                        {
                            pii tmp = make_pair(r, c);
                            int theid = M[tmp];
                            x.link(loc, theid);
                        }
                    }
            }
        x.repeat_dance(0);
        printf("%d\n", x.ansd);
    }
    return 0;
}

G-Divisibility
博主一开始冥思苦想该怎么建矩阵，因为按照之前的题的思路来说，肯定有一个东西是你要覆盖的，那个东西就可以用来做列。但这题怎么想也没有那个”列”。看了题解才发现这题与之前的题不同，矩阵的意义不一样了。之前的都和题目有一定的关系。而这题完全用矩阵模拟正常的选数的逻辑。
另外由于是求最大的，那么他的估价函数需要修改。
具体的做法大家看代码就能明白了。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<map>   
#include<math.h>
using namespace std;
const int maxnode = 1000005;
const int maxn = 1005;
const int maxm =1005;
const int inf = 0x3f3f3f;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1

    int ansnum;
    int theans[maxn];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        ansnum = 0;
        ansd = 0;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void exact_remove(int c)//删除节点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[Col[j]];
            }
    }

    void repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    void repeat_resume(int c)
    {
        for (int i = U[c];i != c;i = U[i])
            L[R[i]] = R[L[i]] = i;
    }

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansnum++;
            memcpy(theans, ans, sizeof(ans));
            ansd = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                exact_remove(Col[j]);
            exact_dance(d + 1);

            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])
            ret++;

        return ret;
    }

    void repeat_dance(int d)
    {
        if (d + f() <= ansd)return;
        if (R[0] == 0)
        {
            if (d > ansd)ansd = d;
            return;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            repeat_dance(d + 1);
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
    }
};
DLX x;

typedef long long ll;
ll num[1005];

int main()
{
    int T;
    scanf("%d", &T);
    int n;
    while (T--)
    {
        scanf("%d", &n);
        x.init(n, n);
        for (int i = 1;i <= n;i++)
            scanf("%lld", &num[i]);
        for (int i = 1;i <= n;i++)
            for (int j = 1;j <= n;j++)
            {
                if (num[i] % num[j] == 0 || num[j] % num[i] == 0)
                    x.link(i, j);
            }
        x.repeat_dance(0);
        printf("%d\n", x.ansd);
    }
    return 0;
}

H - A simple math problem
至少买多少张可以中一次，一共有N个数，买M个数，就有C(N,M)种方式，中R个数，就有C(N,R)种中奖方式。因为数不大(不超过8)，我们可以按位来代表那个数是中奖号码，列，就可以用中奖号码的所有状态表示，行则是买的号码的所有状态。再套重复覆盖。另外，就算这样仍然会TLE。所以要打表(大约要等10min左右)。(然而打表代码不见辣。。忘记存了。。)
I - Airport
一看距离就知道要二分，但这题有个巧妙的二分方式，就是用数组存两两之间的距离，然后二分下标，根据这个距离构造矩阵即可。

#include<map>   
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
const int maxnode = 10000;
const int maxn = 100;
const int maxm = 100;
const int inf = 0x3f3f3f;
int N, K;
struct DLX
{
    int n, m, size;
    int U[maxnode], D[maxnode], R[maxnode], L[maxnode], Row[maxnode], Col[maxnode];
    int H[maxn];//行头结点
    int S[maxm];//每一列有多少结点
    int ansd, ans[maxn];//如果有答案,择选了ansd行,放在ans[]数组里面0~ansd-1

    int ansnum;
    int theans[maxn];
    void init(int _n, int _m)
    {
        n = _n, m = _m;
        //memset(cans, '\0', sizeof(cans));
        ansnum = 0;
        ansd = inf;
        for (int i = 0;i <= m;i++)
        {
            S[i] = 0;
            U[i] = D[i] = i;//初始状态下,上下自己指向自己(也就知道了头结点的值为i)
            L[i] = i - 1;
            R[i] = i + 1;
        }
        R[m] = 0, L[0] = m;//环状,下面的Link一样也是环,这样，不管从一行中的任意一个结点都可以遍历完这一行.
        size = m;//编号,每列的头结点编号1-m，所以size从m+1开始
        for (int i = 1;i <= n;i++)
            H[i] = -1;
    }

    void link(int r, int c)//第r行,第c列
    {
        ++S[Col[++size] = c];//第size个结点的列为c,当前列的节点数++
        Row[size] = r;//第size个节点行位置为r
        D[size] = D[c];
        U[D[c]] = size;
        U[size] = c;
        D[c] = size;
        if (H[r] < 0)
            H[r] = L[size] = R[size] = size;
        else
        {
            R[size] = R[H[r]];
            L[R[H[r]]] = size;
            L[size] = H[r];
            R[H[r]] = size;
        }
    }

    void exact_remove(int c)//删除节点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[Col[j]];
            }
    }

    void repeat_remove(int c)//只删除列
    {
        for (int i = D[c];i != c;i = D[i])
            L[R[i]] = L[i], R[L[i]] = R[i];
    }

    void exact_resume(int c)//恢复节点c(列c),以及恢复所有在这一列的节点所在的行中的所有的节点。
    {
        for (int i = U[c];i != c;i = U[i])
            for (int j = L[i];j != i;j = L[j])
                ++S[Col[U[D[j]] = D[U[j]] = j]];
        L[R[c]] = R[L[c]] = c;
    }

    void repeat_resume(int c)
    {
        for (int i = U[c];i != c;i = U[i])
            L[R[i]] = R[L[i]] = i;
    }

    void exact_dance(int d)//深度
    {
        if (R[0] == 0)
        {
            ansnum++;
            memcpy(theans, ans, sizeof(ans));
            ansd = d;
            return;
        }
        int c = R[0];
        for (int i = R[0];i != 0;i = R[i])
            if (S[i] < S[c])
                c = i;
        exact_remove(c);//找到节点数最少的列，当前元素不是原图上0,1的节点,而是列头结点
        for (int i = D[c];i != c;i = D[i])
        {
            ans[d] = Row[i];//列头结点下面的一个节点
            for (int j = R[i];j != i;j = R[j])
                exact_remove(Col[j]);
            exact_dance(d + 1);

            for (int j = L[i];j != i;j = L[j])
                exact_resume(Col[j]);
        }
        exact_resume(c);
    }

    int f()  //估价函数
    {
        bool vv[maxm];
        int ret = 0, c, i, j;
        for (c = R[0];c != 0;c = R[c])vv[c] = 1;
        for (c = R[0];c != 0;c = R[c])
            if (vv[c])
            {
                ret++, vv[c] = 0;
                for (i = D[c];i != c;i = D[i])
                    for (j = R[i];j != i;j = R[j])
                        vv[Col[j]] = 0;
            }
        return ret;
    }

    bool repeat_dance(int d)
    {
        if (d + f() > K)return 0;
        if (R[0] == 0)
        {
            return d <= K;
        }
        int c = R[0], i, j;
        for (i = R[0];i;i = R[i])
            if (S[i] < S[c])c = i;
        for (i = D[c];i != c;i = D[i])
        {
            repeat_remove(i);
            for (j = R[i];j != i;j = R[j])repeat_remove(j);
            if (repeat_dance(d + 1))return 1;
            for (j = L[i];j != i;j = L[j])repeat_resume(j);
            repeat_resume(i);
        }
        return 0;
    }

};
DLX x;
typedef long long ll;

struct node
{
    ll x, y;
};
node Citys[65];

ll dis(int i, int j)
{
    return abs(Citys[i].x - Citys[j].x) + abs(Citys[i].y - Citys[j].y);
}
ll Dis[65][65];

ll V[4000];
int cnt = 0;
int main()
{
    int T;
    scanf("%d", &T);
    int cas = 1;
    while (T--)
    {
        cnt = 0;
        scanf("%d %d", &N, &K);
        for (int i = 1;i <= N;i++)
            scanf("%lld %lld", &Citys[i].x, &Citys[i].y);
        for (int i = 1;i <= N;i++)
            for (int j = 1;j <= N;j++)
            {
                ll temp = dis(i, j);
                Dis[i][j] = temp;
                V[cnt++] = temp;
            }
        sort(V, V + cnt);
        int ncnt = unique(V, V + cnt) - V;

        int l = 0, r = ncnt - 1, mid;
        while (l<r)
        {
            mid = (l + r) / 2;
            x.init(N, N);
            ll tmpdis = V[mid];
            for (int i = 1;i <= N;i++)
                for (int j = 1;j <= N;j++)
                {
                    if (Dis[i][j] <= tmpdis)
                        x.link(i, j);
                }
            if (x.repeat_dance(0))
                r = mid;
            else
                l = mid + 1;

        }
        printf("Case #%d: ", cas++);
        printf("%lld\n", V[l]);
    }
    return 0;
}

总结:
1，构建矩阵时，如果有需要覆盖的东西，那么那个东西往往是列。
2，如果实在找不出列，就尝试是否可以根据它本身模拟逻辑来构造矩阵。
3，dancing函数需要根据题目要求进行修改。

大学要有梦想
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值