SCU 4529 An Easy Problem（强连通分量+缩点+最小路径覆盖+剪枝）

本文链接：https://blog.youkuaiyun.com/Noooooorth/article/details/52031742

本文介绍了一种解决有向图最小路径覆盖问题的方法。通过先进行强连通分量分解，然后使用Floyd算法进行闭包传递，最终利用匈牙利算法找到最小路径覆盖数量。文中提供了一个完整的C++实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目大意：有向有环图，求最小路径覆盖，点可以重复使用

解题思路：

题目有1000个点，直接闭包传递可能会超时，所以可以先把每个强连通分量缩点，然后再使用floyd进行闭包传递，最后再求最小路径覆盖。在闭包传递的时候要进行一个剪枝，不然会被卡常数。

#include <set>
#include <map>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
#define FIN freopen("in.txt", "r", stdin);
#define FOUT freopen("out.txt", "w", stdout);
#define lson l, mid, cur << 1
#define rson mid + 1, r, cur << 1 | 1
const int INF = 0x3f3f3f3f;
const int MAXN = 1e3 + 50;
const int MAXM = 1e5 + 50;
const int MOD = 1e9 + 7;

int n, m, tim;
bool mp[MAXN][MAXN];

struct Edge
{
    int from, to, nxt;
}E[MAXM];
int Head[MAXN], tot;

void edge_init()
{
    tot = 0;
    memset(Head, -1, sizeof(Head));
}

void edge_add(int u, int v)
{
    E[tot].from = u;
    E[tot].to = v;
    E[tot].nxt = Head[u];
    Head[u] = tot++;
}

int Low[MAXN], DFN[MAXN], Stack[MAXN], Belong[MAXN];
int Index, top, scc;
bool InStack[MAXN];
int num[MAXN];

void Tarjan(int u)
{
    DFN[u] = Low[u] = ++Index;
    InStack[u] = true;
    Stack[top++] = u;
    int v;
    for (int i = Head[u]; ~i; i = E[i].nxt)
    {
        v = E[i].to;
        if (!DFN[v])
        {
            Tarjan(v);
            if (Low[u] > Low[v])
                Low[u] = Low[v];
        }
        else if (InStack[v] && Low[u] > DFN[v])
            Low[u] = DFN[v];
    }
    if (Low[u] == DFN[u])
    {
        scc++;
        do
        {
            v = Stack[--top];
            InStack[v] = false;
            Belong[v] = scc;
            num[scc]++;
        } while (v != u);
    }
}

void floyd()
{
    for (int k = 1; k <= scc; k++)
        for (int i = 1; i <= scc; i++)
        {
            if (!mp[i][k]) //剪枝
                continue;
            for (int j = 1; j <= scc; j++)
                if (mp[i][k] && mp[k][j])
                    mp[i][j] = true;
        }
}

int linker[MAXN];
bool used[MAXN];

bool dfs(int u)
{
    for (int i = 1; i <= scc; i++)
    {
        if (i == u)
            continue;
        if (mp[u][i] && !used[i])
        {
            used[i] = true;
            if (linker[i] == -1 || dfs(linker[i]))
            {
                linker[i] = u;
                return true;
            }
        }
    }
    return false;
}

int hungray()
{
    int res = 0;
    memset(linker, -1, sizeof(linker));
    for (int i = 1; i <= scc; i++)
    {
        memset(used, false, sizeof(used));
        if (dfs(i))
            res++;
    }
    return res;
}

int main()
{
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    int tcase;
    scanf("%d", &tcase);
    for (int c = 1; c <= tcase; c++)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            mp[i][j] = false;
        edge_init();
        memset(mp, false, sizeof(mp));
        memset(DFN, 0, sizeof(DFN));
        memset(num, 0, sizeof(num));
        memset(InStack, false, sizeof(InStack));
        Index = scc = top = 0;
        for (int i = 0; i < m; i++)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            edge_add(u, v);
        }
        for (int i = 1; i <= n; i++)
            if (!DFN[i])
                Tarjan(i);
        printf("Case %d: ", c);
        for (int i = 0; i < tot; i++)
            mp[Belong[E[i].from]][Belong[E[i].to]] = true;
        floyd();
        printf("%d\n", scc - hungray());
    }
    return 0;
}