poj 2337 有向图输出欧拉路径

Catenyms

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 10186		Accepted: 2650

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<cstring>
 #include<cstdio>
 #include<string>
 #include<algorithm>
 #include<climits>
 #define MAXE 1010
 #define MAXP 28
 using namespace std;
 struct Edge
 {
     int s,t,next;
     char str[];
 }edge[MAXE];
 int head[MAXE];
 int degree[MAXP];
 int fa[MAXP];
 int stack[MAXE];
 bool used[MAXP];
 bool sign[MAXE];
 bool cur[MAXE][MAXE];
 int start;
 int n;
 int top;
 bool cmp(Edge a,Edge b)
 {
     return strcmp(a.str,b.str)>;
 }
 void add(int s,int t,int ent)
 {
     edge[ent].s=s;
     edge[ent].t=t;
     edge[ent].next=head[s];
     head[s]=ent;
 }
 int find(int x)
 {
     int temp=x,i;
     while(fa[x]!=x)
         x=fa[x];
     while(fa[temp]!=x)
     {
         i=fa[temp];
         fa[temp]=x;
         temp=i;
     }
     return x;
 }
 bool oula()
 {
     int temp=,temp2=;
     start=edge[n].s;
     for(int i=;i<=;i++)
     {
         if(used[i])
         {
             if(fa[i]==i)temp++;
             if(degree[i])
             {
                 if(degree[i]>||degree[i]<-)return false;
                 if(degree[i]==-)start=i;
                 temp2++;
             }
         }
     }
     if(temp!=)return false;
     if(temp2&&temp2!=)return false;
     return true;
 }
 void dfs(int s)
 {
     for(int i=head[s];i!=-;i=edge[i].next)
     {
         if(!sign[i])
         {
             sign[i]=true;
             dfs(edge[i].t);
             stack[++top]=i;
         }
     }
     /*while(1)
     {
         if(top==n)break;
         int temp=head[s];
         for(int i=head[s];i!=-1;temp=i=edge[i].next)
         {
             if(!sign[i]&&!cur[stack[top]][i])break;
         }
         if(temp==-1)
         {
             cur[stack[top-1]][stack[top]]=true;
             sign[stack[top]]=false;
             sign[stack[top-1]]=false;
             s=edge[stack[--top]].s;
         }
         else
         {
             stack[++top]=temp;
             s=edge[temp].t;
             sign[temp]=true;
         }
     }*/
 }
 int main()
 {
     int cas;
     scanf("%d",&cas);
     while(cas--)
     {
         memset(head,-,sizeof(head));
         memset(sign,false,sizeof(sign));
         memset(used,false,sizeof(used));
         memset(cur,false,sizeof(cur));
         memset(degree,,sizeof(degree));
         scanf("%d",&n);
         for(int i=;i<=n;i++)
             scanf("%s",edge[i].str);
         sort(edge+,edge++n,cmp);
         for(int i=;i<=;i++)
             fa[i]=i;
         for(int i=;i<=n;i++)
         {
             int s=edge[i].str[]-'a'+,t=edge[i].str[strlen(edge[i].str)-]-'a'+;
             add(s,t,i);
             fa[find(t)]=find(s);
             degree[s]--;
             degree[t]++;
             used[s]=true;
             used[t]=true;
         }
         if(!oula())
         {
             printf("***\n");
         }
         else
         {
             top=;
             dfs(start);
             /*for(int i=1;i<=top-1;i++)
                 printf("%s.",edge[stack[i]].str);
             printf("%s\n",edge[stack[top]].str);*/
             for(int i=top;i>=;i--)
                 printf("%s.",edge[stack[i]].str);
             printf("%s\n",edge[stack[]].str);
         }
     }
     return ;
 }