POJ 2032 搜索 （IDA*） 或 DLX

题意：

你有一间矩形的屋子，屋子的地面上铺着正方形的地板，共有 H 行 W 列。经过长时间的使用，一些地板损坏了。而你又没有钱将整间屋子的地板都换成新的，所以你决定用一些地毯将损坏的地毯盖起来。
然而，你需要遵守下面的注意事项：
所有的地毯都必须是正方形的。
地毯可以相互覆盖。
地毯可以是任意大小的。
地毯不能盖到屋子外面。
所有的损坏的地板都要被盖住。
所有的未损坏的地板都不能被盖住。

这道题本来是暴搜加很多剪枝，自己原来的T了，看了网上题解有IDA*就被吓到了，因为之前没有写过IDA*，而且对于IDA*还处于一个不了解的状态。不过看到也有向我一样写暴搜加剪枝的题解，其中有几个我没用到的剪枝，之后加在我的代码中交上去却W了，拍一拍也没发现什么问题，但是不想调了，决定学一下IDA*。

/*
先看了看刘汝佳叔叔的紫书，在IDDFS的介绍中加了一行，就是提到了IDA*，说这个是表达一下IDA*并没有A*那么悚[自己蒟蒻]听闻，IDA*可以大概理解为IDDFS+A*的h函数。IDDFS是在DFS的基础上，限制搜索的深度，当搜索深度超过预定值Maxd时就return，在搜到解之前不断加大Maxd，直到搜索到解。Maxd初值很小（一般从0开始循环）。
然而在这个迭代加深搜索的过程中加一个估价函数h，就可以说是IDA*了，h函数的作用是估算当前状态到达解需要多少步，而如果当前已走步数（或深度）加上这个估算值大于已知ans的话就可以return了。
*/

以上只是很浅显的一个理解，感觉这道题并不能算是IDA*的一个很好的例题，它单单是在搜索的过程中加了h函数，并没有体现”ID”，自己在理解上也有一些问题：IDDFS搜索任一可行解以及DFS+h函数搜索最优解可以很好理解，但IDA*怎么搜这两种解感觉还有些问题，等下再写一道经典一点的例题加深一下理解吧。

那么来看这道题的做法：
我是先给所有点都编了号，id(x, y)，这样数组可以减小维度，
先预处理出以每个点为左上角的最大地毯，f数组
DP（O（N^2）），或者用二维树状数组（O（N^2 log^2N））
还需要预处理出要覆盖每个点，需要哪些地毯，记录编号，cov数组

问题就变成，对于所有的地毯，枚举铺设哪些，使得在最少块数下覆盖所有的1。

可以做的一个优化就是对于两块可以铺盖的地毯i，j（i，j表示点的编号），如果i可以完全包含j，那么选i一定比比选j差，因为地毯是可以覆盖的，所以选尽量大的总是好的。这样我们搜索时就不需要枚举j了。

h函数：这个函数是要满足一定条件的估价，刘汝佳叔叔称为“乐观估价”，因为当now+h() >= ans时我们会return，那么h的估价一定不能比真实情况大，而且为了保证效果又不能比真实情况小太多。所以h函数一般需要好好想一想。对于这道题不错的一个估价是：当前状态下，遍历一遍所有的点，对于还没有被覆盖的，我们把所有可以覆盖这个点的地毯都铺上，这些地毯算为1块。最后计算出的当前状态下还需要铺的“地毯数”就是h函数返回值。这个结果一定是比真实情况小的，但也不会小很多，性能还是不错的。

之后就可以写搜索了，一开始自己写的还是有问题，之后看了一份题解，换成人家的搜索姿势就A了。[泪]
我的搜索姿势是：当前点t没有被覆盖时，一定要铺一块地毯覆盖这个点，所以就铺t这块地毯，若已经被覆盖，那么就可以不铺，但是还是要搜索铺一块的情况，不过剪枝：如果要再铺一块的话没有任何效果那么就不铺。
别人家的搜索姿势：当前点被覆盖时，不需要再铺，只搜索不铺，若没被覆盖，枚举用哪一块来覆盖（cov数组）。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int n, m, ans, f[115], num[115], cov[115][115];
bool map[115], vis[115], vis2[115]; 

int id(int x, int y){
    return (x-1)*m+y;
}

bool cover(int t){
    if(!map[t]) return 1;
    for(int i = 1; i <= num[t]; i++){
        if(vis[cov[t][i]]) return 1;
    }
    return 0;
}

int h(){
    int res = 0;
    for(int i = id(n, m); i; i--){
        vis2[i] = vis[i];
    }
    for(int i = 1; i <= n; i++)
    for(int j = 1; j <= m; j++){
        int t = id(i, j);
        if(cover(t)) continue;
        res++;
        for(int k = 1; k <= num[t]; k++){
            vis[cov[t][k]] = 1;
        }
    }
    for(int i = id(n, m); i; i--){
        vis[i] = vis2[i];
    }
    return res;
}

void sec(int t, int ed){
    if(ed + h() >= ans) return ;
    if(t > id(n, m)){
        ans = min(ans, ed); return ;
    }
    if(!map[t]){sec(t+1, ed); return ;}
    if(cover(t)){
        sec(t+1, ed); return ;
    }
    for(int i = 1; i <= num[t]; i++){
        vis[cov[t][i]] = 1;
        sec(t+1, ed+1);
        vis[cov[t][i]] = 0;
    }
}

