[HDOJ3529]Bomberman Just Search!

模型转换之最小可重复覆盖（Dancing Links）~

#include <cstdio>
#include <cstring>

 using namespace std;

 const int SIZE = 16;
const int MAXR = 256;
const int MAXC = 32;
const int INF = (1 << 20);
const int dx[] = {-1,0,1,0};
const int dy[] = {0,1,0,-1};

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];

int hi;
int wi;
char board[SIZE][SIZE];
int tag[SIZE][SIZE];

int maxstep;

bool covered[MAXC];

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)
{
    for (Node * p = col->d;p != col;p = p->d)
    {
        p->r->l = p->l;
        p->l->r = p->r;
        sum[p->cnum]--;
    }
}

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

int Estimate()
{
    int value = 0;
    memset(covered,false,sizeof(covered));
    for (Node * p = head.r;p != & head;p = p->r)
        if (!covered[p->cnum])
        {
            covered[p->cnum] = true;
            value++;
            bool can = false;
            for (Node * q = p->d;q != p;q = q->d)
            {
                can = true;
                for (Node * o = q->r;o != q;o = o->r)
                    covered[o->cnum] = true;
            }
            if (!can) return INF;
        }
    return value;
}

bool dfs(int k)
{
    if (k + Estimate() > maxstep) return false;

    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;
        }
    for (Node * p = mincol->d;p != mincol;p = p->d)
    {
        RemoveColumn(p);
        for (Node * q = p->r;q != p;q = q->r)
            RemoveColumn(q);
        if (dfs(k + 1))
        {
            //ans[k] = p->rnum + 1;
            return true;
        }
        for (Node * q = p->l;q != p;q = q->l)
            ResumeColumn(q);
        ResumeColumn(p);
    }
    return false;
}

bool legal(int x,int y)
{
    return x >= 0 && x < hi && y >= 0 && y < wi && board[x][y] == '.';
}

int main()
{
    while(scanf("%d %d",&hi,&wi) != EOF)
    {
        int scnt = 0;
        int wcnt = 0;
        memset(tag,-1,sizeof(tag));

        for(int i = 0;i < hi;i++)
        {
            scanf("%s",board[i]);
            for(int j = 0;j < wi;j++)
                if(board[i][j] == '.')
                    tag[i][j] = scnt++;
                else if(board[i][j] == '#')
                    tag[i][j] = wcnt++;
        }

        InitDLX(scnt,wcnt);

        for(int i = 0;i < hi;i++)
            for(int j = 0;j < wi;j++)
                if(board[i][j] == '#')
                    for(int k = 0;k < 4;k++)
                    {
                        int x = i + dx[k];
                        int y = j + dy[k];
                        while(legal(x,y))
                        {
                            InsertDLX(tag[x][y],tag[i][j]);
                            x += dx[k];
                            y += dy[k];
                        }
                    }

        DeleteRowHeadDLX(scnt);

        for(maxstep = 0;!dfs(0);maxstep++) ;

        printf("%d\n",maxstep);
    }
    return 0;
}