POJ1637 Sightseeing tour 混合图判断欧拉回路

题目大意:给一个图,有的边有向,有的边无向,问能否找到一条回路恰好经过每条边一次。

解题思路： 模型近似于欧拉回路了，但是边的性质不唯一。

先回想一下有向图的欧拉回路的判定：每个点入度等于出度。

无向图的欧拉回路：每个点的度数为偶数。（假如该点度数为a , 在回路中其实也是想要求该点的出度为a/2 ,入度为a/2 ,出度=入度）

这样来看,有向图和无向图的欧拉回路判断的本质就统一了,就是要求在回路中每个点的出度=入度。

不知哪位大神很经典的想到用网络流...膜拜一下...

先说建模过程吧, 对于有向边(u,v) , 这条边已经固定了, 把相应的出度和入度加上就好。

对于无向图(u,v) , 我们暂且定位这条边是从u到v的, 但是保留修改方向的权利 , 加一条从u到v流量为1的边。

先遍历每个点, 如果该点的出度和入度的差值是奇数的话必定不能构造欧拉回路。（这个自己想..）

如果是偶数的话, 如果出度大于入度, 建一条从源点到该点容量为c= (out[i]-in[i])/2 的边 , 

表示出度比入度多了, 需要把之前暂定的从该点引出的c条无向边反向才能使该点出度等于入度。

如果入度大于出度, 建一条从该点到汇点的容量为c=(in[i]-out[i])/2的边，

表示入度比出度多了, 需要把之前暂定的从该点引入的c条无向边反向才能使该点出度等于入度。

而对于最开始建的流量为1的原图中的无向边, 

如果有流量流过, 就表示使该边反向了。

最后,如果该图满流(最大流等于所有与源点相关的边的流量的和)，

说明有办法使所有点入度等于出度，能构成欧拉回路。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
using namespace std;
#define FOR(i,l,r) for(int i=(l);i<=(r);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define DSC(i,r,l) for(int i=(r);i>=(l);--i)

#define N 300
#define M 10000
#define INF 1e8
int in[N],out[N];
struct
{
    int to,next;
    int c;
}edge[M];
int head[N],level[N],ip;
int que[N];
bool makelevel(int s,int t)
{
    memset(level,0,sizeof(level));
    int iq=0;
    que[iq++]=s;
    level[s]=1;
    int top;
    for(int i=0;i<iq;i++)
    {
        top=que[i];
        if(top==t)  return 1;
        for(int k=head[top];k!=-1;k=edge[k].next)
        {
            if(!level[edge[k].to]&&edge[k].c>0)
            {
                que[iq++]=edge[k].to;
                level[edge[k].to]=level[top]+1;
            }
        }
    }
    return 0;
}
int dfs(int now,int maxf,int t)
{
    if(now==t)  return maxf;
    int  ret=0,c;
    for(int k=head[now];k!=-1;k=edge[k].next)
    {
        if(edge[k].c>0&&level[edge[k].to]==(level[now]+1))
        {
            c=dfs(edge[k].to,min(maxf-ret,edge[k].c),t);
            edge[k].c-=c;
            edge[k^1].c+=c;
            ret+=c;

            if(ret==maxf)   return  ret;
        }
    }
    return ret;
}
int dinic(int s,int t)
{
    int  ans=0;
    while(makelevel(s,t))   ans+=dfs(s,INF,t);
    return ans;
}
void add(int u,int v,int c,int f)//有向边f为0 ,否则为 c
{
    edge[ip].to=v;edge[ip].c=c;edge[ip].next=head[u];head[u]=ip++;
    edge[ip].to=u;edge[ip].c=f;edge[ip].next=head[v];head[v]=ip++;
}
bool solve(int n)
{
    int sum=0,ans;
    int start=0,end=n+1;
    FOR(i,1,n)
    {
        if(abs(out[i]-in[i])&1) return 0; //如果有点出度入度之差为奇数,必定不能构成欧拉回路
        if(out[i]>in[i]) add(start,i,(out[i]-in[i])/2,0),sum+=(out[i]-in[i])/2; //出度大于入度
        else if(in[i]>out[i]) add(i,end,(in[i]-out[i])/2,0);  //入度大于出度
    }
    if(dinic(start,end)==sum) return 1; //满流,说明能构成欧拉回路
    else return 0;
}

int main()
{
    int cas,n,m,x,y,z;
    cin>>cas;
    while(cin>>n>>m)
    {
        memset(head,-1,sizeof(head)); ip=0;
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        while(m--)
        {
            scanf("%d%d%d",&x,&y,&z);
            out[x]++;
            in[y]++;
            if(!z) add(x,y,1,0); //对于无向边,暂定从x到y,建容量为1的边
        }
        if(solve(n)) puts("possible");
        else puts("impossible");
    }
    return 0;
}