POJ_2513_Trie树+欧拉回路+并查集

链接：http://poj.org/problem?id=2513

1.把木棒的端点考虑为顶点，木棒考虑为边，建立起一个无向图。

2.问题转化为在无向图上判断是否有欧拉回路或者欧拉道路。

3.在无向图上判断是否有欧拉回路或者欧拉道路：欧拉定理+并查集（判断连通性）

4.考虑如何统计每个顶点的度，开始用的是暴力解法，直接用数组记录顶点，并且通过顺序查找获得顶点编号，TLE，然后考虑用map（红黑树），每次以logn的时间复杂度完成顶点度的  更新，继续TLE，想到用HASH，不过没想到好的映射方式，最后搜解题报告，发现trie树这种玩意。

6.Trie树能以O(sizeof(key))的时间复杂度完成字符串的查找，所以每次更新顶点度的时间复杂度可以优化为O(1)，这样应该不会超时。

7.Trick:在没有任何木条时，应该输出Possible.

8.静态实现Trie比动态实现Trie更快。

9.实现代码（动态+递归）：

#include<iostream>
	#include<cstdio>
	#include<cstring>
	using namespace std;
	const int MAXN = 500001;
	int p[MAXN],maxv=0,deg[MAXN];
	void init()
	{
	     for(int i=0;i<MAXN;i++)
	     p[i] = i,deg[i]=0;
	}
	int find(int x)
	{
	    return x==p[x]?x:p[x]=find(p[x]);
	}
	void merge(int x,int y)
	{
	     int r1 = find(x),r2 = find(y);
	     if(r1==r2)return;
	     p[r1] = r2;
	}
	bool Euler()
	{
	     int cnt = 0;
	     for(int i=0;i<maxv;i++)
	     {
	         if(deg[i]&1) cnt++;
	     }
	     return cnt==0||cnt==2;
	}
	bool conn()
	{
	     int cnt = 0;
	     for(int i=0;i<maxv;i++)
	     {
	         if(p[i]==i)cnt++;
	     }
	     if(cnt==1)return true;
	     else return false;
	}
	struct node
	{
	    int id;
	    node* next[26];
	    node()
	    {
	        for(int i=0;i<26;i++)
	        next[i] = NULL;
	        id = -1;
	    }
	};
	struct trie
	{
	   node *root;
	   int wordnum;
	   trie()
	   {
	       root = new node();
	       wordnum = 0;
	   }
	   ~trie()
	   {
	       clear(root);
	   }
	   void clear(node *cur)
	   {
	        for(int i=0;i<26;i++)
	        {
	            if((*cur).next[i]!=NULL)
	            {
	               clear((*cur).next[i]);
	               delete (*cur).next[i];
	               (*cur).next[i]=NULL;
	            }
	        }
	   }
	   int find(char *key,int cur,node *curr,int len)
	   {
	        if(cur==len)
	        {       
	           if(curr->id==-1)return -1;//没找到 
	           return curr->id;   
	        }
	        int site = key[cur]-'a';
	        if((*curr).next[site]==NULL)
	        {
	             return -1;
	        }//没找到
	        return find(key,cur+1,(*curr).next[site],len); 
	   }
	   void insert(char *key,int cur,node *curr,int len)
	   {
	        if(cur==len)
	        {
	            curr->id = wordnum++;
	            return;
	        }
	        int site = key[cur]-'a';
	        if((*curr).next[site]==NULL)
	        {
	            (*curr).next[site] = new node();
	        }
	        insert(key,cur+1,(*curr).next[site],len);
	   }
	};
	int main()
	{
	    int i=0;
	    char f[12],s[12];
	    trie tree;
	    init();
	    while(1)
	    {
	        for(i=0;~(f[i]=getchar())&&f[i]!=' ';i++);
	        if(f[i]==-1)break;
	        f[i] = 0;
	        for(i=0;(s[i]=getchar())!='\n';i++);
	        s[i] = 0;
	        int u,v;
	        u = tree.find(f,0,tree.root,strlen(f));
	        if(u==-1)
	        {
	            tree.insert(f,0,tree.root,strlen(f));
	            u = tree.wordnum-1;
	            deg[u] = 1;
	        }
	        else deg[u]++;
	        v = tree.find(s,0,tree.root,strlen(s));
	        if(v==-1)
	        {
	            tree.insert(s,0,tree.root,strlen(s));
	            v = tree.wordnum-1;
	            deg[v] = 1;
	        }
	        else deg[v]++; 
	        merge(u,v);
	    }
	    maxv = tree.wordnum;
	    if(maxv==0){
	       printf("Possible\n");
	       return 0;
	    }
	    bool ok = Euler()&&conn();
	    if(ok) printf("Possible\n");
	    else printf("Impossible\n");
	    return 0;
	}

10.静态实现+迭代，代码：

#include<iostream>
	#include<cstring>
	#include<cstdio>
	using namespace std;
	struct trie_node
	{
	    int id;
	    int next[26];
	    trie_node()
	    {
	        for(int i=0;i<26;i++)next[i] = 0;
	        id = -1;
	    }
	}trie[700000];
	const int MAXN = 500002;
	int p[MAXN],deg[MAXN],maxv=0,trieM=2;
	void init()
	{
	    for(int i=0;i<MAXN;i++)p[i]=i;
	}
	int find(int x)
	{
	    return x==p[x]?x:p[x]=find(p[x]);
	}
	void merge(int x,int y)
	{
	     int r1 = find(x),r2 = find(y);
	     if(r1==r2)return;
	     p[r1] = r2;
	}
	int insert(char *word)
	{
	    int now;
	    int ptr = 1;
	    char *p = word;
	    while(*p)
	    {
	        now = *p-'a';
	        if(!trie[ptr].next[now])trie[ptr].next[now]=trieM++;
	        ptr = trie[ptr].next[now];
	        p++;
	    }
	    //如果没有该元素 
	    if(trie[ptr].id==-1)
	    {
	        trie[ptr].id = maxv++;
	    }
	    return trie[ptr].id;
	}
	bool conn()
	{
	     int cnt = 0;
	     for(int i=0;i<maxv;i++)
	     if(p[i]==i)cnt++;
	     return cnt==1;
	}
	bool euler()
	{
	     int cnt = 0;
	     for(int i=0;i<maxv;i++)
	     {
	         if(deg[i]&1)cnt++;
	     }
	     return cnt==0||cnt==2;
	}
	int main()
	{
	    char f[11],s[11];
	    init();
	    while(scanf("%s%*c%s%*c",f,s)!=EOF)
	    {
	        int u = insert(f);
	        int v = insert(s);
	        deg[u]++,deg[v]++;
	        merge(u,v);
	    }
	    if(maxv==0)puts("Possible");
	    else
	    {
	        bool ok = euler()&&conn();
	        if(ok) puts("Possible");
	        else puts("Impossible");
	    }
	    return 0;
	}