TZOJ 2099 Sightseeing tour(网络流判混合图欧拉回路)

描述

The city executive board in Lund wants to construct a sightseeing tour by bus in Lund, so that tourists can see every corner of the beautiful city. They want to construct the tour so that every street in the city is visited exactly once. The bus should also start and end at the same junction. As in any city, the streets are either one-way or two-way, traffic rules that must be obeyed by the tour bus. Help the executive board and determine if it's possible to construct a sightseeing tour under these constraints.

输入

On the first line of the input is a single positive integer n, telling the number of test scenarios to follow. Each scenario begins with a line containing two positive integers m and s, 1 <= m <= 200,1 <= s <= 1000 being the number of junctions and streets, respectively. The following s lines contain the streets. Each street is described with three integers, xi, yi, and di, 1 <= xi,yi <= m, 0 <= di <= 1, where xi and yi are the junctions connected by a street. If di=1, then the street is a one-way street (going from xi to yi), otherwise it's a two-way street. You may assume that there exists a junction from where all other junctions can be reached.

输出

For each scenario, output one line containing the text "possible" or "impossible", whether or not it's possible to construct a sightseeing tour.

样例输入

4
5 8
2 1 0
1 3 0
4 1 1
1 5 0
5 4 1
3 4 0
4 2 1
2 2 0
4 4
1 2 1
2 3 0
3 4 0
1 4 1
3 3
1 2 0
2 3 0
3 2 0
3 4
1 2 0
2 3 1
1 2 0
3 2 0

样例输出

possible
impossible
impossible
possible

题意

m个点，s条边，问是否存在欧拉回路

题解

网络流判混合路欧拉回路

关键是把图变成有向图再判断

容易知道如果是欧拉回路那么所有点的入度in，等于出度out

可以发现无向边(u,v)，有向边(u,v)或是有向边(v,u)，in[i]-out[i]的奇偶性不变

那我们就可以先假定无向边(u,v)变成有向边(u,v)

统计所有点的入出度

如果存在i，使得abs(in[i]-out[i])%2==1那么图不存在欧拉回路

对于in[i]>out[i]的点，说明i点需要多流出流量，建边(S,i)流量(in[i]-out[i])/2

对于in[i]<out[i]的点，说明i点需要多流入流量，建边(i,T)流量(out[i]-in[i])/2

对于所有无向边(u,v)，建边(u,v)流量1

跑S->T的最大流，若满流即存在一种方法通过改变无向边的方向使得每个点的入度=出度（是不是类似于上下界可行流是否有解问题）

代码

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 using namespace std;

 const int maxn=1e5+;
 const int maxm=2e5+;
 const int INF=0x3f3f3f3f;

 int TO[maxm],CAP[maxm],NEXT[maxm],tote;
 int FIR[maxn],gap[maxn],cur[maxn],d[maxn],q[];
 int n,m,S,T;

 void add(int u,int v,int cap)
 {
     //printf("i=%d %d %d %d\n",tote,u,v,cap);
     TO[tote]=v;
     CAP[tote]=cap;
     NEXT[tote]=FIR[u];
     FIR[u]=tote++;

     TO[tote]=u;
     CAP[tote]=;
     NEXT[tote]=FIR[v];
     FIR[v]=tote++;
 }
 void bfs()
 {
     memset(gap,,sizeof gap);
     memset(d,,sizeof d);
     ++gap[d[T]=];
     for(int i=;i<=n;++i)cur[i]=FIR[i];
     int head=,tail=;
     q[]=T;
     while(head<=tail)
     {
         int u=q[head++];
         for(int v=FIR[u];v!=-;v=NEXT[v])
             if(!d[TO[v]])
                 ++gap[d[TO[v]]=d[u]+],q[++tail]=TO[v];
     }
 }
 int dfs(int u,int fl)
 {
     if(u==T)return fl;
     int flow=;
     for(int &v=cur[u];v!=-;v=NEXT[v])
         if(CAP[v]&&d[u]==d[TO[v]]+)
         {
             int Min=dfs(TO[v],min(fl,CAP[v]));
             flow+=Min,fl-=Min,CAP[v]-=Min,CAP[v^]+=Min;
             if(!fl)return flow;
         }
     if(!(--gap[d[u]]))d[S]=n+;
     ++gap[++d[u]],cur[u]=FIR[u];
     return flow;
 }
 int ISAP()
 {
     bfs();
     int ret=;
     while(d[S]<=n)ret+=dfs(S,INF);
     return ret;
 }
 void init()
 {
     tote=;
     memset(FIR,-,sizeof FIR);
 }
 int main()
 {
     int N,u,v,op,s,_;
     scanf("%d",&_);
     while(_--)
     {
         int in[]={},out[]={};
         init();
         scanf("%d%d",&N,&m);
         S=N+,T=S+,n=T;
         for(int i=;i<=m;i++)
         {
             scanf("%d%d%d",&u,&v,&op);
             in[v]++,out[u]++;
             if(op==)
                 add(u,v,);
         }
         int flag=;
         for(int i=;i<=N;i++)
             if((out[i]-in[i])%==)
             {
                 flag=;
                 break;
             }
         if(!flag)
         {
             printf("impossible\n");
             continue;
         }
         int sum=;
         for(int i=;i<=N;i++)
         {
             if(in[i]>out[i])
             {
                 sum+=(in[i]-out[i])/;
                 add(i,T,(in[i]-out[i])/);
             }
             else if(out[i]>in[i])
                 add(S,i,(out[i]-in[i])/);
         }
         printf("%s\n",ISAP()==sum?"possible":"impossible");
     }
     return ;
 }