欧拉回路，欧拉道路

欧拉回路又称一笔画，常见的题目是将一个题转化为欧拉回路问题，建图，判断是否为欧拉回路，欧拉回路的路径输出；

欧拉回路的判断条件：（判断的前提是该图在忽略边的方向的时候是联通的）

无向图：（1）、每个节点的度数都为偶数（从任意节点出发都能走出一条欧拉回路）；

                （2）、有且仅有两个点的度数为奇数（从其中的一个度数为奇数的节点出发，到另一个度数为奇数的顶点结束，能够走出一条欧拉回路）

有向图：（1）、每个节点的入度等于出度（从任意节点出发都能走出一条欧拉回路）

                （2）、只有一个点的入度比出度大1同时只有一个点出度比入度大1（从出度比入度大1的节点出发，到入度比出度大1的节点结束，能够走出一条欧拉回路）

欧拉回路的路径打印：

无向图：

void euler(int u){
	for (int i=0; i<n; i++) if (G[u][i] && !vis[u][i]){
		vis[u][i] = vis[i][u] = 1;
		euler(i);
		printf("%d  %d\n",u,i);		
	}
}

有向图：

void euler(int u){
	for (int i=0; i<n; i++) if (G[u][i] && !vis[u][i]){
		vis[u][i]  = 1;            //与无向图的区别
		euler(i);
		printf("%d  %d\n",u,i);		
	}
}

经典的欧拉回路题目poj2337；

此题很巧妙的将单词看作边，很巧妙的将问题转化为了求欧拉回路的问题，只是要字典序输出，需要再建图的时候讲边（单词）排好序

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<climits>
#include<cctype>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<stack>
#define ll long long
#define INF INT_MAX
#define eps 1e-8
#define MAX 100010
#define MAXN 26

using namespace std;

struct Edge{
	int from,to;
};

vector<Edge>edges;
vector<int>G[MAXN];
multiset<string> S;

string str[MAX];

int fa[MAX],in[MAX],out[MAX],mark[MAX],vis[MAX];

void init(){
	memset(mark,0,sizeof(mark));
	memset(vis,0,sizeof(vis));
	memset(in,0,sizeof(in));
	memset(out,0,sizeof(out));
	for (int i=0; i<MAXN; i++) fa[i] = i;
	for (int i=0; i<MAXN; i++) G[i].clear();
	edges.clear();
	S.clear();	
}

void addEdge(int from,int to){
	Edge t;
	t.from = from;
	t.to = to;
	edges.push_back(t);
	int k = edges.size() - 1;
	G[from].push_back(k);
}

int find(int x){                 //并查集，用于判断图在忽略方向的时候是否联通
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}

int check(){                //判断有向图是否为欧拉图
	int num = 0;
	for (int i=0; i<MAXN; i++){
		if (mark[i] && fa[i] == i) num++;
	}
	if (num != 1) return -1;
	int cnt1 = 0,cnt2 = 0;
	int s = -1;
	for (int i=0; i<MAXN; i++) if (mark[i]){
		if (in[i] == out[i]) continue;
		if (abs(in[i] - out[i]) > 1) return -1;
		if (in[i] - out[i] == 1) cnt1++;
		if (out[i] - in[i] == 1){
			s = i;
			cnt2++;
		}
	}
	if (!((cnt1 == 0 && cnt2 == 0) || (cnt1 == 1 && cnt2 == 1))) return -1;
	if (s < 0){
		for (int i=0; i<MAXN; i++) if (mark[i]) return i;
	}
	return s;
}

int cnt;

string ans[MAX];

void eular(int u){              //路径输出，结果要用栈先保存，不然路径是逆向的
	for (int i=0; i<G[u].size(); i++){
		int k = G[u][i];
		Edge e = edges[k];
		if (!vis[k]){
			vis[k] = 1;
			eular(e.to);
			ans[cnt++] = str[k];
		}
	}
}

int main(){
	int T,n;
	scanf("%d",&T);
	string st;
	while (T--){
		init();
		scanf("%d",&n);
		for (int i=0; i<n; i++){
			cin >> st;
			S.insert(st);
		}
		multiset<string>::iterator it;
		int k = 0;
		for (it = S.begin(); it != S.end(); it++,k++){
			str[k] = *it;
			int len = str[k].length();
			int u = str[k][0] - 'a';
			int v = str[k][len-1] - 'a';
			in[v]++;
			out[u]++;
			mark[u] = mark[v] = 1;
			addEdge(u,v);
			int x = find(u);
			int y = find(v);
			if (x != y) fa[x] = y;
		}
		
	/*	for (int i=0; i<n; i++){
			cout << str[i] << "  " << edges[i].from << "  " << edges[i].to << endl;
		}*/
		
		int s = check();
		if (s < 0){
			printf("***\n");
		}
		else {
			cnt = 0;
			eular(s);
			cout << ans[cnt-1];
			for (int i=cnt-2; i>=0; i--){
				cout << '.' << ans[i];
			}
			printf("\n");
		}
	}
	return 0;
}