hdu 4712 Hamming Distance bfs

我的做法，多次宽搜，因为后面的搜索扩展的节点会比较少，所以复杂度还是不需要太悲观的，然后加上一开始对答案的估计，用估计值来剪枝，就可以ac了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
char a[11];
int key[111111];
int hash[1111111];
int que[2111111];
int front,end;
int ans;
void bfs()
{
    while(front<=end)
    {
        int now=que[front++];
        if(hash[now]>=ans) continue;
        for(int i=0;i<=19;i++)
        {
            int to=(now^(1<<i));
            if(hash[to]>hash[now]+1)
            {
                hash[to]=hash[now]+1;
                que[++end]=to;
            }
        }
    }
}

int cal(int t,int s)
{
    int sum=0;
    for(int i=0;i<=19;i++)
    {
        int tmp=key[t]&(1<<i);
        int txt=key[s]&(1<<i);
        if(tmp^txt)
        sum++;
    }
    return sum;
}

int main()
{
//    freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(hash,1,sizeof(hash));
        ans=33;
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=5;j++)
            {
                scanf("%c",&a[j]);
                if(a[j]==' '||a[j]=='\n')
                j--;
            }
            int txt=1,sum=0;
            for(int j=1;j<=5;j++)
            {
                if(a[j]>='0'&&a[j]<='9')
                sum+=(a[j]-'0')*txt;
                else
                sum+=(a[j]-'A'+10)*txt;
                txt*=16;
            }
            key[i]=sum;
        }
        sort(key+1,key+1+n);
        for(int i=1;i<n;i++)
        ans=min(ans,cal(i,i+1));

        for(int i=1;i<=n;i++)
        {
            ans=min(ans,hash[key[i]]);
            front=1,end=0;
            que[++end]=key[i];
            hash[key[i]]=0;
            bfs();
        }

        cout<<ans<<endl;
    }
    return 0;
}