poj 2337 Catenyms(欧拉路径)

Catenyms

 

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
***

#include<cstdio>
#include<vector>
#include<cstring>
#include<stack>
#include<cstdlib>
#include<algorithm>
using namespace std;

struct str
{
    char word[35];
};

struct Edge
{
    int u,v;
};

str s[1005];
int in[27],out[27];
bool vis[1005];
vector<Edge>edges;
vector<int>G[1005];
stack<int>S;
int n,beg;
bool flag;

bool cmp(str a,str b)
{
    return strcmp(a.word,b.word)<0;
}

void init()
{
    edges.clear();
    while(!S.empty())S.pop();
    for(int i=0;i<26;i++)G[i].clear();
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    memset(vis,0,sizeof(vis));
    flag=0;
}

void dfs(int u)
{
    for(int i=0;i<G[u].size();i++)
    {
        int x=G[u][i];
        if(!vis[x])
        {
            vis[x]=1;
            dfs(edges[x].v);
            S.push(x);
        }
    }
}

void solve()
{
    int cnt1=0,cnt2=0;
    for(int i=0;i<26;i++)
    {
        if(in[i]==out[i])
            continue;
        else if(out[i]-in[i]==1)
        {
            cnt1++;
                beg=i;
            if(cnt1>=2)
                return;
        }
        else if(in[i]-out[i]==1)
        {
            cnt2++;
            if(cnt2>=2)
                return;
        }
        else
            return;
    }
    if(cnt1>1||cnt2>1)return;
    if(cnt1==0)
    for(int i=0;i<26;i++)
        if(out[i])
        {
            beg=i;
            break;
        }
    flag=1;
}

int main()
{
    //freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%s",s[i].word);
        sort(s,s+n,cmp);
        for(int i=0;i<n;i++)
        {
            int u=s[i].word[0]-'a';
            int v=s[i].word[strlen(s[i].word)-1]-'a';
            in[v]++;
            out[u]++;
            edges.push_back((Edge){u,v});
            G[u].push_back(i);
        }
        solve();
        if(!flag)
        {
            printf("***
");
            continue;
        }
        dfs(beg);
        if(S.size()!=n)
        {
            printf("***
");
            continue;
        }
        else
        {
            bool key=0;
            while(!S.empty())
            {
                int x=S.top();
                if(key)
                    printf(".");
                printf("%s",s[x].word);
                key=1;
                S.pop();
            }
            printf("
");
        }
    }
    return 0;
}