HDU 4687 Boke and Tsukkomi 一般图匹配

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=4687

题意：

有n个女孩，她们之间有k对可能的组合，但参赛时每个人只能参加一个组合，在组合数量最大化时有些组合是多余的，找出这些多余的组合

思路：

刚开始我的思路是首先求出最大匹配，然后枚举每条边是不是多余的，用去掉枚举边之后的图求出最大匹配，和最初的最大匹配比较，若相等说明当前枚举边是多余的。然而WA了，有数据如下：
5 4
1 2
2 3
3 4
4 5
此时跑出的答案即多余边是全部的边，明显是不对的。。。
换种思路，可以枚举每条边是不是在最大匹配中，把当前枚举边的两个点删除（即强制匹配这两个点），用新图求出最大匹配，若等于最初的最大匹配-1，则说明枚举边一定在最大匹配中，否则就是多余边。
带花树开花算法蒟蒻很难理解，权当模板

#include <bits/stdc++.h>
using namespace std;

const int N = 210;

struct edge
{
    int to, next;
}g[N*N*2];

int cnt, head[N];
int que[N], rear;
int match[N], mark[N], nxt[N], par[N], vis[N];

int n, m, a[N], b[N];
bool h[N][N];

void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
int ser(int x)
{
    int r = x, i = x, j;
    while(r != par[r]) r = par[r];
    while(i != r) j = par[i], par[i] = r, i = j;
    return r;
}
void unite(int x, int y)
{
    x = ser(x), y = ser(y);
    if(x == y) return;
    par[x] = y;
}
int lca(int x, int y)
{
    static int t = 0;
    t++;
    while(true)
    {
        if(x != -1)
        {
            x = ser(x); //点要对应到所在的花上去
            if(vis[x] == t) return x;
            vis[x] = t;
            if(match[x] != -1) x = nxt[match[x]];
            else x = -1;
        }
        swap(x, y); //交换，使两点轮流走
    }
}
void group(int x, int r)
{
    while(x != r)
    {
        int y = match[x], z = nxt[y];
        // next数组是用来标记花朵中的路径的，综合match数组来用，实际上形成了
        // 双向链表，如(x, y)是匹配的，next[x]和next[y]就可以指两个方向了。
        if(ser(z) != r) nxt[z] = y;
        /* 奇环中的点都有机会向环外找到匹配，所以都要标记成S型点加到队列中去，
         因环内的匹配数已饱和，因此这些点最多只允许匹配成功一个点，在aug中
         每次匹配到一个点就break终止了当前阶段的搜索，并且下阶段的标记是重
         新来过的，这样做就是为了保证这一点。*/
        if(mark[y] == 2) mark[que[rear++] = y] = 1;
        if(mark[z] == 2) mark[que[rear++] = z] = 1;
        unite(x, y), unite(y, z);
        x = z;
    }
}
void augmented(int s)
{
    for(int i = 1; i <= n; i++) //每次都要重设标记
        nxt[i] = -1, par[i] = i, mark[i] = 0, vis[i] = -1;
    mark[s] = 1; //1代表S型，2代表T型
    que[0] = s;
    rear = 1;
    for(int i = 0; match[s] == -1 && i < rear; i++)
    {
        int v = que[i];
        for(int j = head[v]; j != -1; j = g[j].next)
        {
            int u = g[j].to;
            if(match[v] == u) continue; //v,u已经匹配，跳过
            if(ser(v) == ser(u)) continue; //在同一朵花中，跳过
            if(mark[u] == 2) continue; //T型，跳过
            if(mark[u] == 1) //S型，奇环缩点
            {
                int r = lca(v, u); // r为从v和u到s的路径上的第一个公共节点
                if(ser(v) != r) nxt[v] = u; // r和v不在同一个花朵，nxt标记花朵内路径
                if(ser(u) != r) nxt[u] = v; // r和u不在同一个花朵，nxt标记花朵内路径
                //将整个r-x-y-r的奇环缩成点，r作为这个环的标记节点
                group(v, r), group(u, r);// 缩路径r-v和r-u为点
            }
            else if(match[u] == -1) //u自由，可以增广
            {
                nxt[u] = v;
                for(int k = u; k != -1;) //交错路取反
                {
                    int x = nxt[k];
                    int tm = match[x];
                    match[x] = k, match[k] = x;
                    k = tm;
                }
                break; // 搜索成功，退出循环将进入下一阶段
            }
            else
            { // 当前搜索的交叉链+u+match[u]形成新的交错路，将match[u]加入队列作为待搜节点
                nxt[u] = v;
                mark[que[rear++] = match[u]] = 1;
                mark[u] = 2;
            }
        }
    }
}
int work()
{
    memset(match, -1, sizeof match);
    for(int i = 1; i <= n; i++)
        if(match[i] == -1) augmented(i);
    int num = 0;
    for(int i = 1; i <= n; i++)
        if(match[i] != -1) num++;
    return num/2;
}
int main()
{
    while(~ scanf("%d%d", &n, &m))
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &a[i], &b[i]);
            add_edge(a[i], b[i]), add_edge(b[i], a[i]);
        }
        int res = work(), num = 0;
        int arr[N], k = 0;
        for(int i = 0; i < m; i++)
        {
            cnt = 0;
            memset(head, -1, sizeof head);
            for(int j = 0; j < m; j++)
            {
                if(i == j) continue;
                if(a[j] == a[i] || a[j] == b[i] || b[j] == a[i] || b[j] == b[i]) continue;//删除枚举边的两端点
                add_edge(a[j], b[j]), add_edge(b[j], a[j]);
            }
            int tm = work();
            printf("%d %d %d\n", i, tm, res);
            if(tm != res-1) num++, arr[k++] = i;
        }
        printf("%d\n", num);
        for(int i = 0; i < k; i++) printf("%d%c", arr[i]+1, i == k-1 ? '\n' : ' ');
        if(! num) printf("\n");//没有多余边时输出空行，否则会PE
    }
    return 0;
}