混合图的欧拉回路求解方法（转）

原文地址http://yzmduncan.iteye.com/blog/1149049

---

基础知识
欧拉回路是图G中的一个回路，经过每条边有且仅一次，称该回路为欧拉回路。具有欧拉回路的图称为欧拉图，简称E图。
无向图中存在欧拉回路的条件：每个点的度数均为偶数。
有向图中存在欧拉回路的条件：每个点的入度=出度。
欧拉路径比欧拉回路要求少一点：
无向图中存在欧拉路径的条件：每个点的度数均为偶数或者有且仅有2个度数为奇数的点。
有向图中存在欧拉路径的条件：除了2个点外，其余的点入度=出度，且在这2个点中，一个点的入度比出度大1，另一个出度比入度大1。
欧拉路径的输出：经典的套圈算法。

下面来重点讲讲混合图的欧拉回路问题。
混合图就是边集中有有向边和无向边同时存在。这时候需要用网络流建模求解。
建模：
把该图的无向边随便定向，计算每个点的入度和出度。如果有某个点出入度之差为奇数，那么肯定不存在欧拉回路。 因为欧拉回路要求每点入度 = 出度，也就是总度数为偶数，存在奇数度点必不能有欧拉回路。
好了，现在每个点入度和出度之差均为偶数。那么将这个偶数除以2，得x。也就是说，对于每一个点，只要将x条边改变方向（入>出就是变入，出>入就是变出），就能保证出 = 入。如果每个点都是出 = 入，那么很明显，该图就存在欧拉回路。
现在的问题就变成了：我该改变哪些边，可以让每个点出 = 入？构造网络流模型。
首先，有向边是不能改变方向的，要之无用，删。一开始不是把无向边定向了吗？定的是什么向，就把网络构建成什么样，边长容量上限1。另新建s和t。对于入 > 出的点u，连接边(u, t)、容量为x，对于出 > 入的点v，连接边(s, v)，容量为x（注意对不同的点x不同）。
之后，察看从S发出的所有边是否满流。有就是能有欧拉回路，没有就是没有。欧拉回路是哪个？察看流值分配，将所有流量非 0（上限是1，流值不是0就是1）的边反向，就能得到每点入度 = 出度的欧拉图。
由于是满流，所以每个入 > 出的点，都有x条边进来，将这些进来的边反向，OK，入 = 出了。对于出 > 入的点亦然。那么，没和s、t连接的点怎么办？和s连接的条件是出 > 入，和t连接的条件是入 > 出，那么这个既没和s也没和t连接的点，自然早在开始就已经满足入 = 出了。那么在网络流过程中，这些点属于“中间点”。我们知道中间点流量不允许有累积的，这样，进去多少就出来多少，反向之后，自然仍保持平衡。
所以，就这样，混合图欧拉回路问题，解了。

---

参考例题：
poj-1637-Sightseeing tour

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
const int inf=0x3ffffff;
const int MAXN = 333;
const int MAXM = 100008;
const double eps = 1e-6;
struct Edge{
    int data, next, cap, flow, oppo;
    Edge(){
    }
    Edge(int data, int next, int cap, int flow, int oppo):data(data)
        , next(next), cap(cap), flow(flow), oppo(oppo){
    }
}edge[MAXM];
int link[MAXM][3];
int list[MAXN];
int degree[MAXN];
int queue[MAXN], path[MAXN], add[MAXN];
int n, m, e, v;

void Add_Link(int a, int b, int c) {
    edge[e] = Edge(b, list[a], c, 0, e+1);
    edge[e+1] = Edge(a, list[b], 0, 0, e);
    list[a] = e;
    list[b] = e+1;
    e += 2;
}

void Init() {
    int i;
    v = n + 2;
    for (i = 0; i < v; i++) {
        list[i] = -1;
        degree[i] = 0;
    }
    e = 0;
    for (i = 0; i < m; i++) {
        degree[link[i][0]]--;
        degree[link[i][1]]++;
        if (!link[i][2]) {
            Add_Link(link[i][0], link[i][1], 1);
        }
    }
}

int Max_Flow() {
    int ans = 0, head, tail, curr, succ, i, j, k;
    bool flag = true;
    while(flag) {
        flag = false;
        for (i = 0; i < v; i++) {
            path[i] = -1;
        }
        path[n] = -2;
        queue[0] = n;
        add[n] = inf;
        for (head = tail = 0; !flag && head <= tail; head++) {
            curr = queue[head];
            for (i = list[curr]; i != -1; i = edge[i].next) {
                if (path[succ = edge[i].data] == -1 && edge[i].flow < edge[i].cap) {
                    queue[++tail] = succ;
                    path[succ] = i;
                    add[succ] = min(add[curr], edge[i].cap-edge[i].flow);
                    if (succ == n+1) {
                        ans += add[succ];
                        flag = true;
                        for (j = succ; path[j] >= 0; j = edge[k].data) {
                            k = edge[path[j]].oppo;
                            edge[path[j]].flow += add[succ];
                            edge[k].flow -= add[succ];
                        }
                        break;
                    }
                }
            }
        }
    }
    return ans;
}

bool Work() {
    Init();
    int i, ans = 0;
    for (i = 0; i < n; i++) {
        if (degree[i] & 1) {
            return false;
        }
    }
    for (i = 0; i < n; i++) {
        if (degree[i] < 0) {
            Add_Link(n, i, -degree[i]/2);
            ans += -degree[i]/2;
        }
        if (degree[i] > 0) {
            Add_Link(i, n+1, degree[i]/2);
        }
    }
    if (Max_Flow() < ans) {
        return false;
    }
    return true;
}

int main() {
//#ifndef ONLINE_JUDGE
//  freopen("1.txt", "r", stdin);
//#endif
    int i, j, k; 
    int T;
    cin >> T;
    while(T--)  {
        cin >> n >> m;
        for (i = 0; i < m; i++) {
            scanf("%d%d%d", &link[i][0], &link[i][1], &link[i][2]);
            link[i][0]--;
            link[i][1]--;
        }
        if (Work()) {
            cout << "possible" << endl;
        } else {
            cout << "impossible" << endl;
        }
    }
    return 0;
}