Catenyms+欧拉回路/欧拉路+并查集+POJ

Catenyms

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 9617		Accepted: 2524

Description

A catenym is a pair of words separated by a period such that the last letter of the first word is the same as the last letter of the second. For example, the following are catenyms: 

dog.gopher

gopher.rat

rat.tiger

aloha.aloha

arachnid.dog

A compound catenym is a sequence of three or more words separated by periods such that each adjacent pair of words forms a catenym. For example, 

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

Given a dictionary of lower case words, you are to find a compound catenym that contains each of the words exactly once.

Input

The first line of standard input contains t, the number of test cases. Each test case begins with 3 <= n <= 1000 - the number of words in the dictionary. n distinct dictionary words follow; each word is a string of between 1 and 20 lowercase letters on a line by itself.

Output

For each test case, output a line giving the lexicographically least compound catenym that contains each dictionary word exactly once. Output "***" if there is no solution.

Sample Input

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

Sample Output

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

解决方案：首先建立一个图的模型：用单词的首尾字母做节点，用单词做边。这些单词能连成一串，必须：1）能形成欧拉路或欧拉回路;2)要能构成一个连通图。先是判断是欧拉回路/欧拉路：记录每个顶点的出度与入度，若有一个点出度大入度1，一个点入度大出度1，其余出度等于入度，则为欧拉路；若每个店的出度与入度都相等，则为欧拉回路。然后判断是否为联通的，可用并查集来判断，这个就不用说了。然后是怎么建图的问题，这个最好用头插法建图，记录每个顶点所连得边及终点。再则就是输出要字典序的问题，可以这样子，先对单词进行排序，然后按照排好顺序的单词建图，是要从小到大，还是从大到小排呢。若是从小到大，由于是头插法建图，那么每次遍历边的时候，这个按字典序从大到小来遍历的，所以，我们应该从大到小排序。还有就是起点的问题：若是欧拉路，则出度比入度大1的那个点做起点，若是欧拉回路，字典序最小的点做起点。

code:
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#define MMAX 1003
using namespace std;
string word[MMAX];
int fa[27],in[27],out[27];
int Map[27][27];
bool vise[MMAX];
bool cmp(string a,string b)
{
    return a>b;
}
stack<string>S;
int N,k;
int head[27];
struct node
{
    int from,to;
    string word;
    int next;
} E[MMAX];
void add(int from,int to,string word)
{
    E[k].from=from;
    E[k].to=to;
    E[k].word=word;
    E[k].next=head[from];
    head[from]=k++;
}
bool vis[27];
int faset(int x)
{

    return x!=fa[x]?fa[x]=faset(fa[x]):x;
}
int C(char c)
{
    return int(c-'a');
}
void dfs(int v)
{
    for(int i=head[v]; i!=-1; i=E[i].next)
    {
        if(!vise[i])
        {
            vise[i]=true;
            dfs(E[i].to);
            S.push(E[i].word);

        }
    }

}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(head,-1,sizeof(head));
        memset(vis,false,sizeof(vis));
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        memset(Map,0,sizeof(Map));
        memset(vise,false,sizeof(vise));
        while(!S.empty())S.pop();
        for(int i=0; i<26; i++)
        {
            fa[i]=i;
        }
        scanf("%d",&N);
        for(int i=0; i<N; i++)
        {
            cin>>word[i];
        }
        sort(word,word+N,cmp);
        k=0;
        for(int i=0; i<N; i++)
        {
            int len=word[i].length();
            int st=C(word[i][0]),en=C(word[i][len-1]);
            add(st,en,word[i]);
            int x=faset(st),y=faset(en);
            vis[st]=true,vis[en]=true;
            if(x!=y)
            {
                fa[x]=y;
            }
            in[en]++,out[st]++;
        }
        bool flag=true;
        int pre=faset(C(word[0][0]));
        for(int i=0; i<26; i++)
        {
            if(vis[i])
            {
                if(pre!=faset(i))
                {
                    flag=false;
                    break;
                }
            }
        }
        int st,cst=0,cen=0,cnt=0;
        st=C(word[N-1][0]);
        for(int i=0; i<26; i++)
        {
            if(in[i]!=out[i])
            {
                if(abs(in[i]-out[i])>1)
                {
                    flag=false;
                    break;
                }
                if(in[i]+1==out[i]) cst++,st=i;

                if(out[i]+1==in[i]) cen++;
                cnt++;
            }
        }
        if((cst==1&&cen==1)||!cnt) ;
        else flag=false;
        if(flag)
        {
            dfs(st);
            while(!S.empty())
            {
                string temp=S.top();
                S.pop();
                cout<<temp<<".";
                if(S.size()==1) break;
            }
            cout<<S.top()<<endl;
            S.pop();
        }
        else
        {
            printf("***\n");
        }
    }
    return 0;
}