混合图欧拉回路

相关题目：pku1637，zju1992

欧拉回路相关资料：

判断一个图中是否存在欧拉回路（每条边恰好只走一次，并能回到出发点的路径），在以下三种情况中有三种不同的算法：

一、无向图
每个顶点的度数都是偶数，则存在欧拉回路。

二、有向图（所有边都是单向的）
每个节顶点的入度都等于出度，则存在欧拉回路。

 

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

 

题目：pku1637对应代码

 

#include < cstdio >
#include < iostream >
#include < queue >
using   namespace  std;
#define  MAX_N 205
#define  INF 0x7fffffff
int  s,t,n,map[MAX_N][MAX_N],indeg[MAX_N],outdeg[MAX_N],pre[MAX_N],fullflow,e;
void  input();
void  make_graph();
bool  test();
int  bfs();
int  MaxFlow();
int  main()
{
     int  caseno;
    scanf( " %d " , & caseno);
     while (caseno -- ){
        input();
         if (test() == 0 ){    printf( " impossible\n " ); continue ;}    // 存在奇数度点不可能有欧拉回路
        make_graph();                                        // 构造网络流模型
         if (MaxFlow() == fullflow)    printf( " possible\n " );
         else  printf( " impossible\n " );
    }
     return   0 ;
}
void  input()
{
     int  m,x,y,d;
    scanf( " %d %d " , & n, & m);
    memset(map, 0 , sizeof (map));memset(indeg, 0 , sizeof (indeg));
    memset(outdeg, 0 , sizeof (outdeg));
     while (m -- ){
        scanf( " %d %d %d " , & x, & y, & d);
         if (d == 0 )
            map[x][y] ++ ;             // 无向边定向
        indeg[y] ++ ;                     // 计算每个点入度和出度
        outdeg[x] ++ ;
    }
}
bool  test()
{
     int  i;
     for (i = 1 ;i <= n;i ++ ){
         if (abs(indeg[i] - outdeg[i]) % 2 == 1 )     return   0 ;
    }
     return   1 ;
}
void  make_graph()
{
     int  i;
    s = 0 ;t = n + 1 ;fullflow = 0 ;
     for (i = 1 ;i <= n;i ++ ){
         if (indeg[i] > outdeg[i])
            map[i][t] = (indeg[i] - outdeg[i]) / 2 ;
         else {
            map[s][i] = (outdeg[i] - indeg[i]) / 2 ;
            fullflow += map[s][i];
        }
    }
    e = t;
}
int  MaxFlow()    // 最大流算法解释见前一篇文章：bfs实现
{
     int  max_flow = 0 ,cur,min;
     while ((min = bfs()) !=- 1 ){    
        max_flow += min;
         for (cur = e;cur != s;cur = pre[cur]){
            map[pre[cur]][cur] -= min;    
            map[cur][pre[cur]] += min;    
        }
    }
     return  max_flow;
}
int  bfs()
{
     int  i,tmp,min;
    queue < int > q;                
    memset(pre, - 1 , sizeof (pre));    
    pre[s] = 0 ;
    q.push(s);
     while ( ! q.empty()){
        tmp = q.front();q.pop();
         if (tmp == e)    {        
            min = INF;
             for (i = e;i != s;i = pre[i])
                min = map[pre[i]][i] < min ? map[pre[i]][i]:min;
             return  min;
        }
         for (i = 1 ;i <= e;i ++ ){
             if (i != s && pre[i] ==- 1 && map[tmp][i]){     
                q.push(i);
                pre[i] = tmp;
            }
        }
    }
     return   - 1 ;
}