poj 2513解题报告

题目来源：http://poj.org/problem?id=2513

题目大意：

给你n根木棒，每个木棒两端都涂有颜色，任意两根木棒可以连在一起，如果他们有一端颜色是相同的，问你最后是否能把所有的木棒连成一根。

题目分析：

这道题是一个欧拉通路的判断，但是令人纠结的是，节点不是整数而是字符串，很头疼啊= =

如果不了解欧拉通路可以自己百度一下。。

因为节点是字符串，所以我们要把它转换成整数的节点，这就涉及到字符串的查找，但是map在这题是会超时的。。。所以想到可以用AC自动机

代码实现：

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

typedef char char_t;//字符的类型，需要的话可以改成int等
const int SIGMA=26;//字符集的大小
const int ELEMENT_MAX=5000100;//trie图中最多可能的节点数，用于内存管理
#define MAX 500010
int father[MAX],rank[MAX];
int ID;
char s1[MAX/2][15],s2[MAX/2][15];
int d[MAX];
int degree[MAX];
bool vis[MAX];
int len1[MAX/2],len2[MAX/2];
struct TrieGraph
{
    struct trie
    {
        bool match;
        int id;
        trie *pre,*child[SIGMA];
        trie():match(false),pre(0)
        {
            memset(child,0,sizeof(child));
            id = -1;
        }
        void* operator new(size_t, void *p)
        {
            return p;
        }
    } root,superroot;
    static char storage[ELEMENT_MAX*sizeof(trie)];
    static trie* data;
    static void init()
    {
        data=(trie*)storage;
    }
    void insert(char_t* s,int n) //在trie中插入一个长度为n的字符串s
    {
        //如果需要在trie节点中记录某些信息，一般是在这个函数里添加
        trie* t=&root;
        for(int i=0; i<n; ++i)
        {
            char_t c=s[i];
            if(!t->child[c])
            {
                t->child[c]=new((void*)data++) trie;
                if(i == n-1)
                {
                    ID++;
                }
            }
            t=t->child[c];
        }
        if(!t->match)
        {
            t->match=true;
            t->id = ID;
        }
    }
    void build_graph() //所有的插入完毕后，将trie树扩充为图
    {
        static trie* Q[ELEMENT_MAX];
        superroot.pre=root.pre=&superroot;
        for(int i=0; i<SIGMA; ++i)
            superroot.child[i]=&root;
        int head=0,tail=0;
        Q[tail++]=&root;
        while(head!=tail)
        {
            trie* t=Q[head++];
            t->match|=t->pre->match;
            for(int i=0; i<SIGMA; ++i)
            {
                if(t->child[i])
                {
                    t->child[i]->pre=t->pre->child[i];
                    Q[tail++]=t->child[i];
                }
                else
                    t->child[i]=t->pre->child[i];
            }
        }
    }
    int match(char_t* s,int n) //返回长度为n的字符串s中有否已被插入的字符串的匹配
    {
        trie* t=&root;
        for(int i=0; i<n; ++i)
        {
            t=t->child[s[i]];
        }
        return t->id;
    }
};
char TrieGraph::storage[ELEMENT_MAX*sizeof(trie)];
TrieGraph::trie* TrieGraph::data;
void make_set()
{
    int i;
    for(int i=1; i<=MAX/2; i++)
    {
        rank[i] = 0;
        father[i] = i;
    }
}
int find_set(int x)
{
    if(x != father[x])
    {
        father[x] = find_set(father[x]);
    }
    return father[x];
}

void union_set(int x,int y)
{
    x = find_set(x);
    y = find_set(y);
    if(rank[x] > rank[y])
        father[y] = x;
    else
    {
        father[x] = y;
        if(rank[x] == rank[y])
        {
            rank[y]++;
        }
    }
}
int main()
{
    TrieGraph::init();
    TrieGraph g;
    ID = 0;
    int k=0;
    int cnt = 0;
    memset(degree,0,sizeof(degree));
    memset(vis,0,sizeof(vis));
    make_set();
    while(scanf("%s %s",s1[k],s2[k]) != EOF)
    {
        //printf("%s %s\n",s1[k],s2[k]);
        len1[k]=strlen(s1[k]);
        for(int i=0; i<len1[k]; ++i)
            s1[k][i]-='a';
        g.insert(s1[k],len1[k]);
        len2[k]=strlen(s2[k]);
        for(int i=0; i<len2[k]; ++i)
            s2[k][i]-='a';
        g.insert(s2[k],len2[k]);
        k++;
    }
    g.build_graph();
    int ii=0;
    for(int i=0; i<k; ++i)
    {
        //printf("%d %d\n",len1[i],len2[i]);
        int d1 = g.match(s1[i],len1[i]);
        int d2 = g.match(s2[i],len2[i]);
        if(!vis[d1])
        {
            d[ii++] = d1;
            vis[d1] = true;
        }
        if(!vis[d2])
        {
            d[ii++] = d2;
            vis[d2] = true;
        }
        degree[d1]++;
        degree[d2]++;
        union_set(d1,d2);
    }
    for(int i=0; i<ii; i++)
    {
        if(degree[d[i]] % 2 == 1)
            cnt++;
    }
    memset(vis,false,sizeof(vis));
    int ans = 0;
    if(cnt==1 || cnt >= 3)
    {
        printf("Impossible\n");
    }
    else
    {
        int fanum=0;
        for(int i=0; i<ii; i++)
        {
            int fa = find_set(d[i]);
            //printf("%d %d\n",d[i],fa);
            if(!vis[fa])
            {
                vis[fa] = true;
                ans++;
            }
        }
        if(ans > 1)
            printf("Impossible\n");
        else
            printf("Possible\n");
    }
    return 0;
}