POJ-1637 Sightseeing tour(通过网络流判定混合图的欧拉回路)

题意：

给了一个n个点s条边混合图，即存在无向边和有向边。(会有重边，会有自环)

思路：

来源于网上kuangbin大神的思路。

自己的理解：

1. 首先其实有向图是无向图增加了约束之后得到的嘛，所以对于混合图肯定要全部转为有向图去做，而有向图存在欧拉回路的充要条件是所有顶点的入度和出度值相同。所以问题就转为了如何确定混合图中的无向边的方向。

2. 如果事先假定无向边为某一个方向，那么在之后需要改变无向边的方向时，该操作会造成两个顶点的入度-1 出度+1，和入度+1 出度-1。所以解决这题的最关键的一步就是将某个顶点的入度和出度结合起来，即设置一个D(v)值，表示v点的出度-入度。从而无向边的方向改变对D(v)的影响变成了要么+2，要么-2。所以如果初始存在一点i的D(i)为奇数，则直接可判为不存在欧拉回路。

3. 如果D(v)都为偶数，接下来就是另一个关键点，把问题转化为求解最大流，因为进行走欧拉回路，那么肯定再需要处理出度!=入度的点，一种方法是，超级源点S与D(v) > 0的点建边，容量为D(v)/2，D(v) < 0的点与超级汇点进行建边，容量为-D(v)/2。除2是因为改变一个无向边会造成D(v)的-2,+2操作。另外，网络中保留的只是之前暂时确定的无向边，并令其容量为1，表示该条无向边只能再被改变一次。所以很容易能想通：如果所有的出度>入度的点多余的度数能通过图中的无向边流入出度<入度的点，并最终全流入超级汇点则表示混合图存在欧拉回路了。

4. 通过上述思路，在读入边时遇到自环，便可直接忽略(不会造成这个点D(v)改变)，遇到重边时，只需通过其计算对点的入度出度的影响即可，其他地方不再需要。

代码：

#include <algorithm>
#include <string.h>
#include <cstdio>
#include <cmath>
#include <queue>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 205;
const int maxm = 2005;
struct node1
{
	int v, next;
}edge1[maxm];
struct node  
{  
    int v, w, next;  
}edge[maxm+maxn];
int no1, head1[maxn];
int vis1[maxn], cnt;
int n, m;
int D[maxn];
queue<int> q;
int no, head[maxn];
int dis[maxn], pre[maxn], rec[maxn], block[maxn];
int maxflow;
inline void init()
{
	no1 = 0;
	memset(head1, -1, sizeof head1);
	memset(vis1, 0, sizeof vis1);
	memset(D, 0, sizeof D);
	no = 0;
    memset(head, -1, sizeof head);
}
inline void add(int u, int v)
{
	edge1[no1].v = v;
	edge1[no1].next = head1[u];
	head1[u] = no1++;
}
inline void add(int u, int v, int w)  
{  
    edge[no].v = v; edge[no].w = w;  
    edge[no].next = head[u]; head[u] = no++;  
    edge[no].v = u; edge[no].w = 0;  
    edge[no].next = head[v]; head[v] = no++;  
}
int tmp = 100;
void dfs(int cur)
{
	vis1[cur] = 1;
	++cnt;
	for(int k = head1[cur]; k != -1; k = edge1[k].next)
	{
		if(vis1[edge1[k].v]) continue;
		dfs(edge1[k].v);
	}
}
int mapping(int S, int T)
{
	maxflow = 0;
	for(int i = 1; i <= n; ++i)
	{
		if(abs(D[i])&1) return 0;
		if(D[i] > 0) add(S, i, D[i]/2), maxflow += D[i]/2;
		if(D[i] < 0) add(i, T, -D[i]/2);
	}
	return 1;
}
void reset(int S, int T)  
{  
    memset(dis, 0x3f, sizeof dis);  
    memset(block, 0, sizeof block);  
    q.push(S); dis[S] = 0;  
    while(!q.empty())  
    {  
        int top = q.front(); q.pop();  
        for(int k = head[top]; k != -1; k = edge[k].next)  
        if(dis[edge[k].v] == inf && edge[k].w)  
            dis[edge[k].v] = dis[top]+1, q.push(edge[k].v);  
    }  
}  
int dinic(int S, int T)  
{  
    int ans = 0, flow = inf, top = S;  
    pre[S] = S;  
    reset(S, T);  
    while(dis[T] != inf)  
    {  
        int k, tmp;  
        for(k = head[top]; k != -1; k = edge[k].next)  
        {  
            if(edge[k].w && dis[edge[k].v]==dis[top]+1 &&   
            !block[edge[k].v]) break;  
        }  
        if(k != -1)  
        {  
            tmp = edge[k].v;  
            flow = min(flow, edge[k].w);  
            pre[tmp] = top, rec[tmp] = k;  
            top = tmp;  
            if(top == T)  
            {  
                ans += flow; tmp = -1;  
                for(; top != S; top = pre[top])  
                {  
                    edge[rec[top]].w -= flow;  
                    edge[rec[top]^1].w += flow;  
                    if(!edge[rec[top]].w) tmp = top;  
                }  
                flow = inf;  
                if(tmp != -1)  
                {  
                    top = pre[tmp];  
                    for(; top != S; top = pre[top])  
                    flow = min(flow, edge[rec[top]].w);  
                    top = pre[tmp];  
                }  
            }  
        }  
        else  
        {  
            block[top] = 1;  
            top = pre[top];  
            if(block[S]) reset(S, T);  
        }  
    }  
    return ans;  
}
int main()
{
	int t, u, v, key;
	scanf("%d", &t);
	while(t--)
	{
		init();
		scanf("%d %d", &n, &m);
		for(int i = 1; i <= m; ++i)
		{
			scanf("%d %d %d", &u, &v, &key);
			if(u == v) continue;
			add(u, v);
			++D[u], --D[v];
			if(!key) add(v, u), add(u, v, 1);
		}
		cnt = 0; dfs(1);
		if(cnt != n)
		{
			puts("impossible");
			continue;
		}
		int S = 0, T = 201;
		if(!mapping(S, T))
		{
			puts("impossible");
			continue;
		}
		if(dinic(S, T) == maxflow) puts("possible");
		else puts("impossible");
	}
	return 0;
} 

继续加油~