二分图的必经边与可行边（HDU - 3026 Chinese Chess）

题目链接
对于一个二分图，我们对于满足最大匹配的多组匹配方案中，对于某些边：

如果对于每个方案，这个边都被选择了，我们称这条边为必经边
如果一条边，它在至少一个方案中被选择了，我们称这条边为可行边

求必经边第一种方案，我们易知可以枚举每个边，去掉该边后，跑一边最大匹配，看看最大匹配数是否减小，若减小，该边为必经边。
显然我们就算用Dinic跑最大匹配，时间复杂度也会到达$O(E^2\ast \sqrt{V})$在这个题中1e5的级别完全不够用。。
于是我们用Dinic+tarjan在$O(E\ast \sqrt{V})$时间内处理出必经点与可行点。
方法如下：

第一步

与普通最大匹配一样，建立超级源汇点，先用Dinic跑出最大匹配数。

第二步

用tarjan算法在跑完Dinic后的残流图上跑强连通分量。（残流图，如果一个边的残流大于0，我们认为联通，否则不连通）
在这，我们不难发现：如果一个边被选择了，那么这个边从左部到右部的残量就是0，反向边就是1，等同于一个从右部指向左部的有向边。未被选中的边反之。

第三步

我们枚举每一条边：有以下结论：：（重点来了）
必经边：：对于一个边<x，y>，如果该边的流量为1（残量为0），且x，y分布在两个不同的强连通分量中，则<x，y>为必经边。
可行边：：对于一个边<x，y>，如果该边的流量为1（残量为0），或x，y分布在相同的强连通分量中，则<x，y>为可行边。
证明详细看蓝皮书（我也不太懂 ）
下面是ac代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <stack>
#include <map>
#include <queue>
#define ll long long
using namespace std;
const int NN = 7e5+5;
const int INF = 0x3f3f3f3f;
typedef unsigned long long ull;
int he[NN], ne[NN], ver[NN], e[NN], l[NN];
int n, m, idx = 0, k = 1, Bcnt = 0;
int ins[NN], ans = 0, tei;
int dfn[NN], low[NN];
int Belong[NN];
stack<int> s;
int tot;
void init()
{
    memset(he, 0, sizeof(he));
    memset(dfn, 0, sizeof(dfn));
    memset(low, 0, sizeof(low));
    memset(ins, 0, sizeof(ins));
    while(s.size()) s.pop();
    Bcnt = 0;
    idx = 0;
    tot = 1;
}
void add(int x, int y, int w)
{
    e[++tot] = w;
    ver[tot] = y;
    ne[tot] = he[x];
    he[x] = tot;
    e[++tot] = 0;
    ver[tot] = x;
    ne[tot] = he[y];
    he[y] = tot;
}
bool bfs(int s, int t)
{
    memset(l, 0, sizeof(l));
    queue<int> q;
    q.push(s);
    l[s] = 1;
    while(q.size())
    {
        int x = q.front();
        q.pop();
        if (x == t) return 1;
        for (int i = he[x]; i; i = ne[i])
        {
            int y = ver[i];
            if (!l[y] && e[i])
            {
                l[y] = l[x] + 1;
                q.push(y);
            }
        }
    }
    return 0;
}
int dfs(int x, int MaxFlow, int t)
{
    if (x == t) return MaxFlow;
    int uflow = 0;
    for (int i = he[x]; i; i = ne[i])
    {
        int y = ver[i];
        if (l[y] == l[x] + 1 && e[i])
        {
            int flow = min(e[i], MaxFlow - uflow);
            flow = dfs(y, flow, t);
            e[i] -= flow;
            e[i^1] += flow;
            uflow += flow;
            if (uflow == MaxFlow)
                break;
        }
    }
    if (uflow == 0)
        l[x] = 0;
    return uflow;
}
int Dinic(int s, int t)
{
    int MaxFlow = 0;
    while(bfs(s, t))
        MaxFlow += dfs(s, INF, t);
    return MaxFlow;
}
void tarjan(int u)
{
    int v;
    dfn[u] = low[u] = ++idx;
    s.push(u);
    ins[u] = 1;
    for (int i = he[u]; i; i = ne[i])
    {
        if (e[i] == 0) continue;

        v = ver[i];
        if (!dfn[v])
        {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }
        else if (ins[v]) low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u])
    {
        Bcnt++;
        int _cnt = 0;
        do
        {
            v = s.top();
            s.pop();
            ins[v] = 0;
            Belong[v] = Bcnt;
            _cnt++;
        }while(u != v);
        if (ans < _cnt)
        {
            tei = Bcnt;
            ans = _cnt;
        }
    }
}
int main()
{
    int k;
    int t0 = 1;
    while(scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        init();
        for (int i =0; i < k; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            add(x, n+y, 1);
        }
        int s = 0, t = n + m + 1;
        for (int i = 1; i <= n; i++)
            add(s, i, 1);
        for (int i = 1; i <= m; i++)
            add(i+n, t, 1);
        //以上为建图过程  以下为求解过程
        int anss = Dinic(s, t);//第一步
        for (int i = s; i <= t; i++)
            if (!dfn[i]) tarjan(i);//第二步
        int cntt = 0;
        for (int i = 1; i <= n; i++)
        {
            for (int j = he[i]; j; j = ne[j])
            {
                if (ver[j]==s) continue;
                if (Belong[i] != Belong[ver[j]] && e[j] == 0)//必经边定理
                    cntt++;
            }//枚举每个边
        }
        printf("Board %d have %d important blanks for %d chessmen.\n",t0++, cntt, anss);
    }
    return 0;
}