HDU 2360 (综合题)

题目意思 是任何只有一个字母不同的单词可以进行改变 最后要转换成全部不同的单词 根据理论每次转换的最小步长应该为单词长度

 

题目要求输出最小字典序的序列~~~

 

只要对输入的单词进行排序就能保证 然后首先建2张图 一张是只改变一个字母能变换的路径图 一个是都不相同单词之间的图

 

很好 下面就是BFS 使用一个数组保存父亲节点 找到后输出就可以了~~~

 

注意下BFS如果采用逐层遍历的话 使用阀值降低规模

 

以下是代码:

 

 

#include <iostream>
#include <queue>
#include <string>
using namespace std;

typedef struct  
{
    char key[30];
}Info;

inline int cmp(const void *p1, const void *p2)
{
    Info *a = (Info *)p1;
    Info *b = (Info *)p2;
    return strcmp(a->key,b->key);
}

long n,l;
long now[110];
long path[110];
bool One[110][110];
bool Map[110][110];
Info Data[110];
long tp[110];

inline long check (Info a,Info b)
{
    long i,j,res; 
    memset(tp,0,sizeof(tp));
    res=0; 
    for(i=0;i<l;++i) 
    { 
        for(j=0;j<l;++j) 
        {
            if(!tp[j]&&a.key[i]==b.key[j]) 
            {
                ++res;
                tp[j]=1;
                break;
            } 
        }
    } 
    return l-res;
}


typedef struct  
{
    long now;
    long pre;
    long step;
}Node;

queue<Node> q,save;
long hash[110];


inline void BFS()
{
    long i,j,len;
    long cost=INT_MAX;
    long pos=-1;

    for (i=0;i<n;++i)
    {
        while (!q.empty())
        {
            q.pop();
        }

        for (j=0;j<n;++j)
        {
            now[j]=j;
            hash[j]=INT_MAX;
        }

        Node Start;
        Start.now=i;
        Start.step=0;
        Start.pre=i;
        q.push(Start);

        len=0;

        while (!q.empty()&&++len<=cost)
        {
            while (!save.empty())
            {
                save.pop();
            }

            while (!q.empty())
            {
                Node t=q.front();
                q.pop();

                if (t.step>=hash[t.now])
                {
                    continue;
                }

                hash[t.now]=t.step;
                now[t.now]=t.pre;
                
                if (Map[i][t.now])
                {
                    if (t.step<cost)
                    {
                        cost=t.step;
                        memcpy(path,now,sizeof(path));
                        pos=t.now;
                        if (cost==l)
                        {
                            goto l1;
                        }
                    }
                    break;
                }

                for (j=0;j<n;++j)
                {
                    if (One[t.now][j]&&t.step+1<hash[j])
                    {
                        Node n;
                        n.pre=t.now;
                        n.now=j;
                        n.step=t.step+1;
                        save.push(n);
                    }
                }

            }

            while (!save.empty())
            {
                q.push(save.front());
                save.pop();
            }
        }

    }

l1:
        //题目保证有解
        string res;
        bool begin=true;

        while (pos!=path[pos])
        {
            if (begin)
            {
                res=string(Data[pos].key);
                begin=false;
            }
            else
            {
                res=string(Data[pos].key)+string(" ")+res;
            }
            pos=path[pos];
        }

        if (begin)
        {
            res=string(Data[pos].key);
        }
        else
        {
            res=string(Data[pos].key)+string(" ")+res;
        }
        puts(res.data());
        res.erase();
}



int main()
{
    long T;
    scanf("%ld",&T);

    while (T--)
    {
        long i,j;
        scanf("%ld %ld",&n,&l);
        getchar();

        for (i=0;i<n;++i)
        {
            gets(Data[i].key);
        }

        qsort(Data,n,sizeof(Info),cmp);
        memset(One,0,sizeof(One));
        memset(Map,0,sizeof(Map));

        for (i=0;i<n;++i)
        {
            for (j=i+1;j<n;++j)
            {
                long num=check(Data[i],Data[j]);
                if(num==1)
                {
                    One[i][j]=One[j][i]=true;
                }
                if (num==l)
                {
                    Map[i][j]=Map[j][i]=true;
                }
            }
        }

        BFS();

    }

    return 0;
}