nyoj99（欧拉路）

http://acm.nyist.net/JudgeOnline/problem.php?pid=99

TLE: 首先建立一个Trie树，然后利用dfs贪心地去寻找可以拼接的单词。在dfs中，由于每次都是从最小的字母开始找起，所以只要能够找到就一定保证是字典序最小的。。。可惜超时了。。其实仔细想想也是的，每一个节点都要循环26次。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;

const int maxn = 1000;
struct Node
{
    int id,back;
    Node *next[26];
};
int n,cnt,ans[maxn];
char str[1010][30];
bool vis[maxn];
Node *T;

void build(char *s)
{
    int len = strlen(s);
    Node *p = T;
    for(int i = 0; i < len; i++)
    {
        if(p->next[s[i]-'a'] == NULL)
        {
            p->next[s[i]-'a'] = (Node *)malloc(sizeof(Node));
            p->next[s[i]-'a']->id = p->next[s[i]-'a']->back = 0;
            for(int j = 0; j < 26; j++)
                p->next[s[i]-'a']->next[j] = NULL;
        }
        p = p->next[s[i]-'a'];
    }
    p->id = ++cnt; p->back = s[len-1] - 'a';
}

bool dfs(Node *root,int num)
{
    if(root == NULL) return false;
    if(root->id > 0 && vis[root->id] == false)
    {
        ans[num] = root->id;
        if(num == n) return true;
        vis[root->id] = true;
        if(dfs(T->next[root->back],num+1)) return true;
        vis[root->id] = false;
        return false;
    }
    for(int i = 0; i < 26; i++)
    {
        if(root->next[i] == NULL) continue;
        if(dfs(root->next[i],num)) return true;
    }
    return false;
}

int main()
{   
    int t;
    scanf("%d",&t);
    while(t--)
    {
        T = (Node *)malloc(sizeof(Node));
        T->id = T->back = 0; 
        for(int i = 0; i < 26; i++) T->next[i] = NULL;
        cnt = 0;
        scanf("%d",&n);
        for(int i = 1; i <= n; i++)
        {
            getchar();
            scanf("%s",str[i]);
            build(str[i]);
        }
        memset(vis,false,sizeof(vis));
        if(dfs(T,1))
        {
            for(int i = 1; i <= n; i++)
                if(i == 1)
                    printf("%s",str[ans[i]]);
                else printf(".%s",str[ans[i]]);
        }
        else printf("***");
        printf("\n");
    }
    return 0;
}

AC（copy别人的）：以字母为节点的有向图的欧拉路径，有向图的欧拉路径的充要条件是所有节点的入度等于出度，或者有一个节点的入度比出度小1，同时有一个节点的入度比出度大1。当然首先这个图得是连通的，后面会通过DFS来判断。
首先通过入度出度的条件判断能否形成欧拉路径。
若能形成，则让入度比出度小1的节点作为起始点（若没有这样的节点，就按字典顺序选第1个出现的字母作为起始点），进行dfs，找到满足条件的路径，若dfs找不到，那说明该图还是连通图

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct node
{
    char s[31];
    int first,last;
};

node a[1001];
int degree_in[1001],degree_out[1001],m,order[1001];
bool used[1001];

int f()
{
    int x1,x2,ans=0,i;
    x1=x2=0;
    for(i=0;i<26;++i)
    {
        if(abs(degree_in[i]-degree_out[i])>=2)
            return -1;
        else if(degree_in[i]-degree_out[i]==1)
            x1++;
        else if(degree_in[i]-degree_out[i]==-1)
        {
            x2++;
            ans=i;
        }
    }
        if(x1>1||x2>1) //当时三个度时，必定是 12 和21，相同的不能大于等于2，不然不能构成欧拉回路
            return -1;
        else if(x1==0)
        {
            for(i=0;i<26;++i)
                if(degree_out[i])
                    return i; //找到一个就行
        }
        else
            return ans;

}
bool cmp(node a,node b)
{
    return strcmp(a.s,b.s)<0;
}

bool dfs(int st,int cnt)
{
    int i;
    if(cnt==m)
        return 1;
    for(i=0;i<m;++i)
    {
        if(a[i].first<st||used[i])
            continue;
        else if(a[i].first>st)
            return false;
        used[i]=true;
        order[cnt]=i;
        if(dfs(a[i].last,cnt+1))
            return 1;
        used[i]=false;//回溯判断是否形成欧拉路径
    }
    return false;
}


int main()
{
    int N,len,i,start;
    scanf("%d",&N);
    while(N--)
    {
        memset(used,false,sizeof(used));
        memset(degree_out,0,sizeof(degree_out));
        memset(degree_in,0,sizeof(degree_in));
        scanf("%d",&m);
        for(i=0;i<m;++i)
        {
            scanf("%s",a[i].s);
            len = strlen(a[i].s);
            a[i].first =a[i].s[0]-'a';
            a[i].last =a[i].s[len-1]-'a';
            degree_out[a[i].s[0]-'a']++;
            degree_in[a[i].s[len-1]-'a']++;//注意这里的入肚出度
        }
        start=f();
        if(start ==-1)
        {
            printf("***\n");
            continue;
        }
        sort(a,a+m,cmp);
        if(!dfs(start,0))
        {
            printf("***\n");
            continue;
        }
       printf("%s",a[order[0]].s);
      for(i=1;i<m;i++)
         printf(".%s",a[order[i]].s);
      printf("\n");
    }
    return 0;
}