uva 10054 - The Necklace 惨痛经历

做了两天，一直在用bfs来做dfs的题，于是就一直TLE到死。以为邻接矩阵不够快，改用邻接表，但是还是TLE。直到怀疑服务器挂有问题= =，上网找别人的代码交。第一个找到的交上去还是错的，直到找到这个参考代码出处。

于是就仿照写一两次，终于发现了几处写错的地方。（其实是发现bfs和dfs的区别）

是什么：把每个珠子看出一条边，珠子的两种颜色看成点。就是给出所有的边（无向）看看能不能找到欧拉回路（就是一笔画，起点和终点同是一个点）（而起点和终点不在一个点上的一笔画就是欧拉道路）

为什么：图的转换，把某些关系转化成边，点。解除是否存在什么什么的路径（方法），什么什么的最短路径（最优方法）。

怎么样：要知道存在欧拉回路的图，不管从哪一个点出发，都能顺利完成“一笔画”（证明：既然能够一笔画完整个图而回到起点，那可以把图看成一个圆，那在圆上选任意一点都能完成一笔画）。所以判断是不是欧拉回路接下来输出路径就简单了（可对于我来说，并不是T_T）。

    而判断无向图是否为的欧拉回路有两个方面：

1，图是否联通的。

2，每个点的是否有偶数条边相连。

   第 1 点直接用并查集做。

   第 2 点在加入边时直接计算就是了。

以下是代码：

这是邻接矩阵的

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
int fa[60];
int data[60][60];
int findfa(int i){
	if(fa[i]==i) return fa[i];
	fa[i]=findfa(fa[i]);
	return fa[i];
}
void eur(int k){
	for(int i=1;i<60;++i){
		if(data[k][i]){
			--data[k][i];
			--data[i][k];
			printf("%d %d\n",k,i);
			eur(i);
			
			//break;//这个不能加！
		}
	}
}
int main(){
	int cas;
	scanf("%d",&cas);
	for(int casi=1;casi<=cas;++casi){
		for(int i=0;i<60;++i)
			fa[i]=i;
		memset(data,0,sizeof(data));
		int n;
		scanf("%d",&n);
		int a,b;
		for(int i=0;i<n;++i){
			scanf("%d%d",&a,&b);
			int tmp=min(a,b);
			b=a+b-tmp;
			a=tmp;
			++data[a][b];
			++data[a][0]; //<span style="font-family: 'Microsoft YaHei';">计算和点连接的边的数量</span>
			++data[b][a];
			++data[b][0]; //也是<span style="font-family: 'Microsoft YaHei';">计算和点连接的边的数量</span>
			if(findfa(a)!=findfa(b))
				fa[findfa(b)]=findfa(a);
		}
		int flag=0,sta;
		for(int i=1;i<60;++i){
			if(data[i][0]%2) flag=1;
			if(data[i][0]) sta=i;
		}

		for(int i=1;i<60;++i)
			if(data[i][0]&&findfa(i)!=findfa(sta)) flag=1;

		printf("Case #%d\n",casi);
		if(flag){
			printf("some beads may be lost\n");
			if(casi!=cas) printf("\n");
			continue;
		}
		eur(sta);
		if(casi!=cas) printf("\n");
	}
	return 0;
}

而这是邻接表写的

#include<iostream>
#include<cstdio>
#include<cstring>
using  namespace std;
struct node{
	int start,index;
	int tot;
	int upp;
	int fa;
	node(int i=0,int inndex=0){
		index=i;
		start=-1;
		upp=-1;
		tot=0;
		fa=inndex;
	}
};
node nda[110];

struct edge{
	int next;
	int sta,end;
	int up;
	int use;
	edge(int a=0,int b=0,int c=0){
		sta=a;
		end=b;
		use=0;
		next=nda[a].start;
		nda[a].start=c;
	}
};

edge eda[16000];
int find(int a){
	if(nda[a].fa==a) return a;
	nda[a].fa=find(nda[a].fa);
	return nda[a].fa;
}
void gotofind(int stain){
	for(int x=nda[stain].start;x!=-1;x=eda[x].next){
		if(eda[x].use==0){
			eda[x].use=1;
			eda[x^1].use=1;
			stain=eda[x].end;
		      //cout<<eda[x].sta<<' '<<eda[x].end<<endl;

                                                  /*

<span style="white-space:pre">							</span>这个不能卸载递归前面，因为当递归结束回到这里输出的答案和题目要求不一样

<span style="white-space:pre">							</span>可是又觉这样说不过去，不符合欧拉回路的性质啊。。。好纠结，知道的留个言~谢谢啦！

<span style="white-space:pre">						</span>   */
			gotofind(stain);

			cout<<eda[x].end<<' '<<eda[x].sta<<endl;
		}
	}
}

int main(){
	int cas;
	cin>>cas;
	for(int casi=1;casi<=cas;++casi){
		for(int i=0;i<55;++i){
			node ini(0,i);
			nda[i]=ini;
		}
		int n;
		scanf("%d",&n);
		int maxin=-1;
		int ai,bi;
		int k=0,sum=0;
		for(int i=1;i<=n;++i){
			scanf("%d%d",&ai,&bi);
			edge tmp(ai,bi,k);
			eda[k]=tmp;
			++k;
			
			edge tmp1(bi,ai,k);
			eda[k]=tmp1;
			++k;
			
			++nda[ai].tot;
			++nda[bi].tot;

			maxin=max(maxin,ai);
			maxin=max(maxin,bi);

			int t1=find(nda[ai].fa),t2=find(nda[bi].fa);
			if(t1!=t2)
				nda[t1].fa=t2;
			
			++sum;
		}
		int flag=0,stain=0,maxto=-1;
		for(int i=1;i<=maxin;++i){
			if(maxto<nda[i].tot){
				maxto=nda[i].tot;
				stain=i;
			}
			if(nda[i].tot%2)
				flag=1;
		}
		int tfa=find(stain);
		for(int i=0;i<=55;++i){
			if(nda[i].tot&&tfa!=find(i)) flag=1;
		}
		cout<<"Case #"<<casi<<endl;
		if(flag){
			cout<<"some beads may be lost"<<endl;
			if(casi!=cas) cout<<endl;
			continue;
		}
		gotofind(stain);

		if(casi!=cas) cout<<endl;
	}
	return 0;
}

关于dfs和bfs的应用区别（我的理解）是：

bfs：用于找最优

dfs：用于找有无

但是算法杀死很灵活的，并不是固定不变的。需要看情（xin）况（qing）使用