题解：洛谷 P3387 缩点

【题目来源】

洛谷：P3387 【模板】缩点 - 洛谷

【题目描述】

给定一个 \(n\) 个点 \(m\) 条边有向图，每个点有一个权值，求一条路径，使路径经过的点权值之和最大。你只需要求出这个权值和。

允许多次经过一条边或者一个点，但是，重复经过的点，权值只计算一次。

【输入】

第一行两个正整数 \(n,m\)。

第二行 \(n\) 个整数，其中第 \(i\) 个数 \(a_i\) 表示点 \(i\) 的点权。

第三至 \(m+2\) 行，每行两个整数 \(u,v\)，表示一条 \(u\rightarrow v\) 的有向边。

【输出】

共一行，最大的点权之和。

【输入样例】

【输出样例】

【核心思想】

问题分析：给定一个 \(n\) 个点、\(m\) 条边的有向图，每个点有权值。需要找一条路径，使得路径经过的所有点的权值之和最大，重复经过的点权值只计算一次。由于可以多次经过点和边，若图中存在环，则环上所有点的权值都可以被完整获取。因此，问题等价于将每个强连通分量（SCC）缩成一个点，分量权值为内部所有点权之和，然后在缩点后的有向无环图（DAG） 上找一条权值和最大的路径（即DAG上的最长路）。
算法选择：
- Tarjan算法求强连通分量：线性时间找到所有SCC，并记录每个点所属的分量编号。
- 缩点建图：遍历原图每条边，若两端点属于不同SCC，则在缩点后的DAG中添加有向边。
- DAG上最长路（DP）：由于缩点后是DAG，可按拓扑序（或反拓扑序）进行动态规划。代码利用Tarjan生成的分量编号（从1开始递增），其顺序天然是逆拓扑序，因此从cnt到1遍历即可，状态转移为 \(dp[v] = \max(dp[v], dp[u] + sumW[v])\)，其中 \(sumW[v]\) 是分量 \(v\) 的总权值。
关键步骤：
- 读入与建图：读取 \(n, m\)，节点权值 \(w[1..n]\)，以及 \(m\) 条有向边，存入邻接表 e。
- Tarjan求SCC：对每个未访问节点运行 tarjan(u)，计算 dfn、low，将同一SCC的节点标记为 scc[u] = cnt，并累加分量总权值 nw[cnt] += w[u]。
- 缩点建DAG：遍历原图所有边 (u, v)，若 scc[u] != scc[v]，则在DAG中添加边 scc[u] -> scc[v]。
- 动态规划求最长路：
  - 初始化 dp[i] = 0。
  - 按分量编号从 cnt 到 1 递减遍历（因为该顺序为逆拓扑序）：
    - 若 dp[i] == 0，则 dp[i] = nw[i]。
    - 对每个后继 j，更新 dp[j] = max(dp[j], dp[i] + nw[j])。
  - 答案即为所有 dp[i] 的最大值。
时间/空间复杂度：
- 时间复杂度：\(O(n + m)\)，Tarjan 和 DP 均为线性。
- 空间复杂度：\(O(n + m)\)，存储原图、缩点后的图及辅助数组。
缩点 + DAG DP的核心思想：
- 强连通分量的压缩：在任意强连通分量中，从任意一点出发可到达分量内所有点，因此该分量内所有点的权值可以一次性获取，等价于一个“超级节点”，其权值为内部权值之和。
- DAG的可解性：缩点后图无环，最长路问题可通过拓扑序DP高效求解，避免了原图中环带来的复杂性。
- 重复经过的处理：由于原图允许重复走边和点，但权值只计一次，缩点后路径经过每个SCC最多一次，DP自然满足该要求。
- 适用于带权有向图上的“最大权值路径（可重复点）”问题，常见于网络流、传播路径等场景。

【算法标签】

普及+ #强连通分量

【代码详解】

#include <bits/stdc++.h>
using namespace std;

const int N = 10005;        // 最大节点数

