poj 2337 Catenyms(欧拉路径+并查集)

Catenyms

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 8078		Accepted: 2127

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

思路：

欧拉回路：图G，若存在一条路，经过G中每条边有且仅有一次，称这条路为欧拉路，如果存在一条回路经过G每条边有且仅有一次，

称这条回路为欧拉回路。具有欧拉回路的图成为欧拉图。

判断欧拉路是否存在的方法

有向图：图连通，有一个顶点出度大入度1，有一个顶点入度大出度1，其余都是出度=入度。

无向图：图连通，只有两个顶点是奇数度，其余都是偶数度的。

判断欧拉回路是否存在的方法

有向图：图连通，所有的顶点出度=入度。

无向图：图连通，所有顶点都是偶数度。

程序实现一般是如下过程：

1.利用并查集判断图是否连通，即判断p[i] < 0的个数，如果大于1，说明不连通。

2.根据出度入度个数，判断是否满足要求。

3.利用dfs输出路径。

代码：

 

#include<algorithm>
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
#include<stack>
using namespace std;


struct Nod
{
    int next;
    int to;
    char str[30];
}node[1010];

int parent[30];
//下面数组分别为出度，入度，存在标记，
int in[30],out[30],existmark[30],used[1010],adj[30];

stack<int> st;  //保存最后的结果，倒序输出

//并查集1
int findp(int u)
{
    while(u!=parent[u])
    {
        u=parent[u];
    }
    return u;
}

//并查集2
void unit(int u,int v)
{
    int r1=findp(u);
    int r2=findp(v);
    if(r1==r2)
        return ;
    parent[r1]=r2;
}

//排序，字典序倒序
bool cmp(Nod p1, Nod p2)
{
    return strcmp(p1.str, p2.str) > 0;
}

//初始化
void init()
{
    int i;
    for(i=0;i<26;i++)
        parent[i]=i;
    memset(in,0,sizeof(in));
    memset(out,0,sizeof(out));
    memset(existmark,0,sizeof(existmark));
    memset(used,0,sizeof(used));
    memset(adj,-1,sizeof(adj));
}
//欧拉路
void Eular(int start,int pos)
{
    int i;
    for(i=adj[start];i!=-1;i=node[i].next)
    {
        if(!used[i])
        {
            used[i]=1;
            Eular(node[i].to,i);
        }
    }
    if(0 <= pos)
        st.push(pos);
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        init();
        int i,v,u;
        for(i=0;i<n;i++)
        {
            scanf("%s",node[i].str);
        }
        sort(node, node + n, cmp);
        for(i=0;i<n;i++)
        {
            u=node[i].str[0]-'a';
            v=node[i].str[strlen(node[i].str)-1]-'a';
            out[u]++;
            in[v]++;
            existmark[u]=1;
            existmark[v]=1;
            unit(u,v);
            node[i].to=v;
            node[i].next=adj[u];
            adj[u]=i;
           // cout<<i<<" "<<u<<" "<<node[i].next<<endl;
        }

        int flag=0;
        for(i=0;i<26;i++)
        {
            if(existmark[i]&&parent[i]==i)
                flag++;
        }
        if(flag>1)
        {
            printf("***\n");
            continue;
        }

        int a=0,b=0,start=-1;
        for(i=0;i<26;i++)
        {
            if(in[i]!=out[i]&&existmark[i])
            {
                if(1==in[i]-out[i])
                {
                    a++;
                }else if(1==out[i]-in[i])
                {
                    b++;
                    start=i;
                }else
                {
                    break;
                }
            }
        }
        if(i<26)
        {
            printf("***\n");
            continue;
        }else
        {
            if(!((0 == a + b) || (1 == a && 1 == b)))
            {
                printf("***\n");
                continue;
            }
            //a+b==0或者1==a并且1==b时
            if(-1==start)
            {
                for(i=0;i<26;i++)
                {
                    if(out[i])
                        break;
                }
                start=i;
            }
            Eular(start, -1);
            //输出
            printf("%s", node[st.top()].str);
            st.pop();
            while(!st.empty())
            {
                 printf(".%s", node[st.top()].str);
                 st.pop();
            }
            printf("\n");
        }
    }
    return 0;
}