欧拉路

欧拉回路，也就是著名的哥尼斯堡七桥问题，也成一笔画问题。
问题描述：是否可以找到一种方案，使得人们从自己家里出发，不重复走每一座桥，然后回到家中？

---

在了解欧拉回路前，我们再了解一下知识。
有向图、无向图、混合图的欧拉通路、欧拉回路。
无向图：

存在欧拉回路的条件：原图连通，每个结点均为偶度结点。

存在欧拉通路的条件：存在欧拉回路，或原图连通，有两个结点为奇度结点，其他结点均为偶度结点。

有向图：

存在欧拉回路的条件：基图连通，每个结点的入度等于出度。

存在欧拉通路的条件：存在欧拉回路，或基图连通，有一个结点入度等于出度+1，有一个结点出度等于入度+1，其他结点的入度等于出度。

混合图：

存在欧拉回路的条件：

1.将无向边随便定向，每个结点的入度与出度之差为偶数。

2.进行网络流，若满流，则存在欧拉回路。

（网络流构图：忽略有向边。对于随便定向的无向边，按照所定向连边，流量为1 。对于入度大于出度的点u，连边（u，T），流量为 abs( (in[u]-out[u])/2 )。对于出度大于入度的点v，连边（S，v），流量为abs( (in[v]-out[v])/2 )）。

存在欧拉通路的条件：存在欧拉回路，或

1.将无向边随便定向，有两个结点的入度与出度之差为奇数，其他结点的入度与出度之差为偶数。

2.在两个奇度结点间连一条无向边，进行网络流，若满流，则存在欧拉通路。

（网络流构图：忽略有向边。对于随便定向的无向边，按照所定向连边，流量为1 。对于入度大于出度的点u，连边（u，T），流量为 abs( (in[u]-out[u])/2 )。对于出度大于入度的点v，连边（S，v），流量为abs( (in[v]-out[v])/2 )）。

---

求欧拉回路的优化方式：
1：修改head[]数组，直线未被访问过得下一条边。
2：防止爆栈而采用非递归模式。

给出回路模板：(无向非递归版)

//stack<int> st,ans;
int st[N],ans[N],top,t; //st模拟递归栈，ans是结果路径栈
int vis[M]; 
void euler(){
	st[++top] = 1;
	while(top > 0){
		int x = st[top];
		int i = head[x];
		while(i && vis[i]) i = nex[i];
		if(i){
			int v = ver[i];
			st[++top] = v;
			head[i] = nex[i];
			vis[i] = vis[i^1] = 1;
		}else{
			top--;
			ans[++t] = x;
		} 
	}
}

---

给出无向+有向的递归模板：//type=1是无向，2是有向。

#include<bits/stdc++.h>
using namespace std;
const int N = 5e7+7,M = 5e7+7;
int n,m,type; 
int cnt = 1,head[N],nex[M],ver[M];
void add(int a,int b){
	ver[++cnt] = b;
	nex[cnt] = head[a];
	head[a] = cnt;
}
//stack<int> st,ans;
//int st[N],ans[N],top,t; //st模拟递归栈，ans是结果路径栈
int vis[N],in[N],out[N]; 
void read(){
	scanf("%d%d%d",&type,&n,&m);
	for (int i = 1;i <= m; i++){
		int x,y;scanf("%d%d",&x,&y);
		add(x,y);
		if(type==1) add(y,x);
		out[x] ++;in[y] ++;
	}
}
int ans[N];
void euler(int x){
	for(int &i = head[x];i;i=nex[i]){
		int y = ver[i];
		int c = (type==1 ? i/2 : i-1); //cout<<i<<endl;
		int sig = i%2;
		if(vis[c]) continue;
		vis[c] = 1;
		euler(y);
		if(type==1) ans[++ans[0]]=(sig ? -c : c);
		else ans[++ans[0]]=c;
	}
}
void solve(){
   for (int i = 1; i <= n; i++)  //判断是否具备欧拉回路的条件
       if ((type == 1 && (in[i] + out[i]) % 2) || (type == 2 && in[i] != out[i])) {
          printf("NO\n");
	      return;
    }
	for(int i=1; i <= n;i++)
	if(head[i]){
		euler(i);
		break;
	}
	if(ans[0]!=m){
		printf("NO\n");
		return;
	}
	printf("YES\n");
	for(int i=m;i>0;i--)
	printf("%d ",ans[i]);
} 
int main(){
	read();
	solve();
	return 0;
} 

