POJ 1637 混合图欧拉回路的判定

以下解释转自/article/5535683.html

1 定义

欧拉通路 (Euler tour)——通过图中每条边一次且仅一次，并且过每一顶点的通路。

欧拉回路 (Euler circuit)——通过图中每条边一次且仅一次，并且过每一顶点的回路。

欧拉图——存在欧拉回路的图。

2 无向图是否具有欧拉通路或回路的判定

G有欧拉通路的充分必要条件为：G 连通，G中只有两个奇度顶点(它们分别是欧拉通路的两个端点)。

G有欧拉回路(G为欧拉图)：G连通，G中均为偶度顶点。

3 有向图是否具有欧拉通路或回路的判定

D有欧拉通路：D连通，除两个顶点外，其余顶点的入度均等于出度，这两个特殊的顶点中，一个顶点的入度比出度大1，另一个顶点的入度比出度小1。

D有欧拉回路(D为欧拉图)：D连通，D中所有顶点的入度等于出度。

4 混合图。混合图也就是无向图与有向图的混合，即图中的边既有有向边也有无向边。

5 混合图欧拉回路

混合图欧拉回路用的是网络流。

把该图的无向边随便定向，计算每个点的入度和出度。如果有某个点出入度之差为奇数，那么肯定不存在欧拉回路。因为欧拉回路要求每点入度 = 出度，也就是总度数为偶数，存在奇数度点必不能有欧拉回路。

现在每个点入度和出度之差均为偶数。将这个偶数除以2，得x。即是说，对于每一个点，只要将x条边反向（入>出就是变入，出>入就是变出），就能保证出 = 入。如果每个点都是出 = 入，那么很明显，该图就存在欧拉回路。

现在的问题就变成了：该改变哪些边，可以让每个点出 = 入？构造网络流模型。有向边不能改变方向，直接删掉。开始已定向的无向边，定的是什么向，就把网络构建成什么样，边长容量上限1。另新建s和t。对于入 > 出的点u，连接边(u, t)、容量为x，对于出 > 入的点v，连接边(s, v)，容量为x（注意对不同的点x不同。当初由于不小心，在这里错了好几次）。之后，察看是否有满流的分配。有就是能有欧拉回路，没有就是没有。查看流值分配，将所有流量非 0（上限是1，流值不是0就是1）的边反向，就能得到每点入度 = 出度的欧拉图。

由于是满流，所以每个入 > 出的点，都有x条边进来，将这些进来的边反向，OK，入 = 出了。对于出 > 入的点亦然。那么，没和s、t连接的点怎么办？和s连接的条件是出 > 入，和t连接的条件是入 > 出，那么这个既没和s也没和t连接的点，自然早在开始就已经满足入 = 出了。那么在网络流过程中，这些点属于“中间点”。我们知道中间点流量不允许有累积的，这样，进去多少就出来多少，反向之后，自然仍保持平衡。

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

-----------------------------------------------------------------------------------

注意最大流应该等于的是 所有的出度大于入度的点上的x之和

