[HDOJ3663]Power Stations

建立精确覆盖模型求解（Dancing Links）~

#include <cstdio>
#include <cstring>
#include <algorithm>

 using namespace std;

 const int MAXR = 1024;
const int MAXC = 512;
const int SIZE = 1024;
const int INF = (1 << 20);

struct Node
{
    Node * u;
    Node * d;
    Node * l;
    Node * r;
    int rnum;
    int cnum;
};

int node;
int sum[MAXC];
Node head;
Node row[MAXR];
Node column[MAXC];
Node pool[MAXR * MAXC];

int alen;
int ans[MAXR];

void InitDLX(int nr,int nc)
{
    node = 0;
    memset(sum,0,sizeof(sum));
    head.r = &column[0];
    column[0].cnum = 0;
    column[0].l = &head;
    column[0].u = column[0].d = &column[0];
    for (int i = 1; i < nc; i++)
    {
        column[i].cnum = i;
        column[i-1].r = &column[i];
        column[i].l = &column[i-1];
        column[i].u = column[i].d = &column[i];
    }
    column[nc-1].r = &head;
    head.l = &column[nc-1];

    for (int i = 0; i < nr; i++)
        row[i].l = row[i].r = &row[i];
}

void InsertDLX(int r,int c)
{
    sum[c]++;
    pool[node].rnum = r;
    pool[node].cnum = c;
    pool[node].l = row[r].l;
    pool[node].r = &row[r];
    row[r].l->r = &pool[node];
    row[r].l = &pool[node];
    pool[node].u = column[c].u;
    pool[node].d = &column[c];
    column[c].u->d = &pool[node];
    column[c].u = &pool[node];

    node++;
}

void DeleteRowHeadDLX(int nr)
{
    for (int i = 0; i < nr; i++)
    {
        row[i].l->r = row[i].r;
        row[i].r->l = row[i].l;
    }
}

void RemoveColumn(Node * col)
{
    col->l->r = col->r;
    col->r->l = col->l;
    for (Node * p = col->d; p != col; p = p->d)
        for (Node * q = p->r; q != p; q = q->r)
        {
            q->u->d = q->d;
            q->d->u = q->u;
            sum[q->cnum]--;
        }
}

void ResumeColumn(Node * col)
{
    col->l->r = col;
    col->r->l = col;
    for (Node * p = col->d; p != col; p = p->d)
        for (Node * q = p->r; q != p; q = q->r)
        {
            q->u->d = q;
            q->d->u = q;
            sum[q->cnum]++;
        }
}

bool dfs(int k)
{
    if (head.r == &head)
    {
        alen = k;
        return true;
    }

    int minl = INF;
    Node * mincol;
    for (Node * p = head.r; p != &head; p = p->r)
        if (sum[p->cnum] < minl)
        {
            minl = sum[p->cnum];
            mincol = p;
        }
    RemoveColumn(mincol);
    for (Node * p = mincol->d; p != mincol; p = p->d)
    {
        for (Node * q = p->r; q != p; q = q->r)
            RemoveColumn(&column[q->cnum]);
        if (dfs(k + 1))
        {
            ans[k] = p->rnum;
            return true;
        }
        for (Node * q = p->l; q != p; q = q->l)
            ResumeColumn(&column[q->cnum]);
    }
    ResumeColumn(mincol);
    return false;
}

bool gmap[SIZE][SIZE];

int lable[SIZE];

int main()
{
    int nv;
    int ne;
    int nd;

    int nr;
    int nc;

    int u;
    int v;
    int o;

    while(scanf("%d %d %d",&nv,&ne,&nd) != EOF)
    {
        nr = 0;
        nc = nv + nd * nv;
        memset(gmap,false,sizeof(gmap));

        for(int i = 0; i < ne; i++)
        {
            scanf("%d %d",&u,&v);
            gmap[u - 1][v - 1] = gmap[v - 1][u - 1] = true;
        }

        for(int i = 0; i < nv; i++)
            gmap[i][i] = true;

        for(int i = 0; i < nv; i++)
        {
            scanf("%d %d",&u,&v);

            u--;
            v--;

            for(int s = u; s <= v; s++)
                for(int e = s; e <= v; e++)
                    lable[nr++] = i * 100 + s * 10 + e;

            lable[nr++] = i * 100 + nd * 10 + nd;
        }

        InitDLX(nr,nc);

        for(int i = 0; i < nr; i++)
        {
            o = lable[i] / 100;
            u = (lable[i] % 100) / 10;
            v = lable[i] % 10;

            InsertDLX(i,o);

            if(u == nd && v == nd) continue;

            for(int j = 0; j < nv; j++)
                if(gmap[o][j])
                    for(int k = u; k <= v; k++)
                        InsertDLX(i,nv + j * nd + k);
        }

        DeleteRowHeadDLX(nr);

        if(!dfs(0)) printf("No solution\n");
        else
        {
            sort(ans,ans + alen);
            for(int i = 0; i < alen; i++)
            {
                u = (lable[ans[i]] % 100) / 10;
                v = lable[ans[i]] % 10;
                if(u == nd && v == nd) printf("0 0\n");
                else printf("%d %d\n",u + 1,v + 1);
            }
        }
        printf("\n");
    }
    return 0;
}