PAT A1126 Eulerian Path

PAT A1126 Eulerian Path

Sample Input 1:

7 12
5 7
1 2
1 3
2 3
2 4
3 4
5 2
7 6
6 3
4 5
6 4
5 6

Sample Output 1:

2 4 4 4 4 4 2
Eulerian

Sample Input 2:

6 10
1 2
1 3
2 3
2 4
3 4
5 2
6 3
4 5
6 4
5 6

Sample Output 2:

2 4 4 4 3 3
Semi-Eulerian

Sample Input 3:

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

Sample Output 3:

3 3 4 3 3
Non-Eulerian

word	meaning
exactly	adv. 精确地;准确地

• 分析：
  Eulerian path: 沿着边不重复的走完所有图中边的路径
  Eulerian circuit：起点终点相同的Eulerian path

1. 如果一个图不是连通图：non-Eulerian
2. 如果一个图是连通图：
   -2-1 它各节点的度都为偶数->是Eulerian
   -2-2 有两个度为奇数的顶点（从一个出发，走一遍能到另一个）->是Semi-Eulerian
   -2-3 其他的：是non-Eulerian

• 思路 1：

1. 用一个vector[maxn]邻接表存储：v[i].size()就是节点i的度
2. DFS遍历图，求出连通分量的个数：如果为1则是连通图，否则不是连通图

• code 1：

#include <iostream>
#include <unordered_map>
#include <vector>
using namespace std;
const int maxn = 1010;
vector<int> G[maxn];
bool flag[maxn];
void DFS(int idex){
	if(G[idex].size() == 0) return;
	flag[idex] = true;
	for(int i = 0; i < G[idex].size(); ++i){
		int next = G[idex][i];
		if(flag[next] == false){
			DFS(next);
		}
	}
}
bool isConnected(int n){
	int cnt = 0;
	for(int i = 1; i <= n; ++i){
		if(flag[i] == false){
			DFS(i);
			cnt++;
		}
	}
	return cnt == 1 ? true : false;
}
int main(){
	int n, m, v1, v2;
	vector<int> degree;
	scanf("%d %d", &n, &m);
	degree.resize(n+1);
	for(int i = 0; i < m; ++i){
		scanf("%d %d", &v1, &v2);
		G[v1].push_back(v2);
		G[v2].push_back(v1);
	}
	for(int i = 1; i <= n; ++i){
		degree[i] = G[i].size();
	}
	int cntOdd = 0;
	for(int i = 1; i <= n; ++i){
		if(i == 1) printf("%d", degree[i]);
		else printf(" %d", degree[i]);
		if(degree[i] % 2 != 0) cntOdd++;
	}
	if(!isConnected(n)) printf("\nNon-Eulerian");
	else printf("%s", cntOdd == 0 ? "\nEulerian" : cntOdd  == 2 ? "\nSemi-Eulerian" : "\nNon-Eulerian");	
	return 0;
}

• T2 code:

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
vector<int> G[maxn];

bool vis[maxn];
void DFS(int id){
	vis[id] = true;
	for(int i = 0; i < G[id].size(); ++i){
		int nex = G[id][i];
		if(vis[nex] == false) DFS(nex);
	}	
}
int main(){
	int v, e;
	scanf("%d %d", &v, &e);
	for(int i = 0; i < e; ++i){
		int v1, v2;
		scanf("%d %d", &v1, &v2);
		G[v1].push_back(v2);
		G[v2].push_back(v1);
	}
	DFS(1);
	int cnt_odd = 0;
	bool Connect = true;
	for(int i = 1; i <= v; ++i){
		if(vis[i] == false) Connect = false;
		int degree = G[i].size();
		if(degree % 2) cnt_odd++; 
		if(i == 1) printf("%d", degree);
		else printf(" %d", degree);
	}
	printf("\n");
	if(Connect == true){
		if(cnt_odd == 2){
			printf("Semi-Eulerian");
			return 0;
		}else if(cnt_odd == 0){
			printf("Eulerian");
			return 0;
		} 
	}
	printf("Non-Eulerian");
	return 0;
}

• 并查集

#include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int father[maxn], degree[maxn];

int FindR(int x)
{
    int tmp = x;
    while(father[x] > 0)
    {
        x = father[x];
    }
    while(father[tmp] > 0)
    {
        int tmp2 = tmp;
        tmp = father[tmp];
        father[tmp2] = x;
    }
    return x;
}
void Union(int a, int b)
{
    int fa = FindR(a), fb = FindR(b);
    if(fa != fb)
    {
        if(father[fa] < father[fb])
        {
            father[fb] += father[fa];
            father[fa] = fb;
        }else
        {
            father[fa] += father[fb];
            father[fb] = fa;
        }
    }
}
int Count(int n)
{
    int cnt = 0;
    for(int i = 1; i <= n; ++i)
    {
        if(father[i] < 0) cnt++;
    }
    return cnt;
}
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    memset(father, -1, sizeof(father));
    for(int i = 0; i < m; ++i)
    {
        int v1, v2;
        scanf("%d %d", &v1, &v2);
        degree[v1]++;
        degree[v2]++;
        Union(v1, v2);
    }
    int cnt = Count(n), cnt_odd = 0;
    for(int i = 1; i <= n; ++i)
    {
        printf("%d", degree[i]);
        if(i < n) printf(" ");
        if(degree[i] % 2 == 1) cnt_odd++;
    }
    printf("\n");
    if(cnt == 1)
    {
        if(cnt_odd == 0) printf("Eulerian");
        else if(cnt_odd == 2) printf("Semi-Eulerian");
        else printf("Non-Eulerian");
    }else printf("Non-Eulerian");
    return 0;
}