HDU 3498 whosyourdaddy

whosyourdaddy

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1028    Accepted Submission(s): 508

Problem Description

sevenzero liked Warcraft very much, but he haven't practiced it for several years after being addicted to algorithms. Now, though he is playing with computer, he nearly losed and only his hero Pit Lord left. sevenzero is angry, he decided to cheat to turn defeat into victory. So he entered "whosyourdaddy", that let Pit Lord kill any hostile unit he damages immediately. As all Warcrafters know, Pit Lord masters a skill called Cleaving Attack and he can damage neighbour units of the unit he attacks. Pit Lord can choice a position to attack to avoid killing partial neighbour units sevenzero don't want to kill. Because sevenzero wants to win as soon as possible, he needs to know the minimum attack times to eliminate all the enemys.

 

 

Input

There are several cases. For each case, first line contains two integer N (2 ≤ N ≤ 55) and M (0 ≤ M ≤ N*N),and N is the number of hostile units. Hostile units are numbered from 1 to N. For the subsequent M lines, each line contains two integers A and B, that means A and B are neighbor. Each unit has no more than 4 neighbor units. The input is terminated by EOF.

 

 

Output

One line shows the minimum attack times for each case.

 

 

Sample Input

5 4

1 2

1 3

2 4

4 5

6 4

1 2

1 3

1 4

4 5

 

 

Sample Output

2

3

 

 

Author

sevenzero

 

 

Source

2010 ACM-ICPC Multi-University Training Contest（7）——Host by HIT

 

 

Recommend

zhouzeyong

 

 

 

初学请看 ：http://blog.csdn.net/sunny606/article/details/7833551

 

http://www.cnblogs.com/steady/archive/2011/03/15/1984791.html

 

这两天学习了Dancing Links  ，它主要对搜索的优化，尤其对于矩阵， 进行深搜的时候，随着层数的加深，矩阵会越来越稀疏，

如果还是用一般的遍历的话， 时间还是没变，还是遍历整个矩阵， 因为矩阵已经变稀疏了，这样做很显然的浪费时间，

这里用到Dancing Links，相信它优美的舞步，一定能打动你的。。

Dancing Links用到一个十字链表， 众所周知 链表对于插入和删除的处理 时间复杂度都是O(1), 这里就要用到链表的这一特性，

对矩阵的某一行或列进行删除的时候 ，先标记，之后把其删除， 等到搜索过后，再把其恢复，时间效率大大的提高。。

Dancing 一般用来解决精确覆盖的问题， 像本题属于 重复覆盖的问题， Dancing Links并不能优化多少，但是这里加一个评估函数，

就在很大的程度上提高了它的效率。、

题目大意：深渊领主有一个技能，溅射（分列攻击），当它把一个单位杀死的时候与该单位 直接 相连的所有单位都要被杀死，

给出n个单位之间的关系，问把这n个单位全部杀死，至少需要攻击多少次。

思路：n个单位排成一排，与该单位相连的单位，以及它自身，位于这一列， 即是Dancing links里面的0-1矩阵。

h函数是这样写的：

当前这种状态至少还需要攻击多少次才能把所有单位消灭。任选没有被标记的一个单位，然后把该列中每一个元素所对应的行，

该行中每一个元素所对应的单位都标记下来。 因为一般我们都只能选取 该列中的一个元素，然后进行处理， 这里把该列中所有的元素都选取出来

，然后进行处理，所需要的次数肯定要比一般情况下的少。。  

 我感觉吧，这个评估函数写的不够风骚，虽然我还没有想到更好的办法。 虽然他能把这题A掉，但是我感觉应该还会有更好的优化！

这道题应该算是一个比较裸的Dancing Links了。

 

#include<iostream>
#include<cstdio>
#include<cstring>

const int N=60;
const int V=N*N;

int L[V],R[V];  //记录左右方向的双向链表
int U[V],D[V];  //记录上下方向的双向链表
int C[V];   //指向其列指针头的地址
int H[N];   //行指针头
int S[N];   //记录列链表中节点的总数
int size,n,m,ak;
int mark[N][N],vis[N];

void Link(int r,int c){
    S[c]++;C[size]=c;
    U[size]=U[c];  D[U[c]]=size;
    D[size]=c;   U[c]=size;
    if(H[r]==-1)
        H[r]=L[size]=R[size]=size;
    else{
        L[size]=L[H[r]];  R[L[H[r]]]=size;
        R[size]=H[r];   L[H[r]]=size;
    }
    size++;
}

void remove(int Size){
    int j;
    for(j=D[Size];j!=Size;j=D[j])
        L[R[j]]=L[j],R[L[j]]=R[j];
}

void resume(int Size){
    int j;
    for(j=D[Size];j!=Size;j=D[j])
        L[R[j]]=R[L[j]]=j;
}

int h(){
    int count=0;
    int i,j,k;
    memset(vis,0,sizeof(vis));
    for(i=R[0];i;i=R[i]){
        if(vis[i])
            continue;
        count++;
        for(j=D[i];j!=i;j=D[j])
            for(k=R[j];k!=j;k=R[k])
                vis[C[k]]=1;
    }
    return count;
}

void Dance(int k){
    if(k+h()>=ak)
        return ;
    if(!R[0]){
        if(k<ak)
            ak=k;
        return ;
    }
    int min=N;
    int i,j,c;
    for(i=R[0];i;i=R[i])
        if(min>S[i])
            min=S[i],c=i;
    for(i=D[c];i!=c;i=D[i]){
        remove(i);
        for(j=R[i];j!=i;j=R[j])
            remove(j);
        Dance(k+1);
        for(j=R[i];j!=i;j=R[j])
            resume(j);
        resume(i);
    }
}

int main(){

    //freopen("input.txt","r",stdin);

    while(~scanf("%d%d",&n,&m)){
        int i,j;
        for(i=0;i<=n;i++){
            S[i]=0;
            U[i]=D[i]=i;
            L[i+1]=i;R[i]=i+1;
        }
        R[n]=0;
        size=n+1;
        memset(mark,0,sizeof(mark));
        memset(H,-1,sizeof(H));
        int a,b;
        while(m--){
            scanf("%d%d",&a,&b);
            mark[a][b]=mark[b][a]=1;
        }
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                if(mark[i][j] || i==j)
                    Link(i,j);
        ak=N;
        Dance(0);
        printf("%d\n",ak);
    }
    return 0;
}