poj1637（混合图判欧拉回路）

把该图的无向边随便定向，计算每个点的入度和出度。如果有某个点出入度
之差为奇数，那么肯定不存在欧拉回路。因为欧拉回路要求每点入度 = 出度，
也就是总度数为偶数，存在奇数度点必不能有欧拉回路。
 好了，现在每个点入度和出度之差均为偶数。那么将这个偶数除以 2，得 x。
也就是说，对于每一个点，只要将 x 条边改变方向（入>出就是变入，出>入就是
9
变出），就能保证出=入。如果每个点都是出=入，那么很明显，该图就存在欧拉
回路。
 现在的问题就变成了：我该改变哪些边，可以让每个点出=入？构造网络流
模型。首先，有向边是不能改变方向的，要之无用，删。一开始不是把无向边定
向了吗？定的是什么向，就把网络构建成什么样，边长容量上限 1。另新建 s 和
t。对于入>出的点 u，连接边(u, t)、容量为 x，对于出>入的点 v，连接边(s, v)，
容量为 x（注意对不同的点 x 不同）。之后，察看是否有满流的分配。有就是能
有欧拉回路，没有就是没有。欧拉回路是哪个？察看流值分配，将所有流量非 0
（上限是 1，流值不是 0 就是 1）的边反向，就能得到每点入度=出度的欧拉图。
 由于是满流，所以每个入>出的点，都有 x 条边进来，将这些进来的边反向，
OK，入=出了。对于出>入的点亦然。那么，没和 s、t 连接的点怎么办？和 s 连
接的条件是出>入，和 t 连接的条件是入>出，那么这个既没和 s 也没和 t 连接的
点，自然早在开始就已经满足入=出了。那么在网络流过程中，这些点属于“中
间点”。我们知道中间点流量不允许有累积的，这样，进去多少就出来多少，反
向之后，自然仍保持平衡。

所以，就这样，混合图欧拉回路问题，解了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
最大流开始//
typedef int cap_type;
#define MAX_V 500 + 30 + 16

// 用于表示边的结构体（终点、容量、反向边）
struct edge
{
	int to, rev;
	cap_type cap;

	edge(int to, cap_type cap, int rev) : to(to), cap(cap), rev(rev)
	{}
};

vector <edge> G[MAX_V];   // 图的邻接表表示
int level[MAX_V];      // 顶点到源点的距离标号
int iter[MAX_V];       // 当前弧，在其之前的边已经没有用了

// 向图中加入一条从from到to的容量为cap的边
void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge(to, cap, G[to].size()));
	G[to].push_back(edge(from, 0, G[from].size() - 1));
}

// 通过BFS计算从源点出发的距离标号
void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); ++i)
		{
			edge &e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

// 通过DFS寻找增广路
cap_type dfs(int v, int t, cap_type f)
{
	if (v == t)
	{
		return f;
	}
	for (int &i = iter[v]; i < G[v].size(); ++i)
	{
		edge &e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			cap_type d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}

	return 0;
}

// 求解从s到t的最大流
cap_type max_flow(int s, int t)
{
	cap_type flow = 0;
	for (;;)
	{
		bfs(s);
		if (level[t] < 0)
		{
			return flow;
		}
		memset(iter, 0, sizeof(iter));
		cap_type f;
		while ((f = dfs(s, t, 0x3f3f3f3f3f3f3f3f)) > 0)
		{
			flow += f;
		}
	}
}
///最大流结束/
vector<int>g[205];
int in[205],out[205];
int main()
{
    int cases,n,m,u,v,w,s,t;
    scanf("%d",&cases);
    while(cases--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<=n;i++) g[i].clear();
        for(int i=0;i<=300;i++) G[i].clear();
        memset(in,0,sizeof(in)); memset(out,0,sizeof(out));
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            in[v]++; out[u] ++;
            if(!w)
            g[u].push_back(v);
        }
        int f = 1;
        for(int i=1;i<=n;i++)
            if(abs(in[i]-out[i])%2!=0)
            { f = 0; break; }
        if(!f) { printf("impossible\n"); continue;}
        s = n+1; t = s+1; int tot = 0;
        for(int i=1;i<=n;i++)
            if(in[i]<out[i]){ add_edge(s,i,(out[i]-in[i])/2); tot += (out[i]-in[i])/2;  }
            else if(in[i]>out[i]){add_edge(i,t,(in[i]-out[i])/2);}
        for(int i=1;i<=n;i++)
        {
            int len = g[i].size();
            for(int k=0;k<len;k++)
            {
                int j = g[i][k];
                add_edge(i,j,1);
            }
        }
        //printf("%d %d\n",max_flow(s,t),tot);
        if(max_flow(s,t)==tot) printf("possible\n");
        else printf("impossible\n");
    }
    return 0;
}