POJ 2337 Catenyms（欧拉回（通）路：路径输出+最小字典序）

题目链接：http://poj.org/problem?id=2337

题目大意：给你n个字符串，只有字符串首和尾相同才能连接起来。请你以最小字典序输出连接好的单词。

解题思路：跟POJ1386一个意思，就是把26个字母当成点，单词当做有向边，判断欧拉回（通）路。但是要输出路径也就是单词，而且要求字典序最小。

可以通过将单词先排序再添加边使字典序最小，还有注意起点，如果有一个出度比入度大1的点，就从这个点出发，否则从最小的点出发。

代码：

 #include<iostream>
 #include<algorithm>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<stack>
 #define CLR(arr,val) memset(arr,val,sizeof(arr))
 #define FAST_IO ios::sync_with_stdio(false);cin.tie(0);
 using namespace std;
 const int M=2e4+;
 const int N=1e4+;

 struct node{
     int to,next;
     string w;
 }edge[M];

 int idx;
 int indeg[N],outdeg[N],head[N];
 string str[M];
 bool vis[M];
 stack<string>sk;

 void init(){
     idx=;
     CLR(head,);
     CLR(indeg,);
     CLR(outdeg,);
     CLR(vis,false);
     while(!sk.empty()){
         sk.pop();
     }
 }

 void addedge(int u,int v,string w){
     edge[idx].to=v;
     edge[idx].w=w;
     edge[idx].next=head[u];
     head[u]=idx++;
 }

 void dfs(int u){
     for(int &j=head[u];j;j=edge[j].next){
         node t=edge[j];
         if(!vis[j]){
             vis[j]=true;
             dfs(t.to);
             sk.push(t.w);
         }
     }
 }

 int main(){
     FAST_IO;
     int t;
     cin>>t;
     while(t--){
         init();
         int n;
         cin>>n;
         for(int i=;i<n;i++)
             cin>>str[i];
         sort(str,str+n);
         int start=;
         //字典序大的先加入，因为静态邻接表是反向添加的
         for(int i=n-;i>=;i--){
             int u,v;
             u=str[i][]-'a';
             v=str[i][str[i].length()-]-'a';
             outdeg[u]++;
             indeg[v]++;
             addedge(u,v,str[i]);
             start=min(start,min(u,v));
         }
         int chu=,ru=;
         bool flag=true;
         for(int i=;i<;i++){
             if(indeg[i]+outdeg[i]==)
                 continue;
             if(indeg[i]!=outdeg[i]){
                 if(indeg[i]+==outdeg[i]){
                     chu++;
                     start=i;                //如果有一个出度比入度大1的点，就从这个点出发，否则从最小的点出发
                 }
                 else if(indeg[i]-==outdeg[i])
                     ru++;
                 else
                     flag=false;
             }
         }
         if(flag&&(chu==&&ru==||chu==&&ru==)){
             dfs(start);
             if(sk.size()==n){
                 while(!sk.empty()){
                     if(sk.size()==)
                         cout<<sk.top()<<endl;
                     else
                         cout<<sk.top()<<".";
                     sk.pop();
                 }
             }
             else
                 puts("***");
         }
         else
             puts("***");
     }
     return ;
 }