hdu 3498 whosyourdaddy (重复覆盖，DLX+迭代加深A*)

题意：有一个英雄，他有一个技能，可以使一个点和与他相邻的点受到伤害，问最少攻击几个点可以使所有点至少被伤害一次。

思路：DLX。很裸。设行为每一个点，列为攻击点，在这里行元素与列元素都为n。然后DLX+迭代加深的启发式搜索就可以了，而启发式函数的含义为在当前状态下，在最优情况中，需要攻击几个点来消灭所有点。设计为选取一列控制，这时需要一行，行数加1。并且将与它连接的所有行包含的列都控制，这个只有在最理想情况才能达到的，因为很少出现一行可以控制这一列上所有行控制的列。在这里证明一下启发式函数hh()的单调不减性。因为每次至多只能删除一列，且根据设计要删除的列之间是无关联的，所以只存在两种情况，要么删除一列，要么不删除，而g()为迭代深度，每次都加1，且hh()最多减1，所以满足不减性。

启发式函数：

int hh()
{
    int ret=0;
    memset(hash,0,sizeof(hash));
    for(int i=dlx[head].r; i!=head; i=dlx[i].r)
    {
        if(hash[i]==false)
        {
            hash[i]=true;
            ret++;
        for(int j=dlx[i].d; j!=i; j=dlx[j].d)
            for(int k=dlx[j].r; k!=j; k=dlx[k].r)
            {
                hash[dlx[k].c]=true;
            }
        }
    }
    return ret;
}

代码如下：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn=15000;
struct node
{
    int l,r;
    int u,d;
    int s,c;
};//十字链表元素，u,d,l,r为上，下，左，右，s为列大小，c为元素所在的列主元。
node dlx[maxn];
int res[60][5];
int n,m;
bool map[60][60];
int size;
int h[60];//行首元
bool hash[60];
int head;//表头
int limit;//迭代限制
void init(int r,int c)//初始化列首元
{
    head=0;
    for(int i=0; i<=c; i++)
    {
        dlx[i].s=0;
        dlx[i].u=dlx[i].d=i;
        dlx[i].r=i+1;
        dlx[i+1].l=i;
    }
    size=c;
    dlx[c].r=0;
    while(r)
    {
        h[r--]=-1;
    }
}
void link(int r,int c)//将元素插入r行，c 列
{
    int tmp=++size;
    dlx[c].s++;
    dlx[tmp].c=c;
    dlx[tmp].d=dlx[c].d;
    dlx[tmp].u=c;
    dlx[dlx[c].d].u=tmp;
    dlx[c].d=tmp;
    if(h[r]<0)
    {
        h[r]=dlx[tmp].l=dlx[tmp].r=tmp;
    }
    else
    {
        dlx[tmp].r=dlx[h[r]].r;
        dlx[tmp].l=h[r];
        dlx[dlx[h[r]].r].l=tmp;
        dlx[h[r]].r=tmp;
    }
}
void remove(int x)
{
    for(int i=dlx[x].d; i!=x; i=dlx[i].d)
    {
        dlx[dlx[i].r].l=dlx[i].l;
        dlx[dlx[i].l].r=dlx[i].r;
        dlx[dlx[i].c].s--;
    }
}
void resume(int x)
{
    for(int i=dlx[x].u; i!=x; i=dlx[i].u)
    {
        dlx[dlx[i].r].l=i;
        dlx[dlx[i].l].r=i;
        dlx[dlx[i].c].s++;
    }
}
int hh()//估价函数
{
    int ret=0;
    memset(hash,0,sizeof(hash));
    for(int i=dlx[head].r; i!=head; i=dlx[i].r)
    {
        if(hash[i]==false)
        {
            hash[i]=true;
            ret++;
        for(int j=dlx[i].d; j!=i; j=dlx[j].d)
            for(int k=dlx[j].r; k!=j; k=dlx[k].r)
            {
                hash[dlx[k].c]=true;
            }
        }
    }
    //cout<<"er"<<endl;
    return ret;
}
bool dlx_dfs(int k)//dancing links搜索
{
    if(k+hh()>=limit)
    {
        return false;
    }
    if(dlx[head].r==head)
    {
        if(k<limit) limit=k;
        return true;
    }
    int minn=n+1;
    int tt;
    for(int i=dlx[head].r; i!=head; i=dlx[i].r)
    {
        if(minn>dlx[i].s)
        {
            minn=dlx[i].s;
            tt=i;
        }
    }
    for(int i=dlx[tt].d; i!=tt; i=dlx[i].d)
    {
        remove(i);
        for(int j=dlx[i].r; j!=i; j=dlx[j].r)
        {
            remove(j);
        }
        if(dlx_dfs(k+1))
        {
            return true;
        }
        for(int j=dlx[i].l; j!=i; j=dlx[j].l)
        {
            resume(j);
        }
        resume(i);
    }
    return false;
}
int astar()// 迭代加深A*
{
    limit=hh();
  //  cout<<limit<<endl;
    while(dlx_dfs(0)==false) limit++;
    return limit;
}
int main()
{
   // freopen("in.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        init(n,n);
        memset(map,0,sizeof(map));
        for(int i=0; i<m; i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            map[a][b]=map[b][a]=1;
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            {
                if(map[i][j]||i==j)//这里加上i本身被自己摧毁
                {
                    link(i,j);
                }
            }
            int ans=astar();
          dlx_dfs(0);
        printf("%d\n",ans);

    }
    return 0;
}