uva10735混合图的欧拉回路_最大流

题意：

混合图的欧拉回路，存在的话输出路径，不存在输出提示信息。

思路：

回忆概念：

1. 如果图G中的一个路径包括每个边恰好一次，则该路径称为欧拉路径(Euler path)。

2. 如果一个回路是欧拉路径，则称为欧拉回路(Euler circuit)。

3. 无向图存在欧拉回路的充要条件
   一个无向图存在欧拉回路，当且仅当该图所有顶点度数都为偶数,且该图是连通图。

4. 有向图存在欧拉回路的充要条件
   一个有向图存在欧拉回路，所有顶点的入度等于出度且该图是连通图。

5. 混合图存在欧拉回路条件
   要判断一个混合图G（V,E）（既有有向边又有无向边）是欧拉图，方法如下：
   假设有一张图有向图G’，在不论方向的情况下它与G同构。并且G’包含了G的所有有向边。那么如果存在一个图G’使得G’存在欧拉回路，那么G就存在欧拉回路。
   其思路就将混合图转换成有向图判断。实现的时候，我们使用网络流的模型。现任意构造一个G’。用Ii表示第i个点的入度，Oi表示第i个点的出度。如果存在一个点k，|Ok-Ik|mod 2=1，那么G不存在欧拉回路。接下来则对于所有Ii>Oi的点从源点连到i一条容量为(Ii-Oi)/2的边，对于所有Ii

一般来说，对于混合图问题，可以先把无向边化为两条有向边来解决。但这个题不行，求欧拉回路的话，不管是什么边只能走一次。所以像上面所说，要给每个无向边重定向。
要注意的是，只能把无向边加入网络，而不能把原图中的有向边纳入到网络模型中，因为最终某条弧有流量就代表被反向了，而原图中的有向边方向已经固定，不能再改变。

#include 
#include 
#include 
#include 
#include 
#define fi first
#define se second
#define pii pair
using namespace std;
typedef long long LL;
const int INF = 0x3f3f3f3f;
const int maxn = 100+5;
const int maxm = 500+5;
int n, m;
int dis[maxn], cur[maxn];
int diff[maxn]; // 每个点出度与入度之差 
int u[maxm], v[maxm];
int directed[maxm], id[maxm]; // 每条边是否是有向边; 无向边的编号 
// 图
struct Edge{
	int u,v,cap,flow;
	Edge(int a, int b, int c, int d):u(a),v(b),cap(c),flow(d){}
}; 
vector edges;
vector G[maxn];

void init(){
	for(int i = 0; i < n+2; ++i) G[i].clear();
	edges.clear();
}

void addEdge(int u, int v, int cap){
	edges.push_back(Edge(u,v,cap,0));
	edges.push_back(Edge(v,u,0,0));
	int m = edges.size();
	G[u].push_back(m-2); 
	G[v].push_back(m-1);
}

bool bfs(int s, int t){
	memset(dis, -1, sizeof(dis));
	dis[s] = 0;
	queue Q;
	Q.push(s);
	while(!Q.empty()){
		int x = Q.front(); Q.pop();
		for(int i = 0; i < G[x].size(); ++i){
			Edge e = edges[G[x][i]];
			if(dis[e.v] == -1&&e.cap > e.flow){
				dis[e.v] = dis[x] + 1;
				Q.push(e.v);
			}
		}
	}
	return dis[t] != -1;
}
int dfs(int s, int t, int f){
	if(s == t||f == 0) return f;
	int ans = 0;
	for(int& i = cur[s]; i < G[s].size(); ++i){
		Edge e = edges[G[s][i]];
		if(dis[e.v] == dis[s] + 1&&e.cap > e.flow){
			int a1 = min(f, e.cap - e.flow);
			int a2 = dfs(e.v, t, a1);
			if(a2 == 0) continue;
			edges[G[s][i]].flow += a2;
			edges[G[s][i]^1].flow -= a2;
			ans += a2;
			f -= a2;
			if(f <= 0) break;
		}
	}
	return ans;
}
int dinic(int s, int t){
	int ans = 0;
	while(bfs(s, t)) {
		memset(cur, 0, sizeof(cur)); // 不加会超时！！！ 
		ans += dfs(s, t, INF);
	}
	return ans;
}

// 输出路径
vector G2[maxn];
vector vis[maxn]; // vis[i][j]: 边(i,j)访问状态
vector path;

void euler(int u){
	for(int i = 0; i < G2[u].size(); ++i){
		if(!vis[u][i]){
			vis[u][i] = 1;
			euler(G2[u][i]);
			path.push_back(G2[u][i] + 1);
		}
	}
} 

void print_ans(){
	for(int i = 0; i < n; i++) { G2[i].clear(); vis[i].clear(); }
	// 建立把无向边重定向后的新图G2 
	for(int i = 0; i < m; ++i){
		bool rev = false;
		// 如果是无向边且被重定向了
		if(!directed[i]&&edges[id[i]].flow > 0)  rev = true; 
		if(!rev){ G2[u[i]].push_back(v[i]); vis[u[i]].push_back(0); }
		else { G2[v[i]].push_back(u[i]); vis[v[i]].push_back(0); }
	}
	
	path.clear();
	euler(0);
	
	printf("1");
	for(int i = path.size()-1; i >= 0; --i) printf(" %d",path[i]);
	printf("\n");
}

int main()
{
	freopen("in.txt","r",stdin);
	int T; scanf("%d",&T);
	while(T--){
		memset(diff, 0, sizeof(diff));	// diff[]：出度 - 入度
		bool flag = true;
		scanf("%d%d",&n,&m);
		init();
		for(int i = 0; i < m; ++i){
			int a,b,c; 
			char dir[5];
			scanf("%d%d%s",&u[i],&v[i],dir);
			--u[i]; --v[i];
			directed[i] = (dir[0] == 'D' ? 1 : 0);
			++diff[u[i]]; --diff[v[i]];
			// 无向边
			if(!directed[i]){ id[i] = edges.size();	addEdge(u[i], v[i], 1);	}
		}
		// 检查每个点的出度和入度是否满足欧拉回路的条件
		for(int i = 0; i < n; ++i) 
			if(diff[i] % 2 != 0) { flag = false; break;}
		
		// 建立网络，源点和汇点
		if(flag){
			int s = n, t = n+1;
			int sum = 0;
			for(int i = 0; i < n; ++i){
				if(diff[i] > 0) { addEdge(s, i, diff[i]/2); sum+=diff[i]/2; }
				if(diff[i] < 0) { addEdge(i, t, -diff[i]/2); }
			}
			int ans = dinic(s, t);
			if(ans != sum)  flag = false; // 如果求出来最大流!=sum,无解	
		}
		
		if(!flag) printf("No euler circuit exist\n");
		else print_ans();
		
		if(T) printf("\n");
	}
	return 0;
}