---

找欧拉路径例题：//poj2337
给出字符串，按字典序从小到大找接龙。
先判断是不是欧拉路径，在判断是不是通路，并查集承接从小到大
这里就加第一个优化会有错，应该是前向星的边顺序问题

#include<stack>
#include<string>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<vector>
using namespace std;
const int N = 1e4+7, M = 1e4+7;
int n,cnt ,minn = 27;
int head[N],ver[M],nex[M],index[M];//index 是为了最后记录有序的前向星插边后的次序，反正我没用 
int vis[M],in[N],out[N]; //vis是记录这边(单词)是不是走过 
string s[M];
int pre[M];
int ans[M]; 
void init(){
	cnt = 0, minn = 27;
	for(int i=0; i < M ;i++)
	pre[i] = i,ans[i] = vis[i] = index[i] = 0;
	for(int i=0; i < N;i++)
	head[i] = vis[i] = in[i] = out[i] = 0; 
}
void add(int x,int y){//(int x,int y,int i)
	ver[++cnt] = y;
	nex[cnt] = head[x];
	//index[cnt] = i;
	head[x] = cnt; 
}
int find(int x){
	return pre[x] == x ?x : pre[x] = find(pre[x]);
}
void un(int x,int y){
	int fx = find(x);
	int fy = find(y);
	if(fx > fy) pre[fx] = fy;
	else pre[fy] = fx;
}
void read(){
	scanf("%d",&n);
	for(int i = 1; i <= n;i++)
	cin >> s[i]; 
	sort(s+1,s+n+1);
	
	for (int i = n; i >= 1;i--){ //因为是前向星，是从后插，所以大的先进 
		int x = s[i][0] - 'a' +1;
		int y = s[i][s[i].size()-1]-'a' + 1;
		add(x,y);
		out[x]++, in[y] ++;
		minn = min(minn,x); // 找到最小值，如果是回路就随便一个点，通路的话下面还有判断，省了特判。 
		un(x,y); // 小的是爸爸 
	} 
}
bool isol(){
	int st=0,e=0;//起点，终点
	for(int i=1; i <= 26;i++){
		if(in[i] != out[i]){
			if(out[i] - in[i]==1) st++,minn = i;
			else if(in[i] - out[i] ==1) e++;
			else return false;
		}
	}
	if((st == 1 && e == 1) || (st==0 && e ==0))
	return true; // 是通路且起点和终点只有一个  或者 是回路 
	return false; 
}
bool lt(){ // 判断基图是否连通 
	int k = 0;
	for(int i=1 ;i <= 26;i++)
	if((in[i] !=0 || out[i]!=0) && pre[i]==i) //i是起点 
	k++;
	if(k ==1) return true;
	return false; 
}
void dfslj(int x){
	for(int i = head[x]; i ; i=nex[i]){
		if(!vis[i]){
			vis[i] = 1;
			dfslj(ver[i]);
			ans[++ans[0]]=n-i+1; // 前向星会把先插的边放到最后，那么我们就先输出后面的就是对应前面的有序边 
		//	ans[++ans[0]]=index[i]; 看不懂就这样吧 
		}
	}
}
void solve(){
	if(isol() && lt()){
		dfslj(minn);
		int flag = 0;
		for(int i=ans[0];i>0;i--)
		cout<<(i==ans[0]?"":".")<<s[ans[i]];
		cout<<endl;
	}else cout<<"***"<<endl;
}
int main(){
	int T; scanf("%d",&T);
	while(T--){
		init();
		read();
		solve();
	}
	return 0;
}

参考资料：
博客：https://www.cnblogs.com/nextbin/p/4005396.html