int main()
{
    while(scanf("%d %d", &m, &n) && n){
        memset(  f, 0, sizeof   f);
        memset(map, 0, sizeof map);
        memset(cov, 0, sizeof cov);
        memset(num, 0, sizeof num);
        memset(vis, 0, sizeof vis);

        for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++){
            int t = id(i, j);
            scanf("%d", map+t);
        }

        for(int i = n; i; i--){
            f[id(i, m)] = map[id(i, m)];
            for(int j = m-1; j; j--){
                int t = id(i, j); if(map[t])
                f[t] = min(f[t+m], min(f[t+1], f[t+m+1])) + 1;
            } 
        }

        for(int i = n; i; i--)
        for(int j = m; j; j--){
            int t = id(i, j);
            if(f[t+1] < f[t]) f[t+1] = 0;
            if(f[t+m] < f[t]) f[t+m] = 0;
            if(f[t+m+1] < f[t]) f[t+m+1] = 0;
        }

        ans = 0;
        for(int i = n; i; i--)
        for(int j = m; j; j--){
            int t = id(i, j);
            if(f[t]) ans++;
            for(int k = 0; k < f[t]; k++)
            for(int l = 0; l < f[t]; l++){
                int t2 = id(i+k, j+l);
                cov[t2][++num[t2]] = t;
            }
        }

        sec(1, 0);
        printf("%d\n", ans);
    }
    return 0;
}

哎，国庆这些天的培训，每次考试都是被虐，感觉快没脸参加noip了。最后杜神的搜索题感觉都不算很难的样子，但是自己写不出来，考场上想不出来。这几天就先练练搜索了。

2015.10.14
然而，自己yy的DLX代码可以用后就来重写了一下这道题，下面是DLX版本。
不过暂时没加估价函数来剪枝，导致跑的比IDA*要慢一些。（16Ms 与 172Ms）

#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;

int n, m, Row, Col, f[15][15], id[15][15];
bool map[15][15], mtr[105][105];

struct DLX{

    int sz, ans, ele, col[1005], row[1005], del[1005];
    int U[1005], D[1005], L[1005], R[1005], S[105];

    void init(int c)
    {
        ans = 1<<30; sz = ele = c;
        memset(U, 0, sizeof U);
        memset(D, 0, sizeof D);
        memset(L, 0, sizeof L);
        memset(R, 0, sizeof R);
        memset(S, 0, sizeof S);
        memset(del, 0, sizeof del);

        for(int i = 0; i <= ele; i++)
        {
            U[i] = D[i] = i;
            L[i] = i-1; R[i] = i+1;
            row[i] = i;
        }
        L[0] = sz; R[sz] = 0;
    }

    void add_col(int c, bool *co)
    {
        int fir = sz;
        for(int i = 1; i <= ele; i++) if(co[i])
        {
            sz++; S[i]++;
            D[sz] = i; U[sz] = U[i];
            D[U[i]] = sz; U[i] = sz; 
            L[sz] = sz-1; R[sz] = sz+1;
            col[sz] = c; row[sz] = i;
        }
        if(fir != sz) L[fir+1] = sz, R[sz] = fir+1;
    }

    void remove(int c)  
    {  
        int t = c;
        do
        {
            int tt = row[t];
            if(!del[tt]) L[R[tt]] = L[tt], R[L[tt]] = R[tt], del[tt] = col[c];
            t = R[t];
        }   while(t != c);
    }  

    void resume(int c)  
    {     
        int t = c;
        do
        {
            int tt = row[t];
            if(del[tt] == col[c]) L[R[tt]] = tt, R[L[tt]] = tt, del[tt] = 0;
            t = R[t];
        }   while(t != c);
    }

    void dfs(int sum)
    {
        if(sum  >= ans) return ;
        if(!R[0]) { ans = sum; return ;}

        int r, Mins = 1<<30;
        for(int j = R[0]; j; j = R[j]) if(S[j] < Mins)
        {
            Mins = S[j], r = j;
        }   

        for(int i = D[r]; i != r; i = D[i])
        {
            remove(i);
            dfs(sum + 1);
            resume(i);
        }
    }

    void solve()
    {
        dfs(0);
        if(ans < (1<<30)) printf("%d\n", ans);
        else printf("-1\n");
    }
};

int main()
{
    while(scanf("%d %d", &m, &n) && n && m)
    {
        memset(  f, 0, sizeof   f);
        memset( id, 0, sizeof  id);
        memset(map, 0, sizeof map);
        memset(mtr, 0, sizeof mtr);

        Row = Col = 0;
        for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
        {
            scanf("%d", map[i]+j);
            if(map[i][j]) id[i][j] = ++Row;
        }

        for(int i = n; i; i--)
        for(int j = m; j; j--) if(map[i][j])
        {
            f[i][j] = min(f[i][j+1], min(f[i+1][j], f[i+1][j+1])) + 1;
        }

        for(int i = n; i; i--)
        for(int j = m; j; j--)
        {
            if(f[i][j] > f[i+1][j]) f[i+1][j] = 0;
            if(f[i][j] > f[i][j+1]) f[i][j+1] = 0;
            if(f[i][j] > f[i+1][j+1]) f[i+1][j+1] = 0;
        }

        for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) if(f[i][j])
        {
            Col++;
            for(int k = i; k-i < f[i][j]; k++)
            for(int l = j; l-j < f[i][j]; l++)
            {
                mtr[Col][id[k][l]] = 1;
            }
        }

        DLX T;
        T.init(Row);
        for(int i = 1; i <= Col; i++)
        {
            T.add_col(i, mtr[i]); 
        }
        T.solve();
    }
    return 0;
}