#include<iostream>
#include<algorithm>
#include<iomanip>
#include<cstring>
#include<string>
#include<cstdio>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define MAXN 2222
#define MAXM 222222
#define INF 1000000000
using namespace std;
struct node
{
int ver;    // vertex
int cap;    // capacity
int flow;   // current flow in this arc
int next, rev;
}edge[MAXM];
int dist[MAXN], numbs[MAXN], src, des, n;
int head[MAXN], e;
void add(int x, int y, int c)
{       //e记录边的总数
edge[e].ver = y;
edge[e].cap = c;
edge[e].flow = 0;
edge[e].rev = e + 1;        //反向边在edge中的下标位置
edge[e].next = head[x];   //记录以x为起点的上一条边在edge中的下标位置
head[x] = e++;           //以x为起点的边的位置
//反向边
edge[e].ver = x;
edge[e].cap = 0;  //反向边的初始网络流为0
edge[e].flow = 0;
edge[e].rev = e - 1;
edge[e].next = head[y];
head[y] = e++;
}
void rev_BFS()
{
int Q[MAXN], qhead = 0, qtail = 0;
for(int i = 1; i <= n; ++i)
{
dist[i] = MAXN;
numbs[i] = 0;
}
Q[qtail++] = des;
dist[des] = 0;
numbs[0] = 1;
while(qhead != qtail)
{
int v = Q[qhead++];
for(int i = head[v]; i != -1; i = edge[i].next)
{
if(edge[edge[i].rev].cap == 0 || dist[edge[i].ver] < MAXN)continue;
dist[edge[i].ver] = dist[v] + 1;
++numbs[dist[edge[i].ver]];
Q[qtail++] = edge[i].ver;
}
}
}
void init()
{
e = 0;
memset(head, -1, sizeof(head));
}
int maxflow()
{
int u, totalflow = 0;
int Curhead[MAXN], revpath[MAXN];
for(int i = 1; i <= n; ++i)Curhead[i] = head[i];
u = src;
while(dist[src] < n)
{
if(u == des)     // find an augmenting path
{
int augflow = INF;
for(int i = src; i != des; i = edge[Curhead[i]].ver)
augflow = min(augflow, edge[Curhead[i]].cap);
for(int i = src; i != des; i = edge[Curhead[i]].ver)
{
edge[Curhead[i]].cap -= augflow;
edge[edge[Curhead[i]].rev].cap += augflow;
edge[Curhead[i]].flow += augflow;
edge[edge[Curhead[i]].rev].flow -= augflow;
}
totalflow += augflow;
u = src;
}
int i;
for(i = Curhead[u]; i != -1; i = edge[i].next)
if(edge[i].cap > 0 && dist[u] == dist[edge[i].ver] + 1)break;
if(i != -1)     // find an admissible arc, then Advance
{
Curhead[u] = i;
revpath[edge[i].ver] = edge[i].rev;
u = edge[i].ver;
}
else        // no admissible arc, then relabel this vertex
{
if(0 == (--numbs[dist[u]]))break;    // GAP cut, Important!
Curhead[u] = head[u];
int mindist = n;
for(int j = head[u]; j != -1; j = edge[j].next)
if(edge[j].cap > 0)mindist = min(mindist, dist[edge[j].ver]);
dist[u] = mindist + 1;
++numbs[dist[u]];
if(u != src)
u = edge[revpath[u]].ver;    // Backtrack
}
}
return totalflow;
}
int ind[MAXN], outd[MAXN];
int xx[MAXM], yy[MAXM], cc[MAXM];
int main()
{
int T, m;
scanf("%d", &T);
while(T--)
{
init();
memset(ind, 0, sizeof(ind));
memset(outd, 0, sizeof(outd));
scanf("%d%d", &n, &m);
for(int i = 1; i <= m; i++)
{
scanf("%d%d%d", &xx[i], &yy[i], &cc[i]);
ind[yy[i]]++;
outd[xx[i]]++;
}
bool flag = true;
for(int i = 1; i <= n; i++)
if((outd[i] - ind[i]) % 2 != 0)
{
flag = false;
break;
}
if(!flag) {printf("impossible\n"); continue;}
int flow = 0;
for(int i = 1; i <= m; i++)
{
if(xx[i] == yy[i] || cc[i]) continue;
add(xx[i] + 1, yy[i] + 1, 1);
}
src = 1, des = n + 2;
for(int i = 1; i <= n; i++)
{
int x = abs(outd[i] - ind[i]) / 2;
if(outd[i] > ind[i]) add(src, i + 1, x), flow += x;
else if(ind[i] > outd[i]) add(i + 1, des, x);
}
n = n + 2;
rev_BFS();
if(maxflow() == flow) printf("possible\n");
else printf("impossible\n");
}
return 0;
}