POJ 1637 【网络流建模汇总】混合图欧拉回路

做过一个无向图欧拉回路的题

HDOJ 5883

但是这个题是个混合图（无向边和有向边都存在）

那么如何搞呢？

首先判断点的度数

设D【i】=i点的入度 - i点的出度

把图中的所有边都任意定向，然后计算出所有的D【i】

如果存在某一个i，使得D【i】不为偶数，那么说明：不可能存在欧拉回路（反之不一定成立，即：都是偶数也可能没有欧拉回路）

也就是说，对于点i来说，D【i】个符号不对

我们需要改变D【i】/2条边的方向，就能保证D【i】=0，也就是出=入

现在的问题是：怎么做改变？

细节在论文里~~~~~~

谈谈自己的理解：用最大流来理解

在做改变的时候，我们不能仅仅考虑点i的改变，需要考虑到i点改变之后，与i相邻的所有点的度数也有相应的变化

那么我们建立网络流

s向所有D【i】>0的点连边，D【i】<0的点都向t连边

每条边上的容量都是每个点需要改变的值（如果跑出来正好匹配的话，说明所有点的更改都是相应变化并且合适的）

那么，最大流是多少？

统计一边的就好（比如计算s向所有的i点连了多少容量出去，如果跑完最大流，流量等于容量的话，说明找到了某一个方案）

谈到了欧拉回路，那么我们需要推广到欧拉路径怎么求：很简单

转化到欧拉回路上求：找到起点和终点，然后连接一条终点到起点的边，然后跑最大流，如果有回路，那么原题中有欧拉路径

起点和终点，就是D【i】为奇数的两个点（当然其他点还是需要为偶数）

然后，选择一个为起点（D【i】>0），另外一个为终点

代码如下：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<stdio.h>
#include<cstring>
#include<string.h>
using namespace std;

const int maxm=5000;
const int maxn=5000;
const int INF=0x3f3f3f3f;
int in[maxm],out[maxm];
int T,n,m;
int a[maxm],b[maxm],c[maxm];
int s,t,tot,all;

struct Edge{
    int to,nxt,cap,flow;
}edge[maxm*10];
int tol,Head[maxm*10];

void init(){
    memset(Head,-1,sizeof(Head));
    tol=2;s=0;t=n+1;tot=t+1;
}

void addedge(int u,int v,int w,int rw=0){
    edge[tol].to=v;
    edge[tol].cap=w;
    edge[tol].flow=0;
    edge[tol].nxt=Head[u];
    Head[u]=tol++;

    edge[tol].to=u;
    edge[tol].cap=rw;
    edge[tol].flow=0;
    edge[tol].nxt=Head[v];
    Head[v]=tol++;
}

int Q[maxn*10],dep[maxn*10],cur[maxn*10],sta[maxn*10];

bool bfs(int s,int t,int n){
    int Front=0,Tail=0;
    memset(dep,-1,sizeof(dep[0])*(n+1));
    dep[s]=0;
    Q[Tail++]=s;
    while(Front<Tail){
        int u=Q[Front++];
        for(int i=Head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if (edge[i].cap>edge[i].flow&&dep[v]==-1){
                dep[v]=dep[u]+1;
                if (v==t) return true;
                Q[Tail++]=v;
            }
        }
    }
    return false;
}

int dinic(int s,int t,int n){
    int maxflow=0;
    while(bfs(s,t,n)){
        for(int i=0;i<n;i++) cur[i]=Head[i];
        int u=s,tail=0;
        while(cur[s]!=-1){
            if (u==t){
                int tp=INF;
                for(int i=tail-1;i>=0;i--)
                    tp=min(tp,edge[sta[i]].cap-edge[sta[i]].flow);
                maxflow+=tp;
                for(int i=tail-1;i>=0;i--){
                    edge[sta[i]].flow+=tp;
                    edge[sta[i]^1].flow-=tp;
                    if (edge[sta[i]].cap==edge[sta[i]].flow) tail=i;
                }
                u=edge[sta[tail]^1].to;
            }
            else if (cur[u]!=-1&&edge[cur[u]].cap>edge[cur[u]].flow&&dep[u]+1==dep[edge[cur[u]].to]){
                sta[tail++]=cur[u];
                u=edge[cur[u]].to;
            }
            else{
                while(u!=s&&cur[u]==-1) u=edge[sta[--tail]^1].to;
                cur[u]=edge[cur[u]].nxt;
            }
        }
    }
    return maxflow;
}


int main(){
    //freopen("input.txt","r",stdin);
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        memset(in,0,sizeof(in));
        memset(out,0,sizeof(out));
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&a[i],&b[i],&c[i]);
            out[a[i]]++;
            in[b[i]]++;
        }
        bool flag=true;
        for(int i=1;i<=n;i++)
        if (abs(in[i]-out[i])%2){
            flag=false;
            break;
        }
        if (!flag){
            puts("impossible");
            continue;
        }
        all=0;
        init();
        for(int i=1;i<=m;i++)
            if (c[i]==0)
                addedge(a[i],b[i],1);
        for(int i=1;i<=n;i++)
            if (in[i]>out[i]){
                addedge(i,t,(in[i]-out[i])/2);
                all+=abs(in[i]-out[i])/2;
            }
            else addedge(s,i,(out[i]-in[i])/2);
        int maxflow=dinic(s,t,tot);
        if (maxflow==all) puts("possible");
        else puts("impossible");
    }
    return 0;
}