POJ2337 Catenyms

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 11394		Accepted: 2953

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

Source

Waterloo local 2003.01.25

欧拉道路问题。因为要求字典序，所以最好先对字符串排序再dfs。

昨天睡得晚，今天智商下滑。打开编译器，连判是否构成欧拉路都没写，直接排了个序开始暴搜……在被数据卡掉之前已经TLE了。

然后全删了代码开始老老实实写欧拉回路，这回变成了WA，想了想，加了一行代码判欧拉回路起始点，AC。

积累了一个字符串排序的方法：

另开一个数组sk给每个字符串标号，然后对sk数组进行排序，就可以得到字符串的排序。和指针有些像。（然而并不会用指针）

#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
int n;
char s[1200][50];
int sk[1200];
int cmp(int a,int b){
    if(strcmp(s[a],s[b])==-1)return 0;
    return 1;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        int i,j;
        for(i=1;i<=n;i++){
            scanf("%s",s[i]);
            sk[i]=i;
        }
        sort(sk+1,sk+n+1,cmp);
    }
    return 0;
}

然后是正解：

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int mxn=1200;
int n;
int in[mxn],out[mxn];
string s[mxn];
struct edge{
    int u,v,next;
    int id;
    int vis;
}e[mxn*3];
int hd[30],ect=0;
int ans[mxn];
int cnt=0;
void add_edge(int u,int v,int id){
    e[++ect].u=u;e[ect].v=v;e[ect].id=id;
    e[ect].next=hd[u];e[ect].vis=0;hd[u]=ect;
}
void dfs(int u){
    for(int i=hd[u];i;i=e[i].next){
        if(!e[i].vis){
            e[i].vis=1;
            dfs(e[i].v);
            ans[++cnt]=e[i].id;
        }
    }
    return;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        memset(in,0,sizeof in);
        memset(out,0,sizeof out);
        memset(hd,0,sizeof hd);
        scanf("%d",&n);
        int i,j;
        ect=0;
        for(i=1;i<=n;i++)cin>>s[i];
        sort(s+1,s+n+1);
        for(i=n;i;i--){
            int u=s[i][0]-'a';
            int v=s[i][s[i].length()-1]-'a';
            in[v]++;
            out[u]++;
            add_edge(u,v,i);
        }
         int st=0,ed=0;
        bool flag=0;
        for(i=0;i<26;i++){
            if(out[i]!=in[i]){//出度不等于入度时判定 
                if(out[i]==in[i]+1){
                    if(!st)st=i;
                    else flag=1;
                }
                else if(in[i]==out[i]+1){
                    if(!ed)ed=i;
                    else flag=1;
                }
                else flag=1;
            }
        }
        if(!st)for(i=0;i<26;i++)
                if(out[i]){
                    st=i;
                    break;
                }
        if(flag){
              printf("***
");
            continue;
        }
        cnt=0;
        dfs(st);
        if(cnt!=n){
            printf("***
");
            continue;
        }
        for(i=n;i>1;i--){
            cout<<s[ans[i]];
            printf(".");
        }
        cout<<s[ans[1]]<<endl;
    }
    return 0;
}