zoj 3209.Treasure Map（DLX精确覆盖）

直接精确覆盖

开始逐行添加超时了，换成了单点添加

#include <iostream>

#include <cstring>

#include <cstdio>

#include <cmath>

#include <vector>

using namespace std;

#define FOR(i,A,s)  for(int i = A[s]; i != s; i = A[i])

#define exp 1e-8

const int MAX = ;

int n, m, k, t, len;

struct DLX {

    int n, Size;//Size为尾指针，真正大小

    int row[MAX], col[MAX];//记录每个点的行列

    int U[MAX], D[MAX], R[MAX], L[MAX]; //4个链表

    int S[MAX],H[MAX];//每列1的个数

    int ncnt, ans[MAX];

    void init (int n) {

        this->n = n;

        ncnt = MAX;

        //增加n+1个辅助链表，从0到n

        for (int i = ; i <= n; i++)

            U[i] = D[i] = i, L[i] = i - , R[i] = i + ,S[i]=;

        R[n] = , L[] = n; //头尾相接

        Size = n + ;

        memset (H, -, sizeof H);

    }

    //单点添加

    void Link (int r, int c)

    {

        ++S[col[++Size] = c];

        row[Size] = r;

        D[Size] = D[c];

        U[D[c]] = Size;

        U[Size] = c;

        D[c] = Size;

        if (H[r] < ) 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) {

        //精确覆盖

        L[R[c]] = L[c], R[L[c]] = R[c];

        FOR (i, D, c)

        FOR (j, R, i)

        U[D[j]] = U[j], D[U[j]] = D[j], --S[col[j]];

//        //重复覆盖

//        for (int i = D[c]; i != c; i = D[i])

//            L[R[i]] = L[i], R[L[i]] = R[i];

    }

    void Restore (int c) {

        FOR (i, U, c)

        FOR (j, L, i)

        ++S[col[j]], U[D[j]] = j, D[U[j]] = j;

        L[R[c]] = c, R[L[c]] = c;

        //重复覆盖

//        for (int i = U[c]; i != c; i = U[i])

//            L[R[i]] = R[L[i]] = i;

    }

    bool v[MAX];

    int ff() {

        int ret = ;

        for (int c = R[]; c != ; c = R[c]) v[c] = true;

        for (int c = R[]; c != ; c = R[c])

            if (v[c])

            {

                ret++;

                v[c] = false;

                for (int i = D[c]; i != c; i = D[i])

                    for (int j = R[i]; j != i; j = R[j])

                        v[col[j]] = false;

            }

        return ret;

    }

    bool dfs (int d) {

        if (d >= ncnt) return ;

        //if (d + ff() > k) return 0;//重复覆盖

        if (R[] == ) {

            ncnt = min (ncnt, d);

            return ;

        }

        int c = R[];

        for (int i = R[]; i != ; i = R[i])

            if (S[i] < S[c])

                c = i;

        Remove (c);//精确覆盖

        FOR (i, D, c) {

            //Remove (i);//重复覆盖

            ans[d] = row[i];

            FOR (j, R, i) Remove (col[j]);//精确覆盖

            //FOR (j, R, i) Remove (j);//重复覆盖

            //if (dfs (d + 1) ) return 1;

            dfs (d + );

            FOR (j, L, i) Restore (col[j]);//精确覆盖

            //FOR (j, L, i) Restore (j);//重复覆盖

            //Restore (i);//重复覆盖

        }

        Restore (c);//精确覆盖

        return ;

    }

    bool solve (vector<int> &v) {

        v.clear();

        if (!dfs () ) return ;

        for (int i = ; i < ncnt; i++) v.push_back (ans[i]);

        return ;

    }

} Dance;

int columns[][ * ];

int main() {

    scanf ("%d", &t);

    while (t--) {

        memset (columns, , sizeof columns);

        scanf ("%d %d %d", &n, &m, &k);

        len = n * m;

        Dance.init (len);

        int x,y,xx,yy;

        for (int p = ; p <= k; p++) {

            scanf ("%d %d %d %d", &x, &y, &xx, &yy);

            for (int i = x+; i <= xx; i++)

                for (int j = y+; j <= yy; j++)

                    Dance.Link (p, j + (i-)*m);

        }

        Dance.dfs ();

        printf ("%d\n", Dance.ncnt == MAX ? - : Dance.ncnt);

    }

    return ;

}