SGU 156. Strange Graph（欧拉路）

时间限制：0.25s

空间限制：6M

题目描述

让我们想象一个无向图G=<V，E>.如果边（u，v）在边集E中，那么我们就说两个顶点u和v是邻接点.在这种情况下，我们也说u是v的一个邻接点且v是u的一个邻接点.我们用N（v）表示点v的邻接点集

合.我们知道v的邻接点数目也叫作这个点的度，用deg v表示.

我们说图G是奇怪的如果它是连通的且对于它的每一个点满足如下条件：

1. 点v的度deg v>=2（表明v的邻接点至少有两个）

2. 如果点v的度deg v=2，那么它的两个邻接点之间没有边相连

3. 如果点v的度deg v>2，那么在它的邻接点集合N（v）中存在点u满足：

（a）点u的度deg u=2

（b）集合N（v）中除顶点u外任意两个不同的点是相邻的，即（w1，w2）这条边存在于边集E中.

现在给你某个这样的图，在里面找出一条哈密尔顿回路，一条哈密尔顿回路就是一条回路，这条回路经过图G中的每一点，且只经过一次.

输入

输入文件的第一行包含两个整数N和M——N为图G中定点的数目，M为图G中边的数目

（3<=N<=10000，M<=100000）.接下来为2M个整数（每相邻两个点为一对）——每对数代表一条边的两个顶点（顶点被编号为1-N）.输入数据保证每条边仅出现一次，且没有这样的环（边的两端点相同）.

输出

如果在图G中没有哈密尔顿回路，则在输出文件的第一行输出-1.如果存在,则输出N个数——即在图G中找到的哈密尔顿回路的顶点序列（注意：最后一个点必须与第一个点相连）.

如果有多种解，则输出任意一种即可.

Sample input #1

4 4

1 2 2 3 3 4 4 1

Sample input #2

9 12

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

4 7 5 8 6 9 7 8 8 9 9 7

Sample output #1

1 2 3 4

Sample output #2

-1

---

分析：

      给出一个联通的图，保证每个点的度至少为2.

      并且对于度大于2的点，相连的有一个度为2的点，其它相连的点之间都有边。

      对于这个图求它的哈密顿回路。

      先来分析这个奇怪的图，从样例2也可以看出对于这样的图是无法保证有解的。

      从这里似乎需要判断哈密顿回路的存在与否，但是判断哈密顿回路的存在问题是NP的。

      这就使得我们转换思路。

      回忆起SGU的SGU 101.Domino（多米诺骨牌），在这一题，我们放弃寻找一个哈密顿路，重新建图变成了一个求欧拉路的问题。

      这里是不是也可以呢？

      考虑一个点u，假设它与a，b，v相连，

      v是一个度为2的点，那么a，b之间一定有边，并且它们还有一条边连向一个度为2的节点

      

      显然边G（u,a,b）是一个完全图，而且能够以任意方式互相遍历

  　 这时我们可以将V(u,a,b)看成一个点。

      接下来的问题就是求新得到的图的欧拉回路了。

　   每次进入完全子图时，走不同的边。

      时间复杂度O（n+m）；

     

code（46ms    AC）

/*
       前向星存边，对于一个完全子图用并查集进行合并,存入f[].
       寻找欧拉路时每次只在一个完全子图中用一条边,并标记走过的点,直接输出答案.
*/
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = int (1e4 + 9);
//前向星存边
struct Edge {
	int u, v, ne;
} edge[INF * 20];
int head[INF], deg[INF], vise[INF * 20], vis[INF], f[INF], cnt = 1;
int n, m, x, y;

void addedge (int u, int v) {
	edge[++cnt].u = u, edge[cnt].v = v;
	edge[cnt].ne = head[u], head[u] = cnt;
}
//合并完全子图
void change() {
	for (int i = 1; i <= n; i++)
		if (deg[i] > 2 && !vis[i]) {
			for (int j = head[i]; j != 0; j = edge[j].ne) {
				int v = edge[j].v;
				if (deg[v] > 2)
					f[v] = i, vis[v] = 1;
			}
		}
}
void EulerianPath (int x, int p) {
	vis[x] = 1;
	for (int i = head[x]; i != 0; i = edge[i].ne) {
		if (vise[i] || vis[edge[i].v]) continue;
		int u = edge[i].u, v = edge[i].v;
		if (p && f[u] == f[v]) {
			vise[i] = vise[i ^ 1] = 1;
			//由内传来
			EulerianPath (v, 0);
		}
		if (deg[x] == 2 || (!p && f[u] != f[v]) ) {
			vise[i] = vise[i ^ 1] = 1;
			//由外传来
			EulerianPath (v, 1);
		}
	}
	printf ("%d ", x);
}
//判断并寻找欧拉回路
void Eulerian() {
	int t = 0;
	for (int i = 1; i <= n; i++) {
		if (!f[i] && deg[i] & 1) {
			t++; break;
		}
		if (!f[i]) f[i] = i;
	}
	if (t != 0) {
		puts ("-1"); return;
	}
	memset (vis, 0, sizeof vis);
	EulerianPath (1, 0);//如果存在哈密顿回路以任意起点出发均可
}
int main() {
	scanf ("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf ("%d %d", &x, &y);
		addedge (x, y), addedge (y, x);
		deg[x]++, deg[y]++;
	}
	change();
	Eulerian();
	return 0;
}