从「缩点」到DAG：用Tarjan+Kosaraju搞定洛谷P3387，彻底弄懂有向图强连通分量

在算法竞赛中，图论问题往往考验选手对复杂结构的拆解能力。洛谷P3387作为一道经典模板题，完整呈现了「强连通分量→缩点→DAG动态规划」的技术链条。本文将带你穿透理论迷雾，用两种截然不同的算法视角（Tarjan与Kosaraju）解剖问题本质，最终在缩点后的DAG上实现优雅的动态规划解法。

1. 强连通分量的双重解法

1.1 Tarjan算法的精妙设计

Tarjan算法之所以成为图论领域的瑞士军刀，在于其巧妙的双时间戳机制。让我们通过洛谷P3387的输入样例，观察算法如何逐步标记图中的强连通分量：

cpp复制vector<int> dfn(n+1);  // 访问次序标记
vector<int> low(n+1);  // 可回溯的最早次序
stack<int> stk;        // 递归栈
vector<bool> inStk(n+1); 
int timestamp = 1;

void tarjan(int cur) {
    dfn[cur] = low[cur] = timestamp++;
    stk.push(cur);
    inStk[cur] = true;
    for(int nex : graph[cur]) {
        if(!dfn[nex]) {
            tarjan(nex);
            low[cur] = min(low[cur], low[nex]); 
        } else if(inStk[nex]) {
            low[cur] = min(low[cur], dfn[nex]);
        }
    }
    if(dfn[cur] == low[cur]) {  // 发现SCC
        int x;
        do {
            x = stk.top(); stk.pop();
            inStk[x] = false;
            scc[x] = cur;  // 用cur作为代表元
        } while(x != cur);
    }
}

关键操作解析：

• dfn记录节点的DFS序，相当于访问身份证
• low通过递归回溯不断更新，标记当前节点能触及的最早祖先
• 当dfn == low时，栈中弹出节点构成完整SCC

注意：实际竞赛中常将low[cur] = min(low[cur], dfn[nex])优化为low[cur] = min(low[cur], low[nex])，这种写法在求割点时需特别注意正确性

1.2 Kosaraju的逆向思维

与Tarjan的递归栈思路不同，Kosaraju算法采用两次DFS的策略：

cpp复制// 第一次DFS：逆图后序遍历
void reverseDFS(int cur) {
    vis[cur] = true;
    for(int nex : reverseGraph[cur]) 
        if(!vis[nex]) reverseDFS(nex);
    stk.push(cur);  // 记录完成时间
}

// 第二次DFS：原图逆序遍历
void forwardDFS(int cur, int leader) {
    vis[cur] = true;
    scc[cur] = leader;
    for(int nex : forwardGraph[cur])
        if(!vis[nex]) forwardDFS(nex, leader);
}

// 主流程
fill(vis.begin(), vis.end(), false);
for(int i=1; i<=n; ++i) 
    if(!vis[i]) reverseDFS(i);

fill(vis.begin(), vis.end(), false);
while(!stk.empty()) {
    int cur = stk.top(); stk.pop();
    if(!vis[cur]) forwardDFS(cur, cur);
}

算法对比分析：

2. 缩点技术的艺术

获得强连通分量后，缩点是将复杂图简化为DAG的关键步骤。以洛谷P3387为例，我们需要：

1. 合并点权：将同一SCC内所有节点的权值累加到代表元

cpp复制for(int i=1; i<=n; ++i) 
    if(scc[i] != i) 
        val[scc[i]] += val[i];

2. 重建DAG边：保留不同SCC之间的原始边

cpp复制unordered_map<int, vector<int>> dagGraph;
for(int i=1; i<=m; ++i) {
    int u = from[i], v = to[i];
    if(scc[u] != scc[v]) 
        dagGraph[scc[u]].push_back(scc[v]);
}

缩点后的图性质验证：

• 无环性：假设存在环，则环上节点应属同一SCC，矛盾
• 偏序关系：自然形成拓扑排序结构

3. DAG上的动态规划策略

在缩点得到的DAG上，我们可采用两种经典方法求解最大路径和：

3.1 记忆化搜索实现

cpp复制vector<int> memo(n+1, -1);

function<int(int)> dfs = [&](int cur) -> int {
    if(memo[cur] != -1) return memo[cur];
    int max_path = 0;
    for(int nex : dagGraph[cur]) 
        max_path = max(max_path, dfs(nex));
    return memo[cur] = val[cur] + max_path;
};

int result = 0;
for(int i=1; i<=n; ++i)
    if(scc[i] == i) 
        result = max(result, dfs(i));

3.2 拓扑排序+DP

cpp复制// 拓扑排序（Kahn算法）
vector<int> inDegree(n+1);
queue<int> q;
for(auto &[u, neighbors] : dagGraph)
    for(int v : neighbors) 
        inDegree[v]++;

for(int i=1; i<=n; ++i)
    if(scc[i]==i && inDegree[i]==0)
        q.push(i);

// DP过程
vector<int> dp(n+1);
while(!q.empty()) {
    int u = q.front(); q.pop();
    dp[u] += val[u];
    for(int v : dagGraph[u]) {
        dp[v] = max(dp[v], dp[u]);
        if(--inDegree[v] == 0)
            q.push(v);
    }
}

性能对比：

4. 实战优化技巧

4.1 数据结构选择

• 使用unordered_map存储DAG比vector更节省空间
• 点权合并时可采用路径压缩思想：

cpp复制int getScc(int x) {
    return scc[x] == x ? x : scc[x] = getScc(scc[x]);
}

4.2 调试要点

1. SCC验证：检查是否所有节点都被正确标记
2. 缩点验证：确保新图边数不超过原始图
3. DP初始化：代表元点权必须正确初始化

4.3 竞赛模板优化

将Tarjan算法封装为可重用组件：

cpp复制struct SCC {
    vector<vector<int>> graph;
    vector<int> dfn, low, scc;
    stack<int> stk;
    int timestamp = 1;
    
    SCC(int n): graph(n+1), dfn(n+1), low(n+1), scc(n+1) {}
    
    void addEdge(int u, int v) { graph[u].push_back(v); }
    
    void run() {
        for(int i=1; i<graph.size(); ++i)
            if(!dfn[i]) tarjan(i);
    }
    // ... tarjan实现 ...
};

在解决类似P3387的问题时，这套模板能节省约30%的编码时间。实际比赛中，建议根据题目特点灵活调整缩点后的处理策略——有些问题可能需要统计入度/出度，有些则需在DAG上运行最短路算法。