HDU-3472（混合图判断欧拉路 + ISAP）

题目大意：给出n个单词，其中一些单词翻转后还是单词。求是否能首尾相接连成一条链。

将每个单词的首尾字母作为端点，如果这个单词可以翻转，就看作一条双向边。否则，就看作一条单向边。

用最大流处理混合图（既有双向边又有单向边）欧拉回路的时候，先忽略初始图中的有向边。为无向边指定一个方向并保留。

然后建立一个源点s，把s连向所有度数>0的边，容量是度数/2。

建立一个汇点t，把所有度数<0的边连向t，容量是度数/2。

所有没连接到s或t的边，容量都为1。

如果从s出发的所有边都满流，则存在欧拉回路。在本题中，不一定要求得欧拉回路，欧拉路也可以。

如果图中没有度数为奇数的点，那么直接判断欧拉回路。如果图中恰有两个度数为奇数的点，在这两点之间连接一条容量为1的边，再判断欧拉回路。

（记得判断图的联通性）

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<cmath>
#include<set>

#define cl(a, n) memset(a, n, sizeof(a))
#define cpy(a, b) memcpy(a, b, sizeof(b))

using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5;
const int maxm = 4e5 + 5;
const int INF = 0x3f3f3f3f;

struct Edge{
    int to, Next, cap, flow, c;
}edge[maxm];

int tot;
int head[maxn];
int gap[maxn], dep[maxn], cur[maxn]; 

int in[maxn], out[maxn];
int vis[maxn];

int f[maxn];

void init(){
    tot = 0;
    cl(head, -1);
    cl(in, 0);
    cl(out, 0);
    cl(vis, 0);
    cl(f, 0);
}

void add(int u, int v, ll w){
    edge[tot].to = v; edge[tot].cap = w; edge[tot].Next = head[u];
    edge[tot].flow = 0; head[u] = tot++;
    edge[tot].to = u; edge[tot].cap = 0; edge[tot].Next = head[v];
    edge[tot].flow = 0; head[v] = tot++;
}

int Q[maxn];
void bfs(int st, int ed){
    memset(dep, -1, sizeof(dep));
    memset(gap, 0, sizeof(gap));
    gap[0] = 1;
    int front = 0, rear = 0;
    dep[ed] = 0;
    Q[rear++] = ed;
    while(front != rear){
        int u = Q[front++];
        for(int i = head[u]; i != -1; i = edge[i].Next){
            int v = edge[i].to;
            if(dep[v] != -1) continue;
            Q[rear++] = v;
            dep[v] = dep[u] + 1;
            gap[dep[v]]++;
        }
    }
}

int S[maxn];
int sap(int st, int ed, int N){
    bfs(st, ed);
    memcpy(cur, head, sizeof(head));
    int top = 0;
    int u = st;
    int ans = 0;
    while(dep[st] < N){
        if(u == ed){
            int Min = INF;
            int inser;
            for(int i = 0; i < top; i++)
                if(Min > edge[S[i]].cap - edge[S[i]].flow){
                    Min = edge[S[i]].cap - edge[S[i]].flow;
                    inser = i;
                }
                for(int i = 0; i < top; i++){
                    edge[S[i]].flow += Min;
                    edge[S[i] ^ 1].flow -= Min;
                }
                ans += Min;
                top = inser;
                u = edge[S[top] ^ 1].to;
                continue;
        }
        bool flag = false;
        int v;
        for(int i = cur[u]; i != -1; i = edge[i].Next){
            v = edge[i].to;
            if(edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u]){
                flag = true;
                cur[u] = i;
                break;
            }
        }
        if(flag){
            S[top++] = cur[u];
            u = v;
            continue;
        }
        int Min = N;
        for(int i = head[u]; i != -1; i = edge[i].Next){
            if(edge[i].cap - edge[i].flow && dep[edge[i].to] < Min){
                Min = dep[edge[i].to];
                cur[u] = i;
            }
        }
        gap[dep[u]]--;
        if(!gap[dep[u]]) return ans;
        dep[u] = Min + 1;
        gap[dep[u]]++;
        if(u != st) u = edge[S[--top] ^ 1].to;
    }
    return ans;
}


int get(int x){
    if(x != f[x]) return f[x] = get(f[x]);
    else return f[x];
}

void Union(int x, int y){
    x = get(x); 
    y = get(y);
    if(x != y) f[x] = y;
}

int main()
{
    int T;
    scanf("%d", &T);
    for(int K = 1; K <= T; K++){
        init();
        int n;
        scanf("%d", &n);
        for(int i = 0; i <= 26; i++) f[i] = i;
        int s = 0, t = 27, num = 0;
        for(int i = 1; i <= n; i++){
            char s[205];
            int c;
            scanf("%s%d", s, &c);
            int u = s[0] - 'a' + 1, v = s[strlen(s) - 1] - 'a' + 1;
            out[u]++; in[v]++;
            int x = get(u);
            int y = get(v);
            if(x != y) f[x] = y;
            if(c == 1){
                add(u, v, 1);
            }
        }
        int cnt = 0;
        int odd = 0;
        int sum = 0;
        int u = 0;
        for(int i = 1; i <= 26; i++){
            if(!out[i] && !in[i]) continue;
            if(f[i] == i) cnt++;
            if(cnt > 1) break;
            if((out[i] - in[i])&1){
                if(odd == 2) {
                    out[u]++; in[i]++;
                    add(u, i, 1);
                }
                u = i;
                odd++;
            }
            if(out[i]-in[i] > 0) {
                add(s, i, (out[i] - in[i]) / 2);
                sum += (out[i] - in[i]) / 2;
            }
            else if((out[i]-in[i]) < 0) add(i, t, (in[i] - out[i]) / 2);
        }
        printf("Case %d: ", K);
        if(cnt != 1 || (odd != 0 && odd != 2)){
            printf("Poor boy!
");
        }
        else if(sap(s, t, 28) == sum){
            printf("Well done!
");
        }
        else{
            printf("Poor boy!
");
        }
    }
    return 0;
}