[BZOJ1179] [Apio2009]Atm（tarjan缩点 + spfa）

传送门

题意

N个点M条边的有向图

每个点有点权

从某一个结点出发

问能获得的最大点权和

一个点的点权最多被计算一次

N<=500000 M<=500000

思路

先tarjan缩点，然后就形成一个dag，无环，所以直接spfa求最长路就行。

也可以先缩点，然后拓扑排序 + dp 搞。

代码

#include <map>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <iostream>

const int MAXN = 500001;
int n, m, s, p, cnt, cnt1, tim, sz, ans;
int head[MAXN], to[MAXN], next[MAXN], head1[MAXN], to1[MAXN], next1[MAXN];
int a[MAXN], dfn[MAXN], low[MAXN], belong[MAXN], val[MAXN], dis[MAXN];
bool ins[MAXN], vis[MAXN];
std::map <int, int> map1[MAXN];
std::stack <int> S;
std::queue <int> q;

inline int max(int x, int y)
{
    return x > y ? x : y;
}

inline int min(int x, int y)
{
    return x < y ? x : y;
}

inline int read()
{
    int f = 1, x = 0;
    char ch = getchar();
    for(; !isdigit(ch); ch = getchar()) if(ch == '-') f = -1;
    for(; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
    return f * x;
}

inline void add(int x, int y)
{
    to[cnt] = y;
    next[cnt] = head[x];
    head[x] = cnt++;
}

inline void add1(int x, int y)
{
    to1[cnt1] = y;
    next1[cnt1] = head1[x];
    head1[x] = cnt1++;
}

inline void dfs(int u)
{
    int i, v;
    S.push(u);
    ins[u] = 1;
    dfn[u] = low[u] = ++tim;
    for(i = head[u]; i ^ -1; i = next[i])
    {
        v = to[i];
        if(!dfn[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if(ins[v]) low[u] = min(low[u], dfn[v]);
    }
    if(!(low[u] ^ dfn[u]))
    {
        sz++;
        do
        {
            v = S.top();
            S.pop();
            belong[v] = sz;
            ins[v] = 0;
        }
        while(u ^ v);
    }
}

inline void spfa()
{
    int i, u, v;
    dis[belong[s]] = val[belong[s]];
    q.push(belong[s]);
    vis[belong[s]] = 1;
    while(!q.empty())
    {
        u = q.front();
        q.pop();
        vis[u] = 0;
        for(i = head1[u]; i ^ -1; i = next1[i])
        {
            v = to1[i];
            if(dis[v] < dis[u] + val[v])
            {
                dis[v] = dis[u] + val[v];
                if(!vis[v])
                {
                    vis[v] = 1;
                    q.push(v);
                }
            }
        }
    }
}

int main()
{
    int i, x, y, u, v;
    n = read();
    m = read();
    memset(head, -1, sizeof(head));
    memset(head1, -1, sizeof(head1));
    for(i = 1; i <= m; i++)
    {
        x = read();
        y = read();
        add(x, y);
    }
    for(i = 1; i <= n; i++) a[i] = read();
    s = read();
    p = read();
    dfs(s);
    for(i = 1; i <= n; i++) val[belong[i]] += a[i];
    for(u = 1; u <= n; u++)
        for(i = head[u]; i ^ -1; i = next[i])
        {
            v = to[i];
            if(belong[u] ^ belong[v] && !map1[belong[u]][belong[v]])
                map1[belong[u]][belong[v]] = 1, add1(belong[u], belong[v]);
        }
    spfa();
    for(i = 1; i <= p; i++)
    {
        x = read();
        ans = max(ans, dis[belong[x]]);
    }
    printf("%d
", ans);
    return 0;
}