POJ 1637 混合图的欧拉回路判定

题意：一张混合图，判断是否存在欧拉回路。

分析参考：

混合图（既有有向边又有无向边的图）中欧拉环、欧拉路径的判定需要借助网络流！

（1）欧拉环的判定：
一开始当然是判断原图的基图是否连通，若不连通则一定不存在欧拉环或欧拉路径（不考虑度数为0的点）。

其实，难点在于图中的无向边，需要对所有的无向边定向（指定一个方向，使之变为有向边），使整个图变成一个有向欧拉图（或有向半欧拉图）。若存在一个定向满足此条件，则原图是欧拉图（或半欧拉图）否则不是。关键就是如何定向？

首先给原图中的每条无向边随便指定一个方向（称为初始定向），将原图改为有向图G'，然后的任务就是改变G'中某些边的方向（当然是无向边转化来的，原混合图中的有向边不能动）使其满足每个点的入度等于出度。
设D[i]为G'中(点i的出度 - 点i的入度）。可以发现，在改变G'中边的方向的过程中，任何点的D值的奇偶性都不会发生改变（设将边<i, j>改为<j, i>，则i入度加1出度减1，j入度减1出度加1，两者之差加2或减2，奇偶性不变）！而最终要求的是每个点的入度等于出度，即每个点的D值都为0，是偶数，故可得：若初始定向得到的G'中任意一个点的D值是奇数，那么原图中一定不存在欧拉环！

若初始D值都是偶数，则将G'改装成网络：设立源点S和汇点T，对于每个D[i]>0的点i，连边<S, i>，容量为D[i]/2；对于每个D[j]<0的点j，连边<j, T>，容量为-D[j]/2；G'中的每条边在网络中仍保留，容量为1（表示该边最多只能被改变方向一次）。求这个网络的最大流，若S引出的所有边均满流，则原混合图是欧拉图，将网络中所有流量为1的中间边（就是不与S或T关联的边）在G'中改变方向，形成的新图G''一定是有向欧拉图；若S引出的边中有的没有满流，则原混合图不是欧拉图。

