P3119 [USACO15JAN] SCC 分解 + SPFA

题意

传送门 P3119 [USACO15JAN] Grass Cownoisseur

题解

显然节点 $1$ 可以遍历其强连通分量内的各点。使用一次 $DFS$ 对顶点后序遍历进行标号，第二次 $DFS$ 跑反向图的方法进行强连通分量分解。将强连通分量缩成一个顶点后，得到一个 $DAG$。

设 $1$ 所在的强连通分量所缩点为 $s$，目标是走 $DAG$ 内某条边的反向边使之形成一个包含节点 $s$ 的环。枚举需要反向的边 $e=(v,u)$，若存在从节点 $s$ 到 $u$ 以及从节点 $v$ 到 $s$ 的路径，则用点权最大的路径更新答案。求点权最大的路径，需要预先求出以节点 $s$ 为源点的单源最长路以及以 $s$ 为汇点的单汇最长路（可以通过将有向边反向转化为单源最长路），$SPFA$ 求解即可。

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
#define inf 0x3f3f3f3f
#define maxn 100005
int N, M, cmp[maxn], dis1[maxn], dis2[maxn], sz[maxn], inq[maxn];
bool used[maxn];
vector<int> G[maxn], rG[maxn], sG[maxn], rsG[maxn], vs;

void add_edge(int u, int v)
{
    G[u].push_back(v);
    rG[v].push_back(u);
}

void dfs(int v)
{
    used[v] = 1;
    for (int i = 0; i < G[v].size(); i++)
    {
        if (!used[G[v][i]]) dfs(G[v][i]);
    }
    vs.push_back(v);
}

void rdfs(int v, int k)
{
    used[v] = 1, cmp[v] = k;
    for (int i = 0; i < rG[v].size(); i++)
    {
        if (!used[rG[v][i]]) rdfs(rG[v][i], k);
    }
}

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

void spfa(int s, int *dis, int k, vector<int> *G)
{
    memset(inq, 0, sizeof(int) * k);
    memset(dis, -1, sizeof(int) * k);
    queue<int> q;
    dis[s] = 0, inq[s] = 1;
    q.push(s);
    while (!q.empty())
    {
        int v = q.front();
        q.pop();
        inq[v] = 0;
        for (int i = 0; i < G[v].size(); i++)
        {
            int u = G[v][i], d2 = dis[v] + sz[u];
            if (dis[u] < d2)
            {
                dis[u] = d2;
                if (!inq[u])
                {
                    inq[u] = 1;
                    q.push(u);
                }
            }
        }
    }
}

void solve()
{
    int k = scc(N);
    if (k == 1)
    {
        printf("%d\n", N);
        return;
    }
    for (int v = 0; v < N; v++)
    {
        int a = cmp[v];
        sz[a]++;
        for (int i = 0; i < G[v].size(); i++)
        {
            int b = cmp[G[v][i]];
            if (a != b)
            {
                sG[a].push_back(b);
                rsG[b].push_back(a);
            }
        }
    }
    spfa(cmp[0], dis1, k, sG);
    spfa(cmp[0], dis2, k, rsG);
    int res = 0;
    for (int v = 0; v < k; v++)
    {
        if (dis2[v] == -1) continue;
        for (int i = 0; i < sG[v].size(); i++)
        {
            int u = sG[v][i];
            if (dis1[u] != -1) res = max(res, dis1[u] + dis2[v] + sz[cmp[0]]);
        }
    }
    printf("%d\n", res);
}

int main()
{
    scanf("%d%d", &N, &M);
    for (int i = 0; i < M; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        --u, --v;
        add_edge(u, v);
    }
    solve();
    return 0;
}