poj1637Sightseeing tour(混合图欧拉回路)

题目请戳这里

题目大意：求混合图欧拉回路。

题目分析：最大流。竟然用网络流求混合图的欧拉回路，涨姿势了啊啊。。

其实仔细一想也是那么回事。欧拉回路是遍历所有边一次又回到起点的回路。双向图只要每个点度数为偶数即可，有向图要保证所有点入度等于出度。求路径的话，dfs即可。

混合图的话，就比较复杂。首先将有向边定向，求出所有点的入度和出度，如果某个点入度和出度之差为奇数，则一定不存在欧拉回路，因为对于混合图，无向边可以任意指定方向，但是无论指定哪个方向，如果取反向的话，只会影响端点的一个出度和一个入度，所以无论无向边如何定向，是不影响节点入度和出度之差的奇偶性的。无向边定向后转化成一张有向图，那么所有的顶点就分成3类：

1：入度= 出度的点，已经是平衡点了，不管；

2：入度>出度的点，向汇点建一条边，边权为(入度- 出度)/2；

3：入度<出度的点，源点与之建一条边，边权为(出度- 入度)/2；

这样跑一遍最大流，看是否为满流。如果是满流，就存在欧拉回路。

因为如果跑出来一个满流，那么对于每个入度>出度的点，都有x条边进来，那么这x条边反向，那么该节点入度=出度，平衡了，对于每个出度>入度的点也是同理。对于出度=入度的点，因为建图的时候没有管他们，也就是说他们本来就是平衡点，所以源点和汇点与之没有直接边，但并不代表这些点就不在图中，因为非平衡点会与之有边相连。如果要求一条具体的欧拉回路的话，只要看具体的网络流，对于流量为1的边，取反便是欧拉回路中一条边了。所谓取反只是对无向边而言的，说明一开始对无向边定向定反了。

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int N = 205;
const int M = 40000;
const int inf = 0x3f3f3f3f;

int n,m,num,sum;
int head[N],sta[N],que[N],cnt[N],dis[N],rpath[N];
int in[N],out[N];
struct node
{
    int to,c,next,pre;
}arc[M];
void build(int s,int e,int cap)
{
    arc[num].to = e;
    arc[num].c = cap;
    arc[num].next = head[s];
    head[s] = num ++;
    arc[num - 1].pre = num;
    arc[num].pre = num - 1;
    arc[num].to = s;
    arc[num].c = 0;
    arc[num].next = head[e];
    head[e] = num ++;
}
void init()
{
    int i,a,b,d;
    scanf("%d%d",&n,&m);
    for(i = 1;i <= n;i ++)
        in[i] = out[i] = 0;
    memset(head,-1,sizeof(head));
    num = 0;
    while(m --)
    {
        scanf("%d%d%d",&a,&b,&d);
        if(d == 0)
            build(a,b,1);
        out[a] ++;
        in[b] ++;
    }
}
void re_Bfs()
{
    int i,front,rear;
    for(i = 0;i <= n + 1;i ++)
    {
        dis[i] = n + 2;
        cnt[i] = 0;
    }
    dis[n + 1] = 0;
    cnt[0] = 1;
    front = rear = 0;
    que[rear ++] = n + 1;
    while(front != rear)
    {
        int u = que[front ++];
        for(i = head[u];i != -1;i = arc[i].next)
        {
            if(arc[arc[i].pre].c == 0 || dis[arc[i].to] < n + 2)
                continue;
            dis[arc[i].to] = dis[u] + 1;
            cnt[dis[arc[i].to]] ++;
            que[rear ++] = arc[i].to;
        }
    }
}
int ISAP()
{
    re_Bfs();
    int i,u,maxflow = 0;
    for(i = 0;i <= n + 1;i ++)
        sta[i] = head[i];
    u = 0;
    while(dis[0] < n + 2)
    {
        if(u == n + 1)
        {
            int curflow = inf;
            for(i = 0;i != n + 1;i = arc[sta[i]].to)
                curflow = min(curflow,arc[sta[i]].c);
            for(i = 0;i != n + 1;i = arc[sta[i]].to)
            {
                arc[sta[i]].c -= curflow;
                arc[arc[sta[i]].pre].c += curflow;
            }
            maxflow += curflow;
            u = 0;
        }
        for(i = sta[u];i != -1;i = arc[i].next)
            if(arc[i].c > 0 && dis[arc[i].to] + 1 == dis[u])
                break;
        if(i != -1)
        {
            sta[u] = i;
            rpath[arc[i].to] = arc[i].pre;
            u = arc[i].to;
        }
        else
        {
            if((-- cnt[dis[u]]) == 0)
                break;
            int Min = n + 2;
            sta[u] = head[u];
            for(i = head[u];i != -1;i = arc[i].next)
                if(arc[i].c > 0)
                    Min = min(Min,dis[arc[i].to]);
            dis[u] = Min + 1;
            cnt[dis[u]] ++;
            if(u != 0)
                u = arc[rpath[u]].to;
        }
    }
    return maxflow;
}
bool solve()
{
    int i;
    sum = 0;
    for(i = 1;i <= n;i ++)
    {
        if(in[i] > out[i])
        {
            if((in[i] - out[i])&1)
                return false;
            build(i,n + 1,(in[i] - out[i])>>1);
        }
        if(in[i] < out[i])
        {
            if((out[i] - in[i])&1)
                return false;
            build(0,i,(out[i] - in[i])>>1);
            sum += (out[i] - in[i])>>1;
        }
    }
    return ISAP() == sum;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t --)
    {
        init();
        if(solve())
            puts("possible");
        else
            puts("impossible");
    }
    return 0;
}
//200K	0MS