int n, m;                  // n:节点数, m:边数
vector<int> e[N];          // 原图的邻接表
vector<int> ne[N];         // 缩点后DAG的邻接表

int dfn[N];                // DFS序（时间戳）
int low[N];                // 通过回边能到达的最小DFN值
int tot;                   // 时间戳计数器

int stk[N];                // Tarjan算法栈
int instk[N];              // 标记节点是否在栈中
int top;                   // 栈顶指针

int scc[N];                // 存储每个节点所属的强连通分量编号
int cnt;                   // 强连通分量计数器

int w[N];                  // 原图中每个节点的权值
int nw[N];                 // 缩点后每个强连通分量的总权值
int dp[N];                 // 动态规划数组，dp[i]表示以分量i为终点的最大权值和

/**
 * Tarjan算法求强连通分量
 * @param x 当前节点
 */
void tarjan(int x)
{
    // 初始化当前节点的DFN和LOW值
    dfn[x] = low[x] = ++tot;

    // 将当前节点压入栈并标记
    stk[++top] = x;
    instk[x] = 1;

    // 遍历当前节点的所有邻接节点
    for (int y : e[x])
    {
        // 如果邻接节点y未被访问
        if (!dfn[y])
        {
            tarjan(y);                      // 递归访问y
            low[x] = min(low[x], low[y]);   // 更新low值
        }
        // 如果y已被访问且在栈中（回边）
        else if (instk[y])
        {
            low[x] = min(low[x], dfn[y]);   // 通过回边更新low值
        }
    }

    // 如果当前节点是强连通分量的根
    if (dfn[x] == low[x])
    {
        int y;
        ++cnt;  // 增加强连通分量计数

        // 弹出栈中节点直到遇到当前节点
        do
        {
            y = stk[top--];     // 弹出栈顶节点
            instk[y] = 0;       // 标记节点已出栈
            scc[y] = cnt;       // 记录节点所属的强连通分量
        }
        while (y != x);         // 直到弹出当前节点
    }
}

int main()
{
    // 输入节点数和边数
    cin >> n >> m;

    int a, b, ans = 0;

    // 输入每个节点的权值
    for (int i = 1; i <= n; i++)
    {
        cin >> w[i];
    }

    // 输入图的边信息
    for (int i = 1; i <= m; i++)
    {
        cin >> a >> b;
        e[a].push_back(b);  // 添加有向边a->b
    }

    // 对每个未访问的节点执行Tarjan算法
    for (int i = 1; i <= n; i++)
    {
        if (!dfn[i])
        {
            tarjan(i);
        }
    }

    // 构建缩点后的DAG（有向无环图）
    for (int x = 1; x <= n; x++)
    {
        // 累加当前强连通分量的总权值
        nw[scc[x]] += w[x];

        // 处理原图中的每条边
        for (int y : e[x])
        {
            a = scc[x];  // 源节点所在的分量
            b = scc[y];  // 目标节点所在的分量

            // 如果两个节点不在同一个强连通分量中，添加边
            if (a != b)
            {
                ne[a].push_back(b);
            }
        }
    }

    // 动态规划：在DAG上求最长路径（拓扑排序顺序为cnt到1）
    for (int x = cnt; x >= 1; x--)
    {
        // 如果当前分量还没有被访问过，初始化dp值
        if (dp[x] == 0)
        {
            dp[x] = nw[x];
        }

        // 更新所有后继节点的dp值
        for (int y : ne[x])
        {
            dp[y] = max(dp[y], dp[x] + nw[y]);
        }
    }

    // 在所有分量中寻找最大权值和
    for (int i = 1; i <= cnt; i++)
    {
        ans = max(ans, dp[i]);
    }

    // 输出最大权值和
    cout << ans << endl;

    return 0;
}

【运行结果】

posted @ 2026-09-01 22:41 团爸讲算法阅读(22) 评论(0) 收藏举报

刷新页面返回顶部

题解：洛谷 P3387 缩点

普及+ #强连通分量

公告