P4617 [COCI2017-2018#5] Dinic + SCC 分解 / 匈牙利算法

题意

传送门 P4617 [COCI2017-2018#5] Planinarenje

题解

二分图博弈问题。构造一组二分图最大匹配。博弈过程可以看作走交错路的过程。若先手从左部走一条非匹配边，由于图中不存在增广路，故最终停在左部点上，先手必败。若先手走一条匹配边，若最终停在左部点上，那么将交错路匹配状态取反，将得到另一组最大匹配；反之，出发点是最大匹配的必经点。

问题转化为判断图的各个左部点是否是二分图最大匹配的必经点。

Dinic + SCC 分解

$Dinic$ 求解最大匹配。在残余网络中，若匹配边 $(u,v)$ 删除后仍能找到增广路，那么存在一条 $u\to v$ 的路径，而残余网络中 $u\leftarrow v$，则 $(u,v)$ 在同一个强连通分量中。

二分图最大匹配的必经点一定是任一组最大匹配的端点。在残余网络上分解强连通分量，则二分图最大匹配的必经边是一条匹配边，且其左右部端点，位于不同的强连通分量中，此时端点一定是二分图最大匹配的必经点。若匹配边的左右端点位于相同的强连通分量中，则说明将这条匹配边删除后，从左部或右部节点出发能找到一条增广路；那么对于左部必经点，其所在的强连通分量中一定不存在左部非匹配点。

总时间复杂度 $O(m\sqrt{n})$。

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int MAXN = 2E4 + 10, INF = 0x3f3f3f3f;
int N, M, V;
struct edge
{
    int to, cap, rev;
};
vector<int> tG[MAXN];
vector<edge> G[MAXN];
int iter[MAXN], level[MAXN];

void add_edge(int from, int to, int cap)
{
    G[from].pb({to, cap, G[to].size()});
    G[to].pb({from, 0, G[from].size() - 1});
}

void bfs(int s)
{
    memset(level, -1, sizeof(level));
    level[s] = 0;
    queue<int> q;
    q.push(s);
    while (q.size())
    {
        int v = q.front();
        q.pop();
        for (auto &e : G[v])
            if (e.cap > 0 && level[e.to] == -1)
                level[e.to] = level[v] + 1, q.push(e.to);
    }
}

int dfs(int v, int t, int f)
{
    if (v == t)
        return f;
    for (int &i = iter[v]; i < G[v].size(); ++i)
    {
        auto &e = G[v][i];
        if (level[e.to] > level[v] && e.cap > 0)
        {
            int d = dfs(e.to, t, min(f, e.cap));
            if (d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s, int t)
{
    int flow = 0;
    for (;;)
    {
        bfs(s);
        if (level[t] == -1)
            return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > 0)
            flow += f;
    }
}

vector<int> rG[MAXN], vs, scc[MAXN];
int idx[MAXN], f[MAXN], match[MAXN];
bool used[MAXN];

void _dfs(int v)
{
    used[v] = 1;
    for (auto &e : G[v])
        if (e.cap > 0 && !used[e.to])
            _dfs(e.to);
    vs.pb(v);
}

void rdfs(int v, int k)
{
    used[v] = 1, idx[v] = k;
    scc[k].pb(v);
    for (int u : rG[v])
        if (!used[u])
            rdfs(u, k);
}

int find_scc()
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for (int v = 0; v < V; ++v)
        if (!used[v])
            _dfs(v);
    memset(used, 0, sizeof(used));
    int k = 0;
    for (int i = (int)vs.size() - 1; i >= 0; --i)
        if (!used[vs[i]])
            rdfs(vs[i], k++);
    return k;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < M; ++i)
    {
        int u, v;
        cin >> u >> v;
        --u, --v;
        add_edge(u, N + v, 1);
    }
    int s = N * 2, t = s + 1;
    V = t + 1;
    for (int v = 0; v < N; ++v)
        add_edge(s, v, 1), add_edge(N + v, t, 1);
    max_flow(s, t);
    for (int v = 0; v < V; ++v)
        for (auto &e : G[v])
            if (e.cap > 0)
                rG[e.to].pb(v);
    int n = find_scc();
    memset(match, -1, sizeof(match));
    for (int v = 0; v < N; ++v)
        for (auto &e : G[v])
            if (e.to != s && e.cap == 0)
            {
                match[v] = e.to;
                break;
            }
    for (int v = 0; v < N; ++v)
        if (match[v] != -1)
        {
            int u = match[v];
            if (idx[v] != idx[u])
                f[v] = 1;
        }
    for (int i = 0; i < n; ++i)
    {
        vector<int> l;
        bool found = 0;
        for (int v : scc[i])
            if (v < N)
            {
                if (match[v] != -1)
                    l.pb(v);
                else
                    found = 1;
            }
        if (!found)
        {
            for (int v : l)
                if (idx[v] == idx[match[v]])
                    f[v] = 1;
        }
    }
    for (int i = 0; i < N; ++i)
        cout << (f[i] ? "Slavko" : "Mirko") << '\n';
    return 0;
}

匈牙利算法

本题数据量较小，可以应用匈牙利算法更简单地实现。

一种思路是枚举已匹配的右部节点 $v$，删除其左部匹配点 $u$，判断是否从 $v$ 出发找到一条增广路，若可以，则 $u$ 不是二分图最大匹配的必经点。

另一种思路是从不能匹配的左部节点出发，对交错路上的所有节点打上标记，意味着这些节点不可能是二分图最大匹配的必经点。因为匹配点 $v$ 若不是最大匹配的必经点，则可以从一个未匹配点出发找到一条可达 $v$ 的交错路，将路上匹配状态取反后得到一组不经过 $v$ 的最大匹配。

总时间复杂度 $O(nm)$。

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int MAXN = 2E4 + 10;
int N, M;
int f[MAXN], match[MAXN];
bool used[MAXN];
vector<int> G[MAXN];

void add_edge(int from, int to) { G[from].pb(to), G[to].pb(from); }

bool dfs(int v)
{
    used[v] = 1;
    for (int u : G[v])
    {
        int w = match[u];
        if (w == -1 || (!used[w] && dfs(w)))
        {
            match[v] = u, match[u] = v;
            return 1;
        }
    }
    return 0;
}

void get(int v)
{
    used[v] = 1;
    f[v] = 1;
    for (int u : G[v])
    {
        int w = match[u];
        if (!used[w])
            get(w);
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < M; ++i)
    {
        int u, v;
        cin >> u >> v;
        --u, --v;
        add_edge(u, N + v);
    }
    memset(match, -1, sizeof(match));
    for (int v = 0; v < N; ++v)
    {
        memset(used, 0, sizeof(used));
        if (dfs(v))
            continue;
        memset(used, 0, sizeof(used));
        get(v);
    }
    for (int i = 0; i < N; ++i)
        cout << (!f[i] ? "Slavko" : "Mirko") << '\n';
    return 0;
}