缩点+DP

题目背景

 

题目描述

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

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

输入输出格式

输入格式：

 

第一行，n,m

第二行，n个整数，依次代表点权

第三至m+2行，每行两个整数u,v，表示u->v有一条有向边

 

输出格式：

 

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

 

输入输出样例

输入样例#1： 复制

2 2
1 1
1 2
2 1

输出样例#1： 复制

2

说明

n<=10^4,m<=10^5,点权<=1000

算法：Tarjan缩点+DAGdp

思路：先缩点，因为缩点的要求就是强联通，在这个题目中，如果存在强联通，那么如果经过其中的一个点那么该强连通都会经过，所以我们直接缩点，然后点权相加即可，缩点完成后再重新建立图，然后使用拓扑排序＋dp做即可求出最大点权，至于为什么是拓扑排序其实可以想一想，起点一定是一个入度为0的点（缩点后），终点也一定是一个出度为0的点，那么我们直接从入度为0的点开始计算，然后dp即可，dp的过程即时选与不选的过程，求出最大值，然后输出

 

#include<iostream>
#include<queue>
using namespace std;
const int maxn = 100010;
int head[maxn], dp[maxn], dfn[maxn], c[maxn], inq[maxn], low[maxn], cnt = 1, total, index, belong[maxn], vis[maxn], Stack[maxn];
int n, m, t, a, b;
struct node{
    int from;
    int to;
    int next;
}edge[maxn];

void add(int u, int v) {
    edge[cnt].from = u;
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}

void tarjan(int u) {
    dfn[u] = low[u] = ++total;
    vis[u] = 1;
    Stack[++index] = u;
    for (int i = head[u]; i != 0; i = edge[i].next) {
        int v = edge[i].to;
        if (!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        } else if (vis[v]) {
            low[u] = min(low[u], dfn[v]);
        }
    }
    if (low[u] == dfn[u]) {
        int temp;
        do {
            temp = Stack[index--];
            belong[temp] = u;
            vis[temp] = 0;
            if (temp == u) break;
            c[u] += c[temp];
        } while (Stack[index + 1] != u);
    }
}

int topologicalSort(){
    queue<int> q;
    for (int i = 1; i <= n; i++) {
        if (!inq[i] && belong[i] == i) {
            q.push(i);
            dp[i] = c[i];
        }
    }
    while (!q.empty()) {
        int temp = q.front();
        q.pop();
        for (int i = head[temp]; i != 0; i = edge[i].next) {
            int v = edge[i].to;
            dp[v] = max(dp[v], dp[temp] + c[v]);
            inq[v]--;
            if (!inq[v]) {
                q.push(v);
            }
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        ans = max(ans, dp[i]);
    }
    return ans;
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> c[i];
    for (int i = 0; i < m; i++) {
        cin >> a >> b;
        add(a, b);
    }
    for (int i = 1; i <= n; i++) {
        if (!dfn[i]) tarjan(i);
    }
    cnt = 1;
    fill(head, head + maxn, 0);
    for (int i = 1; i <= m; i++) {
        int x = belong[edge[i].from];
        int y = belong[edge[i].to];
        if (x != y) {
            add(x, y);
            inq[y]++;
        }
    }
    int ans = topologicalSort();
    cout << ans << endl;
}