POJ2337 Catenyms（欧拉通路的求解）

                                                           Catenyms

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 11526		Accepted: 2993

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 <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <climits>
#include <cstring>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include<functional>
#define mod 1000000007
#define inf 0x3f3f3f3f
#define pi acos(-1.0)
using namespace std;
typedef long long ll;
const int N=;
const int M=;
ll power(ll a,int b,ll c) {
    ll ans=;
    while(b) {
        if(b%==) {
            ans=(ans*a)%c;
            b--;
        }
        b/=;
        a=a*a%c;
    }
    return ans;
}
struct Word { int l; char s[]; };
struct Edge { int st, ed; bool del; };

Word word[];
Edge edge[];
int in[], out[];
int stk[], father[];
bool mark[];
int E, top;

int cmp ( const void* a, const void* b )
{
    return strcmp( ((Word*)a)->s, ((Word*)b)->s );
}

int find_set ( int x )
{
    if ( father[x] != x )
        father[x] = find_set ( father[x] );
    return father[x];
}

bool judge ()
{
    int t = ;
    for ( int i = ; i < ; i++ )
        if ( mark[i] && father[i] == i ) t++;
    return t == ;
}

void find_path ( int u )
{
    for ( int i = ; i < E; i++ )
    {
        if ( ! edge[i].del && edge[i].st == u )
        {
            edge[i].del = true;
            find_path ( edge[i].ed );
            stk[top++] = i;
        }
    }
}

int main()
{
    int cs;
    scanf("%d",&cs);
    while ( cs-- )
    {
        scanf("%d",&E);
        int u, v, c1, c2, start, i;

        for ( i = ; i < ; i++ )
        {
            in[i] = out[i] = ;
            father[i] = i;
            mark[i] = false;
        }

        for ( i = ; i < E; i++ )
        {
            scanf("%s",word[i].s);
            word[i].l = strlen(word[i].s);
        }

        qsort(word, E, sizeof(word[]), cmp);

        for ( i = ; i < E; i++ )
        {
            u = word[i].s[] - 'a';
            v = word[i].s[word[i].l-] - 'a';
            edge[i].st = u;
            edge[i].ed = v;
            edge[i].del = false;
            mark[u] = mark[v] = true;
            out[u]++; in[v]++;
            u = find_set ( u );
            v = find_set ( v );
            if ( u != v ) father[v] = u;
        }

        c1 = c2 = ;
        start = edge[].st;
        for ( i = ; i < ; i++ )
        {
            if ( in[i] == out[i] ) continue;
            else if ( in[i] -  == out[i] ) c1++;
            else if ( out[i] -  == in[i] ) { c2++; start = i; }
            else break;
        }

        if ( i ==  && ((c1 == c2 && c1 == ) || (c1 == c2 && c1 == )) && judge() )
        {
            top = ;
            find_path ( start );
            for ( i = top - ; i > ; i-- )
                printf("%s.",word[stk[i]].s);
            printf("%s\n",word[stk[]].s);
        }
        else printf("***\n");
    }
    //system("pause");
    return ;
}