NYOJ 单词拼接

单词拼接

时间限制： 3000 ms  |  内存限制： 65535 KB

难度： 5

描述

给你一些单词，请你判断能否把它们首尾串起来串成一串。

前一个单词的结尾应该与下一个单词的道字母相同。

如

aloha

dog

arachnid

gopher

tiger

rat

 

可以拼接成：aloha.arachnid.dog.gopher.rat.tiger

输入

第一行是一个整数N(0<N<20)，表示测试数据的组数
每组测试数据的第一行是一个整数M,表示该组测试数据中有M(2<M<1000)个互不相同的单词，随后的M行，每行是一个长度不超过30的单词,单词全部由小写字母组成。

输出

如果存在拼接方案，请输出所有拼接方案中字典序最小的方案。(两个单词之间输出一个英文句号".")
如果不存在拼接方案，则输出
***

样例输入

2
6
aloha
arachnid
dog
gopher
rat
tiger
3
oak
maple
elm

样例输出

aloha.arachnid.dog.gopher.rat.tiger
***

1：判断有向图欧拉图

2 ：对单词排序，深搜求最小字典顺，深搜时标记每个边是否使用过

 
#include<bits/stdc++.h>
using namespace std;
#pragma comment(linker,"/STACK:1024000000,1024000000")
const int maxn = 1005*2;
struct node
{
    int to ;
    int order;
};
vector<node>g[maxn];
stack<string>s;
int f[maxn];
int vis[maxn];
int in[maxn];
int out[maxn];
int flag[maxn];
int n;
int  bian[maxn];
string a[maxn];
int res =1;
void init()
{
    for(int i= 0 ; i<=26; i++)
    {
        f[i]  = i;
    }
    for(int i = 0 ; i<n; i++)
        g[i].clear();
    memset(vis,0,sizeof(vis));
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    memset(flag,0,sizeof(flag));
    memset(bian,0,sizeof(bian));

}
bool  dfs( int u,int cot,int id)
{
    if(cot==n+1)
    {
        return true;

    }
    for(int i = 0 ; i<g[u].size(); i++)
    {
        if(!bian[g[u][i].order])
        {
            bian[g[u][i].order] = 1;
            if(dfs(g[u][i].to,cot+1,g[u][i].order))
            {
                string temp = a[g[u][i].order];
                // cout<<temp <<endl;
                s.push(temp);
                bian[g[u][i].order] = 0;
                //bian[id] = 0 ;
                return true;
            }
            bian[g[u][i].order] = 0;
        }
    }
    return false;
}
int find(int x)
{
    return x==f[x]?x:f[x] = find(f[x]);

}
void add(int x,int y)
{
    int bx = find(x);
    int by = find(y);
    if(bx!=by)
    {
        f[bx] = by;
    }
}
bool judge()
{
    int cot = 0;
    for(int i = 0 ; i<26; i++)
    {
        if(f[i]==i&&flag[i])
            cot++;
    }
    if(cot>1)
        return false;
    return true;
}
int main()
{

    int T;
    scanf("%d",&T);
    while(T--)
    {
        while(!s.empty())
            s.pop();
        res = 0;
        scanf("%d",&n);
        init();
        for(int i = 1 ; i<=n; i++)
        {
            //scanf("%s",a[i]);
            cin>>a[i];
        }

        sort(a+1,a+n+1);
        for(int i = 1 ; i<=n; i++)
        {
            int x = a[i][0]-'a';
            int y = a[i][a[i].size()-1]-'a';
            g[x].push_back((node)
            {
                y,i
            });
            flag[x] = 1;
            flag[y] = 1;
            add(x ,y);
            in[y]++;
            out[x]++;
        }
        int cot = 0;
        int xx,yy;
        for(int i = 0 ; i<26; i++)
        {
            if(in[i]!=out[i])
            {
                cot++;
                if(cot==1)
                {
                    xx = i;
                }
                else if(cot==2)
                {
                    yy = i;
                }
            }
        }

        if(judge())
        {
            if(cot==0||(cot==2&&((in[xx]-out[xx]==1&&out[yy]-in[yy]==1)||(  in[yy]-out[yy]==1&&out[xx]-in[xx]==1)   )))
            {
                // printf("cot = %d\n",cot);
                if(cot==0)
                {
                    if(dfs(a[1][0]-'a',1,1))
                    {
                        while(!s.empty())
                        {
                            cout<<s.top();
                            s.pop();
                            if(!s.empty())
                                cout<<".";
                        }
                    }
                }
                else
                {
                    int jj = 0 ;
                    for(int i = 0 ; i<26&&!jj; i++)
                    {
             
                        if(out[i]-in[i]==1)
                        {
                           
                            if(dfs(i,1,1))
                            {
                       
                                while(!s.empty())
                                {
                                      cout<<s.top();
                                    s.pop();
                                    if(!s.empty())
                                        cout<<".";
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                printf("***");
            }
        }
        else
        {
            printf("***");
        }
        printf("\n");
    }
    return 0 ;
}