Catenyms （寻找有向欧拉路+输出路径）

题目链接

大意：给你一串单词，首尾相同的单词才能相连，存在的话按字典序最小的输出。（单词的首尾暗示了这是一个有向图）

思路：本题的目的是考察找有向图存在欧拉回路的条件，（1.如果图连通，且每个点的出度等于入度，则存在欧拉回路 2 .如果图连通，且恰有一点u的出度比入度大1，另有一点v的出度比入度小1，其余的出度等于入度，则存在欧拉路，起点u终点v），用并查集来判断。

然后我们要考虑字典序是最小的，所以要提前排序，用edges【i】存放第i条边。lujing【】用来逆序存放边。

在判断时很多地方写得很巧妙，建议仔细斟酌。条件判断的时候也不能遗漏。

代码（从1开始的这种写法一直WA，暂未找到根源所在。。请见第二份代码）

#include<iostream>
#include<string.h>
#include<algorithm>
#include<stdio.h>
using namespace std;
const int maxn=1000+10;
int fa[27];
int mark[27];
int m;
int in[30];
int out[30];
int lujing[maxn];
int start;
int lala;
int findset(int i)
{
    if(fa[i]==-1)
        return i;
    return fa[i]=findset(fa[i]);
}
void init()
{
    memset(fa,-1,sizeof(fa));
    lala=1;
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    memset(mark,0,sizeof(mark));
    memset(lujing,0,sizeof(lujing));

}
struct E
{
    int u;
    int v;
    //int len;
    bool vis;
}edges[maxn];
struct words
{
    int len;
    char s[30];
    bool operator<(const words &b)const
    {
        return strcmp(s,b.s)<0;
    }
}words[maxn];

int judge()//判断是否弱连通
{
    int cnt=0;
    for(int i=1;i<=26;i++)
    {
        if(mark[i])
        {
            if(findset(i)==i)
            {
                cnt++;
            }
        }
    }
   return cnt==1;
}


void euler(int startt)
{
    for(int i=1;i<=m;i++)
    {
        if(!edges[i].vis&&startt==edges[i].u)
        {
            edges[i].vis=true;
            euler(edges[i].v);
            lujing[lala++]=i;
        }
    }
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        init();
        cin>>m;
        for(int i=1;i<=m;i++)
        {
           scanf("%s",words[i].s);
           words[i].len=strlen(words[i].s);
        }
        sort(words,words+m);
        for(int i=1;i<=m;i++)
        {
            int u=words[i].s[0]-'a'+1;
            int v=words[i].s[words[i].len-1]-'a'+1;
            mark[u]=true;
            mark[v]=true;
            edges[i].u=u;
            edges[i].v=v;

            edges[i].vis=false;
            out[u]++;
            in[v]++;

            u=findset(u);

            v=findset(v);

            if(u!=v)
            {
                fa[u]=v;
            }
        }

        int start=edges[0].u;
        int count1=0,count2=0;
        int i;
        for( i=1;i<=26;i++)
        {
            if(mark[i])
            {
                if(in[i]==out[i])
                    continue;
                else if(in[i]-out[i]==1)
                    count1++;
                else if(out[i]-in[i]==1)
                {
                    start=i;
                    count2++;
                }
                else
                    break;
            }
        }
  //      cout<<count1<<" "<<count2<<"  "<<judge()<<"   "<<endl;
        if(i==27&&((count1==count2&&count1==1)||(count1==count2&&count1==0))&&judge())
        {
            euler(start);
           cout<<words[lujing[lala-1]].s;
            for(int i=lala-2;i>=1;i--)
            {
                cout<<"."<<words[lujing[i]].s;
            }
            cout<<endl;
        }
        else
            cout<<"***"<<endl;

    }
    return 0;
}

AC代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1000+10;
struct Word
{
    int len;
    char s[20+5];
    bool operator <(const Word &b)const
    {
        return strcmp(s,b.s)<0;
    }
}words[maxn];
struct Edge
{
    int u,v;//u表示起点,v表示终点
    bool vis;
}edges[maxn];
int fa[26+5];          //并查集
int in[26+5],out[26+5];//入度,出度
bool mark[26+5];       //mark[i]=true,表i这个字母被用到作为图顶点了
int m;//单词数,即边数
int cnt,ans[maxn];//记录输出单词的序号,逆序
int findset(int u)
{
    if(fa[u]==-1) return u;
    return fa[u]=findset(fa[u]);
}
bool ok()//判断是否弱连通图
{
    int k=0;
    for(int i=0;i<26;i++)if(mark[i])
        if(findset(i)==i) k++;
    return k==1;
}
void euler(int u)
{
    for(int i=0;i<m;i++)if(!edges[i].vis && edges[i].u==u)//本边未走过且起点吻合
    {
        edges[i].vis=true;
        euler(edges[i].v);
        ans[cnt++]=i;
    }
}
int main()
{
    int T; scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            scanf("%s",words[i].s);
            words[i].len=strlen(words[i].s);
        }
        sort(words,words+m);

        memset(fa,-1,sizeof(fa));
        memset(mark,0,sizeof(mark));
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        for(int i=0;i<m;i++)
        {
            int u,v;
            u=words[i].s[0]-'a';
            v=words[i].s[words[i].len-1]-'a';
            edges[i].u=u;
            edges[i].v=v;
            edges[i].vis=false;     //表示该边还未被访问
            mark[u]=mark[v]=true;
            in[v]++, out[u]++;
            u=findset(u), v=findset(v);
            if(u!=v) fa[u]=v;       //合并连通分量
        }

        int start=edges[0].u;//欧拉路径起始点的编号
        int i,c1=0,c2=0;                //错误1,这里c1与c2忘了初始化
        for(i=0;i<26;i++)if(mark[i])
        {
            if(in[i]==out[i]) continue;
            else if(in[i]-out[i]==1) c1++;
            else if(out[i]-in[i]==1) c2++,start=i;
            else break;
        }
  //      cout<<ok()<<endl;
        if(i==26&&((c1==c2&&c1==0)||(c1==c2&&c1==1)) && ok() )//所有点度符合要求且弱连通
        {
            cnt=0;
            euler(start);
            printf("%s",words[ans[cnt-1]].s);
            for(int i=cnt-2;i>=0;i--)
                printf(".%s",words[ans[i]].s);
            printf("\n");
        }
        else printf("***\n");
    }
    return 0;
}