一笔画问题-DFS-并查集

 一笔画问题

时间限制：3秒 内存限制：128兆

题目描述

zyc从小就比较喜欢玩一些小游戏，其中就包括画一笔画，他想请你帮他写一个程序，判断一个图是否能够用一笔画下来。

规定，所有的边都只能画一次，不能重复画。

 

输入

第一行只有一个正整数N(N<=10)表示测试数据的组数。
每组测试数据的第一行有两个正整数P,Q(P<=1000,Q<=2000)，分别表示这个画中有多少个顶点和多少条连线。（点的编号从1到P）
随后的Q行，每行有两个正整数A,B(0<A,B<P)，表示编号为A和B的两点之间有连线。

输出

如果存在符合条件的连线，则输出"Yes",
如果不存在符合条件的连线，输出"No"。

样例输入

2
4 3
1 2
1 3
1 4
4 5
1 2
2 3
1 3
1 4
3 4

样例输出

No
Yes

一些概念：

设G=(V,E)是任意图，G中经过所有边一次且仅一次的路称为欧拉轨迹或欧拉路，G中经过所有边一次且
仅一次的回路（起点与终点相同的路）称为欧拉回路，存在欧拉回路的图称为欧拉图。
 
能够一笔画完的的图为欧拉图或半欧拉图
如果一个图能用一笔多起点开始，不重复通过同一条边而走遍全部边又回到起点，则为欧拉图。
若不能回到起点，但能走遍所有边，则为半欧拉图。

如果一个连通图的所有顶点的度均是偶数，则一定是欧拉图，反之亦然。
如果一个连通图只有两个度为奇数的顶点则为半欧拉图。若要一笔画完半欧拉图，则必须以这两个奇点为起始点和终止点。

如果一个图有N对奇数顶点，则这个图必须要用N笔才能画成（没有一个图的奇点有奇数个）。

与欧拉图相似的是哈密尔顿图，即能够从一个结点出发，对每个结点仅经历一次，又回到起始结点的图称其为哈密尔顿图。

并查集

#include<iostream>
#include<cstring>
using namespace std;
int mp[1005][1005],c[1005];
int f[1005];
int find(int x)
{
	if(f[x]!=x)
	f[x]=find(f[x]);
	return f[x];
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		memset(mp,0,sizeof(mp));
		memset(c,0,sizeof(c));
		int i,j,n,m,a,b,k=0,cnt=0,flag=0;
		for(i=1;i<1005;i++) 
		f[i]=i;
		cin>>n>>m;
		for(i=0;i<m;i++)
		{
			cin>>a>>b;
			mp[a][b]=mp[b][a]=1;
			int a1=find(a), b1=find(b);
			if(a1!=b1)  
			f[a1]=b1;
		}
		for(i=1;i<=n;i++)
		{
			if(i==find(i))
			cnt++;
			if(cnt>1) 
			{flag=1;break;} 
		}
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=n;j++)
			if(mp[i][j]==1) 
			c[i]++;
			if(c[i]&1) k++;
		}
		if(flag) 
		printf("No\n");
		else
		{
			if(k==2||k==0) printf("Yes\n");
			else printf("No\n");
		}
	}
} 

DFS

#include<iostream>
#include<cstring>
using namespace std;
int mp[1005][1005],visit[1005];
int n,m,flag,cnt[1005];
void dfs(int v)
{
	visit[v]=1;
	for(int i=1;i<=n;i++)
	if(mp[v][i]&&!visit[i])
	dfs(i);
}
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		memset(mp,0,sizeof(mp));
		memset(visit,0,sizeof(visit));
		memset(cnt,0,sizeof(cnt));
		int i,j,a,b,k=0;
		flag=1;
		cin>>n>>m;
		for(i=0;i<m;i++)
		{
			cin>>a>>b;
			mp[a][b]=mp[b][a]=1;
			cnt[a]++;
			cnt[b]++;
		}
		dfs(1);
		for(i=1;i<=n;i++)
		{
			if(!visit[i])
			flag=0;
			if(cnt[i]&1)
			k++;
		}
		if(!flag)
		cout<<"No"<<endl;
		else
		{
			if(k==0||k==2)
			cout<<"Yes"<<endl;
			else
			cout<<"No"<<endl;
		}
	}
 } 

一笔画算法为：

（1）建立邻接矩阵

（2）算出每个顶点的度数，并统计奇点的个数

（3）若无奇点，则可从任意点出发，最终一定会回到该点（称为欧拉回路）

（4）若有两个奇点，必须从其中一个奇点出发，另一个奇点终止

（5）若奇点的个数超过两个，则不能一笔画

注意：图必须为连通图，每个点可以走多次，度为奇数的顶点个数为0个或2个，对于欧拉回路，只能是0个

#include<iostream>
#include<cstring>
using namespace std;
int a[7],total=0,edge=0;
int mp[6][6]=
{
0,1,0,0,1,1,
1,0,1,1,0,1,
0,1,0,1,0,0,
0,1,1,0,1,1,
1,0,0,1,0,1,
1,1,0,1,1,0
};
int draw(int v)
{
	int k=0;
	if(total==edge)
	return 1;
	for(int i=0;i<6;i++)
	{
		if(mp[v][i])
		{
			k=1;
			mp[v][i]=mp[i][v]=0;
			edge+=2;
			if(draw(i))
			{
				cout<<i<<" ";
				return 1;
			}
			else
			{
				mp[v][i]=mp[i][v]=1;
				edge-=2;
				k=0;
			}
		}
	}
	if(k==0)
	return 0;
}
int main()
{
	int i,j,v,k=0;
	memset(a,0,sizeof(a));
	for(i=0;i<6;i++)
	{
		for(j=0;j<6;j++)
		if(mp[i][j])
		a[i]++;
		
		total+=a[i];
		if(a[i]&1)
		{k++;v=i;}
	}
	if(k>2)
	cout<<"NO solution"<<endl;
	else
	{
		draw(v);
		cout<<v;
	}
}

#include<iostream>
#include<cstring>
using namespace std;
int G[6][6]=  
{  
0,1,0,0,1,1, 
1,0,1,1,0,1,  
0,1,0,1,0,0,  
0,1,1,0,1,1,  
1,0,0,1,0,1,  
1,1,0,1,1,0  
};  
int vis[6][6];
void euler(int u)
{
	for(int v=0;v<6;v++)
	if(G[u][v]&&!vis[u][v])
	{
		vis[u][v]=vis[v][u]=1;
		euler(v);
		printf("%d ",v);//逆序打印 
	}
}
int main()
{
	memset(vis,0,sizeof(vis));
	euler(4);//起点
	cout<<4;
}