题解：洛谷 P3387 【模板】缩点

【题目来源】

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

【题目描述】

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

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

【输入】

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

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

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

【输出】

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

【输入样例】

2 2
1 1
1 2
2 1

【输出样例】

2

【算法标签】

《洛谷 P3387 缩点》 #图论# #拓扑排序# #强连通分量# #Tarjan#

【代码详解】

#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;
}

【运行结果】

2 2
1 1
1 2
2 1
2