POJ 2513 Colored Sticks

POJ 2513 Colored Sticks

题意：有一些木棍，两端有颜色，可以两根木棍接起来，拼起来的一端颜色必须相同，问可不可以拼成一个长木棍。

这个题的基本思路是，首先将字符串映射到 int 离散化。

接下来一个重要的关键是：如果接起来是一根长木棍，中间的接口肯定是两个颜色一样的，这样除了两端，中间的颜色肯定是偶数个。

两端如果颜色也一样，就是各种颜色全部为偶数个。

如果两端颜色不一样，只有这两个颜色是奇数个，其他是偶数个。

然后记录下各种颜色的个数， 如果奇数的颜色不是2或者0那么就不可以。

还要判断下，图片是否连通，比如这组数据：

a b

b a

c d

d c

这样就不可以，虽然颜色都是偶数个

用并查集判断下是否连通就可以了。

接下来还有个问题，每种颜色映射到一个整数，如果是map就超时了，我试过了。

用Tire就不会超时，new或者静态数组都可以。

总结：

1.Tire字典树

2.欧拉回路（并查集判断是否连通，和点的个数统计）

AC代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<vector>
#include<cstdio>
#include<queue>

using namespace std;
const int maxn=250000+10;
char a[15], b[15];
map<string ,int> mp;
int cnt=0;
int gin[maxn*2];
int p[maxn*2];

struct node{
int id;
bool use;
node* next[27];
node(){
id = 0;
use =false;
for(int i = 0; i < 27; ++i)
next[i] = NULL;
}
};
int Find(int u){
return u==p[u]? u: p[u]=Find(p[u]);
}

node *root;\

int hashC(char *str){
node *p = root;
while(*str!=0){
int t = *str -'a';
if(p->next[t]==NULL)
p->next[t] = new node();
p=p->next[t];
++str;
}

if(!p->use){
p->use = true;
p->id = cnt++;
}
return p->id;
}

int main(){
for(int i =0; i<maxn*2;++i) p[i]=i;
root = new node();
while(~scanf("%s%s", a, b)){
int pa = hashC(a);
int pb = hashC(b);

++gin[pa];
++gin[pb];
p[Find(pa)]=Find(pb);
}
bool poss=true;
int dan=0;
for(int i =0;i<cnt;++i){
if(gin[i]&1) ++dan;
}
if(dan!=0&&dan!=2) poss=false;
if(poss){
int dian=0;
for(int i =0; i<cnt;++i){
if(Find(i)==i) ++dian;
if(dian>1){ poss=false; break;}
}
}

if(poss==false) printf("Impossible\n");
else printf("Possible\n");

return 0;
}