为什么能这样建图？
考虑网络中的一条增广路径S-->i-->...-->j-->T，将这条从i到j的路径在G'中全部反向，则：i的入度加1出度减1，j的入度减1出度加1，路径中其它点的入度出度均不变。而i是和S相连的，因此初始D[i]>0，即i的出度大于入度，故这样反向之后D[i]减少2；同理，j是和T相连的，这样反向之后D[j]增加2。因此，若最大流中边<S, i>满流（流量为初始D[i]/2），此时D[i]值就变成了0，也就是i的入度等于出度。因此只要使所有S引出的边全部满流，所有初始D值>0的点的D值将等于0，又因为将边变向后所有点的D值之和不变，所有初始D值小于0的点的D值也将等于0，而初始D值等于0的D点既不与S相连也不与T相连，所以它们是网络中的中间点，而中间点的流入量等于流出量，故它们的入度和出度一直不变，即D值一直为0。因此，整个图G'成为欧拉图。
（2）欧拉路径的判定：
首先可以想到的是枚举欧拉路径的起点i和终点j，然后在图中添加边<j, i>，再求图中是否有欧拉回路即可。但是，该算法的时间复杂度达到了O(M * 最大流的时间)，需要优化。
前面已经说过，在将边变向的过程中任何点的D值的奇偶性都不会改变，而一个有向图有欧拉路径的充要条件是基图连通且有且只有一个点的入度比出度少1（作为欧拉路径的起点），有且只有一个点的入度比出度多1（作为终点），其余点的入度等于出度。这就说明，先把图中的无向边随便定向，然后求每个点的D值，若有且只有两个点的初始D值为奇数，其余的点初始D值都为偶数，则有可能存在欧拉路径（否则不可能存在）。进一步，检查这两个初始D值为奇数的点，设为点i和点j，若有D[i]>0且D[j]<0，则i作起点j作终点（否则若D[i]与D[j]同号则不存在欧拉路径），连边<j, i>，求是否存在欧拉环即可（将求出的欧拉环中删去边<j, i>即可）。这样只需求一次最大流。
就是转化成最大流，最一次最大流，看是不是满流

 #include <iostream>
 #include <cstdlib>
 #include <cstdio>
 #include <string>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <queue>
 #include <algorithm>
 #include <map>
 using namespace std;
 const int maxn = ;
 const int maxm = maxn*maxn;
 const int INF = 0x3f3f3f3f;
 struct Edge
 {
     int from, to, cap, flow;
     Edge(int from, int to, int cap, int flow): from(from), to(to), cap(cap), flow(flow) {}
 };
 struct Dinic
 {
     int n, m, s, t;
     vector<Edge> edges;
     vector<int> G[maxn];
     bool vis[maxn];
     int d[maxn];
     int cur[maxn];
     void init(int n)
     {
         this->n = n;
         for(int i = ; i <= n; i++) G[i].clear();
         edges.clear();
     }
     void ClearFlow ()
     {
         for(int i = ; i < edges.size(); i++) edges[i].flow = ;
     }
     void AddEdge(int from, int to, int cap)
     {
         edges.push_back(Edge (from, to, cap, ));
         edges.push_back(Edge (to, from, , ));
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }
     bool BFS()
     {
         memset(vis, , sizeof(vis));
         queue<int> Q;
         Q.push(s);
         d[s] = ;
         vis[s] = ;
         while(!Q.empty())
         {
             int x = Q.front();
             Q.pop();
             for(int i = ; i < G[x].size(); i++)
             {
                 Edge& e = edges[G[x][i]];
                 if(!vis[e.to] && e.cap > e.flow)
                 {
                     vis[e.to] = ;
                     d[e.to] = d[x]+;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a)
     {
         if(x == t || a == ) return a;
         int flow = , f;
         for(int &i = cur[x]; i < G[x].size(); i++)
         {
             Edge& e = edges[G[x][i]];
             if(d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > )
             {
                 e.flow += f;
                 edges[G[x][i]^].flow -= f;
                 flow += f;
                 a -= f;
                 if(a == ) break;
             }
         }
         return flow;
     }
     int Maxflow(int s, int t)
     {
         this->s = s;
         this->t = t;
         int flow = ;
         while(BFS())
         {
             memset(cur, , sizeof(cur));
             flow += DFS(s, INF);
         }
         return flow;
     }
 };
 int fa[maxn];
 int find(int x)
 {
     return x == fa[x]? x : fa[x] = find(fa[x]);
 }
 void Union(int x, int y)
 {
     x = find(x), y = find(y);
     if(x != y) fa[x] = y;
 }
 Dinic dinic;
 int n, m, s, t;
 int ind[maxn], outd[maxn];
 bool vis[maxn];
 struct Edge2
 {
     int v;
     bool vis;
     int next;
 } edge[maxm];
 int cnt;
 int first[maxn];
 void addedge(int u, int v)
 {
     edge[cnt].v = v, edge[cnt].vis = ;
     edge[cnt].next = first[u], first[u] = cnt++;
 }
 void init()
 {
     cnt = ;
     memset(first, -, sizeof(first));
     memset(ind, , sizeof(ind));
     memset(outd, , sizeof(outd));
     memset(vis, , sizeof(vis));
     for(int i = ; i <= n+; i++) fa[i] = i;
 }
 void read_case()
 {
     scanf("%d%d",&n,&m);
     init();
     dinic.init(n+);
     while(m--)
     {
         int x, y;
         char c;
         scanf("%d %d %c", &x, &y, &c);
         if(c == '')
             addedge(x, y);
         else if(c == '')
             dinic.AddEdge(x, y, );
         vis[x] = vis[y] = ;
         outd[x]++, ind[y]++;
         Union(x, y);
     }
 }
 int totflow;
 int build()
 {
     s = , t = n+;
     totflow = ;
     for(int i = ; i <= n; i++)
         if(vis[i])
         {
             if((outd[i]+ind[i]) & )
                 return ;
             else if(outd[i] > ind[i])
             {
                 int d = outd[i]-ind[i];
                 dinic.AddEdge(s, i, d/);
                 totflow += d/;
             }
             else if(ind[i] > outd[i])
             {
                 int d = ind[i]-outd[i];
                 dinic.AddEdge(i, t, d/);
             }
         }
     return ;
 }
 int check()
 {
     int count = ;
     for(int i = ; i <= n; i++) if(vis[i] && fa[i] == i) count++;
     if(count > ) return ;

     int ans = dinic.Maxflow(s, t);
     if(ans >= totflow) return ;
     return ;
 }
 void rebuild()
 {
     for(int i = ; i < dinic.edges.size(); i++)
     {
         Edge &e = dinic.edges[i];
         if(e.cap >  && e.from >=  && e.from <= n)
         {
             if(e.flow == ) addedge(e.from, e.to);
             else addedge(e.to, e.from);
         }
     }
 }
 void solve()
 {
     read_case();
     if(build())
     {
         if(!check()) printf("impossible\n");
         else
         {
             rebuild();
             printf("possible\n");
         }
     }
     else printf("impossible\n");
 }
 int main()
 {
     int T;
     scanf("%d",&T);
     while(T--)
         solve();
     return ;
 }