hdu3472 混合欧拉

题意：
      给你一些字符串，有的字符串反过来也有意义，题目问给的这n个字符串是否可以首尾相连，组成一个串。

思路：
      算是混合欧拉的基础题目了，混合欧拉就是专门处理这类问题的，先说下混合欧拉的大体步骤。
（1） 判断整个图是否连通，如果不连通直接不行（方法随意，并查集搜索什么的都行）
（2） 看度数差为奇数的有多少个，只能有0个或者两个，其他的都不行。
（3） 如果度数差有奇数的有两个，那么一定一个是正的v1，一个是负的v2，add(v1       ,v2 ,1);
（4） 如果方向随意的边，那么我们随意建立一条就行add(a ,b ,1),方向固定的不用管
（5） 虚拟超级远点s，超级汇点e，然后所有度数为负数的add(s ,i ,-du[i]/2),所有为      正的add(i ,e ,du[i]/2);
（6） 最后一遍最大流，看是否满流，如果满流，那么就是有解，否则无解。
至于为什么费用留可以这样求，等比赛回来再来详细补充这个问题。

 

 

#include<queue>
#include<stdio.h>
#include<string.h>

#define N_node 30
#define N_edge 10000
#define INF 100000000

using namespace std;

typedef struct
{
   int to ,next ,cost;
}STAR;

typedef struct
{
   int x ,t;
}DEP;

STAR E[N_edge];
DEP xin ,tou;
int list[N_node] ,listt[N_node] ,tot;
int du[N_node] ,deep[N_node];
int mer[N_node];

void add(int a, int b ,int c)
{
   E[++tot].to = b;
   E[tot].cost = c;
   E[tot].next = list[a];
   list[a] = tot;
  
   E[++tot].to = a;
   E[tot].cost = 0;
   E[tot].next = list[b];
   list[b] = tot;
}

int minn(int x ,int y)
{
   return x < y ? x : y;
}

int finds(int x)
{
   return x == mer[x] ? x : mer[x] = finds(mer[x]);
}

bool BFS_Deep(int s ,int t ,int n)
{
   memset(deep ,255 ,sizeof(deep));
   queue<DEP>q;
   xin.x = s ,xin.t = 0;
   q.push(xin);
   deep[xin.x] = xin.t;
   while(!q.empty())
   {
      tou = q.front();
      q.pop();
      for(int k = list[tou.x] ;k ;k = E[k].next)
      {
         xin.x = E[k].to;
         xin.t = tou.t + 1;
         if(deep[xin.x] != -1 || !E[k].cost) continue;
         deep[xin.x] = xin.t;
         q.push(xin);
      }
   }
   for(int i = 0 ;i <= n ;i ++)
   listt[i] = list[i];
   return deep[t] != -1;
}

int DFS_Flow(int s ,int t ,int flow)
{
   if(s == t) return flow;
   int nowflow = 0;
   for(int k = listt[s] ;k ;k = E[k].next)
   {
      int to = E[k].to;
      int c = E[k].cost;
      listt[s] = k;
      if(deep[to] != deep[s] + 1 || !c) continue;
      int tmp = DFS_Flow(to ,t ,minn(c ,flow - nowflow));
      nowflow += tmp;
      E[k].cost -= tmp;
      E[k^1].cost += tmp;
      if(nowflow == flow) break;
   }
   if(!nowflow) deep[s] = 0;
   return nowflow;
}

int DINIC(int s ,int t ,int n)
{
   int Ans = 0;
   while(BFS_Deep(s ,t ,n))
   {
      Ans =+ DFS_Flow(s ,t ,INF);
   }
   return Ans;
}

int main ()
{
   int n ,i ,j ,a ,b ,c;
   int mark[30];
   int t ,cas = 1;
   char str[30];
   scanf("%d" ,&t);
   while(t--)
   {
      scanf("%d" ,&n);
      memset(list ,0 ,sizeof(list)) ,tot = 1;
      memset(du ,0 ,sizeof(du));
      memset(mark ,0 ,sizeof(mark));
      for(i = 1 ;i <= 26 ;i ++) mer[i] = i;
     
      for(i = 1 ;i <= n ;i ++)
      {
         scanf("%s %d" ,str ,&c);
         a = str[0] - 'a' + 1;
         b = str[strlen(str)-1] - 'a' + 1;
         du[a] -- ,du[b] ++;
         mark[a] = mark[b] = 1;
         mer[finds(a)] = finds(b);
         if(c) add(a ,b ,1);
      }
     
      int sum = 0;
      for(i = 1 ;i <= 26 && sum <= 2;i ++)
      if(finds(i) == i && mark[i])  sum ++;
      printf("Case %d: " ,cas ++);
      if(sum != 1)
      {
         puts("Poor boy!");
         continue;
      }
     
      sum = 0;
      int v1 ,v2;
      for(i = 1 ;i <= 26 ;i ++)
      {
         if(du[i] % 2 && du[i] < 0) v1 = i ,sum ++;
         if(du[i] % 2 && du[i] > 0) v2 = i ,sum ++;
      }
      if(sum != 0 && sum != 2)
      {
          puts("Poor boy!");
          continue;
      }
      if(sum == 2)
      {
         add(v1 ,v2 ,1);
         du[v1] -- ,du[v2] ++;
      }
     
      sum = 0;
      for(i = 1 ;i <= 26 ;i ++)
      {
         if(!mark[i]) continue;
         if(du[i] < 0) add(0 ,i ,-du[i]/2) ,sum -= du[i]/2;
         else add(i ,27 ,du[i]/2);
      }
      DINIC(0 ,27 ,27) == sum ? puts("Well done!"):puts("Poor boy!");
   }
   return 0;
}