poj 1637 & zoj 1992 混合图的欧拉回路

/*
参考：http://zhyu.me/acm/zoj-1992-and-poj-1637.html
题意：给出一个混合图（有的边有向，有的边无向），问此图是否存在欧拉回路。

先说说欧拉回路吧，起点和终点相同，经过图G的每条边一次，且只经过一次的路径称为欧拉回路。
按照图的不同分为：无向图欧拉回路、有向图欧拉回路和混合图欧拉回路。

判断一个图是否存在欧拉回路：
1.无向图：图连通，且图中均为偶度顶点。
2.有向图：图连通，且图中所有顶点出入度相等。
3.混合图：混合图欧拉回路的判断是用网络流，实现方法：

首先对所有的无向边随便定向，之后会进行调整。然后统计每个点的出入度，如果有某个点出入度之差为奇数，则不存在欧拉回路，因为相差为奇数的话，无论如果调整边，都不能使得每个点的出入度相等。

现在每个点的出入度之差为偶数了，把这个偶数除以2,得x。则对每个顶点改变与之相连的x条边的方向就可以使得该点出入度相等。如果每个点都能达到出入度相等，自然就存在欧拉回路了。

现在问题就变成了改变哪些边的方向能让每个点出入度相等了，构造网络流模型。
有向边不能改变方向，所以不添加有向边。对于在开始的时候任意定向的无向边，按所定的方向加边，容量为1。源点向所有出>入的点连边，容量为该点的x值；所有入>出的点向汇点连边，容量为该点的x值。

建图完成了，求解最大流，如果能满流分配，则存在欧拉回路。那么哪些边改变方向才能得到欧拉回路呢？查看流量分配，所有流量非0的边就是要改变方向的边。

原理是因为满流分配，所以和源点相连的点一定都有x条边流入，将这些边反向这些点就出入度相等了，和汇点相连的亦然。没有和源、汇相连的已经出入度相等了，当然不用修改，至此欧拉回路求解完毕。
*/
#include <cstdio>
#include <iostream>
#include<queue>
#include<set>
#include<ctime>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
#include<cstring>
using namespace std;
const int inf=1<<30;
const int maxn=1019;
struct Edge
{
	int u,v;
}E[maxn];
struct edge  
{   
    int v, next;   
    int val;   
} net[ 500100 ];   
int n,m,num;
int In[maxn],Out[maxn];
int level[maxn], Qu[maxn], out[maxn],next[maxn];  
class Dinic {   
public:   
    int end;  
    Dinic() {   
        end = 0;   
        memset( next, -1, sizeof(next) );   
    }   
    inline void insert( int x, int y, int c) {   
        net[end].v = y, net[end].val = c,  
        net[end].next = next[x],   
        next[x] = end ++;   
        net[end].v = x, net[end].val = 0,  
        net[end].next = next[y],   
        next[y] = end ++;   
    }   
    bool BFS( int S, int E ) {   
        memset( level, -1, sizeof(level) );   
        int low = 0, high = 1;   
        Qu[0] = S, level[S] = 0;   
        for( ; low < high; ) {   
            int x = Qu[low];   
            for( int i = next[x]; i != -1; i = net[i].next ) {   
                if( net[i].val == 0 ) continue;   
                int y = net[i].v;   
                if( level[y] == -1 ) {   
                    level[y] = level[x] + 1;   
                    Qu[ high ++] = y;   
                }   
            }   
            low ++;   
        }   
        return level[E] != -1;   
    }    
    
    int MaxFlow( int S, int E ){   
        int maxflow = 0;   
        for( ; BFS(S, E) ; ) {   
            memcpy( out, next, sizeof(out) );   
            int now = -1;   
            for( ;; ) {   
                if( now < 0 ) {   
                    int cur = out[S];   
                    for(; cur != -1 ; cur = net[cur].next )    
                        if( net[cur].val && out[net[cur].v] != -1 && level[net[cur].v] == 1 )   
                            break;   
                    if( cur >= 0 ) Qu[ ++now ] = cur, out[S] = net[cur].next;   
                    else break;   
                }   
                int u = net[ Qu[now] ].v;   
                if( u == E ) {   
                    int flow = inf;   
                    int index = -1;   
                    for( int i = 0; i <= now; i ++ ) {   
                        if( flow > net[ Qu[i] ].val )   
                            flow = net[ Qu[i] ].val, index = i;   
                    }   
                    maxflow += flow;   
                    for( int i = 0; i <= now; i ++ )   
                        net[Qu[i]].val -= flow, net[Qu[i]^1].val += flow;   
                    for( int i = 0; i <= now; i ++ ) {   
                        if( net[ Qu[i] ].val == 0 ) {   
                            now = index - 1;   
                            break;   
                        }   
                    }   
                }   
                else{   
                    int cur = out[u];   
                    for(; cur != -1; cur = net[cur].next )    
                        if (net[cur].val && out[net[cur].v] != -1 && level[u] + 1 == level[net[cur].v])   
                            break;   
                    if( cur != -1 )   
                        Qu[++ now] = cur, out[u] = net[cur].next;   
                    else out[u] = -1, now --;   
                }   
            }   
        }   
        return maxflow;   
    }   
};   

bool init()
{
	int a,b,d;
	memset(In,0,sizeof(In));
	memset(Out,0,sizeof(Out));
	scanf("%d%d",&n,&m);
	num=0;
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&a,&b,&d);
		Out[a]++;
		In[b]++;
		if(d==0)
		{
			E[num].u=a;
			E[num].v=b;
			num++;
		}
	}
	for(int i=1;i<=n;i++)
	{
		if((In[i]-Out[i])&1)
		return false;
	}
	return true;
}
void solve()
{
	Dinic my;
	int sum=0;
	for(int i=1;i<=n;i++)
	{
		if(Out[i]>In[i])
		{my.insert(0,i,(Out[i]-In[i])/2);
		sum+=(Out[i]-In[i])/2;}
		else
		my.insert(i,n+1,(In[i]-Out[i])/2);
		
	}
	for(int i=0;i<num;i++)
	{
		my.insert(E[i].u,E[i].v,1);
	}
	if(sum==my.MaxFlow(0,n+1))
	puts("possible");
	else 
	puts("impossible");
}
int main()
{
	int ca;
	scanf("%d",&ca);
	while(ca--)
	{
		if(!init())puts("impossible");
		else solve();
	}
}