混合图求欧拉回路——Sightseeing tour ( POJ 1637 )-CSDN博客

本文链接：https://blog.csdn.net/FeBr2/article/details/52739393

题目链接：
http://poj.org/problem?id=1637
分析：
给出N个点，M条边(有向或者无向)，求这个图里是否存在欧拉回路。
题解：

一般图欧拉回路判定
- 无向图：每个点的度数都是偶数。
- 有向图：每个点的入度等于出度。
混合图欧拉回路判定
1. 判定度数：
  记录入度和出度的时候，对无向边任意定向。如果存在欧拉回路，那么可以得到每个点入度与出度之差为偶数，否则就一定不能构成。
2. 网络流求解：
  在第一步判定之后，我们需要修正我们之前随意定好的无向边，如果最后能得到所有点入度等于出度那么就能够得到这个混合图的欧拉回路（通过正确地把无向边化成有向边）。
  
  定义：入度大于出度的点流出流量。记录所有的流出流量和。然后定义入读大于出度的节点需要流出流量，出度大于入度的点需要接受流量。
  
  建边：某节点入度大于出度，Add( S, i, (in[i]-out[i])/2 )
  某节点出度大于入度，Add( i, T, (out[i]-in[i])/2 )
  遍历< i, j>，若i, j之间连接了x条无向边，那么连接一条从j到i的流量为x的边。
  判定：若最后得到图的网络流最大流等于前面入度-出度的流量和，那么该图存在欧拉回路，否则不存在。
AC代码：

/*************************************************************************
    > File Name: 1637.cpp
    > Author: Akira 
    > Mail: qaq.febr2.qaq@gmail.com 
    > Created Time: 2016年10月05日 星期三 14时44分24秒
 ************************************************************************/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <ctime>
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))
using namespace std;

#define MaxN 233
#define MaxM MaxN*20
#define INF 0x3f3f3f3f
#define bug cout<<88888888<<endl;
#define MIN(x,y) (x<y?x:y)
#define MAX(x,y) (x>y?x:y)

int T;
int N,M;

struct Edge{
    int u,v,next;
    int flow;
}edge[MaxM];   //最大边数，一般都是实际边数的2倍甚至以上

int head[MaxN];
int cont;

void init(){        //记得init
    cont = 0;
    MST(head, -1);

}

void add(int u, int v, int flow){
    edge[cont].u = u;
    edge[cont].v = v;
    edge[cont].flow = flow;
    edge[cont].next = head[u];
    head[u] = cont++;
}

void Add(int u, int v, int flow){    //建正反两条边，反向流量为0
    add(u, v, flow);
    add(v, u, 0);
}

int dis[MaxN];
int num[MaxN];
int cur[MaxN];
int pre[MaxN];

void BFS(int source,int sink)
{
    queue<int>q;
    CLR(num);
    MST(dis,-1);

    q.push(sink);
    dis[sink]=0;
    num[0]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v = edge[i].v;
            if(dis[v] == -1)
            {
                dis[v] = dis[u] + 1;
                num[dis[v]]++;
                q.push(v);
            }
        }
    }
}

int ISAP(int source,int sink,int n)      //从源点到汇点，n为总点数，返回最大流
{
    memcpy(cur,head,sizeof(cur));
    int flow=0, u = pre[source] = source;
    BFS( source,sink);
    while( dis[source] < n )
    {
        if(u == sink)
        {
            int df = INF, pos;
            for(int i =source;i != sink;i = edge[cur[i]].v)
            {
                if(df > edge[cur[i]].flow)
                {
                    df = edge[cur[i]].flow;
                    pos = i;
                }
            }
            for(int i = source;i != sink;i = edge[cur[i]].v)
            {
                edge[cur[i]].flow -= df;
                edge[cur[i]^1].flow += df;
            }
            flow += df;
            //cout << flow << endl;
            u = pos;
        }
        int st;
        for(st = cur[u];st != -1;st = edge[st].next)
        {
            if(dis[edge[st].v] + 1 == dis[u] && edge[st].flow)
            {
                break;
            }
        }
        if(st != -1)
        {
            cur[u] = st;
            pre[edge[st].v] = u;
            u = edge[st].v;
        }
        else
        {
            if( (--num[dis[u]])==0 ) break;
            int mind = n;
            for(int id = head[u];id != -1;id = edge[id].next)
            {
                if(mind > dis[edge[id].v] && edge[id].flow != 0)
                {
                    cur[u] = id;
                    mind = dis[edge[id].v];
                }
            }
            dis[u] = mind+1;
            num[dis[u]]++;
            if(u!=source)
            u = pre[u];
        }
    }
    return flow;
}

int in[MaxN], out[MaxN];
int mp[MaxN][MaxN];

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        init();
        CLR(in);
        CLR(out);
        CLR(mp);

        scanf("%d%d", &N, &M);
        int a,b,d;
        for(int i=0;i<M;i++)
        {
            scanf("%d%d%d", &a, &b, &d);
            out[a]++;
            in[b]++;
            if(!d) mp[a][b]++;
        }
        int flow = 0;
        int flag = 0;
        for(int i=1;i<=N;i++)
        {
            if( in[i] > out[i] ) flow += (in[i] - out[i]) >> 1;
            if( abs(out[i]-in[i])&1 )
            {
                flag = 1;
                break;
            }
        }

        if(flag)
        {
            cout << "impossible\n";
            continue;
        }
        else
        {
            int S = 0;
            int T = N+1;
            for(int i=1;i<=N;i++)
            {
                if( out[i] > in[i] ) Add(i, T, (out[i]-in[i])/2 );
                if( in[i] > out[i] ) Add(S, i, (in[i]-out[i])/2 );
                for(int j=1;j<=N;j++)
                {
                    if(mp[i][j]) Add(j, i, mp[i][j]);
                }
            }
            if(ISAP(S,T,N+2) == flow ) cout << "possible\n";
            else cout << "impossible\n";
        }
    }
}