Luogu P2656 采蘑菇

尽管是缩点的习题，思路也是在看了题解后才明白的。

首先，每个强连通分量内的点都是一定互通的，也就是可以完全把这里面的边都跑满，摘掉所有能摘的蘑菇。那么，考虑给每一个强连通分量化为的新点一个点权,代表摘光蘑菇能拿到的边权之和。然后，在新点之间保留原来的桥及其初始权值。（每一个桥一定只能跑一遍，否则说明这两个本应单向通行的分量之间有返回的路径，则二者可构成一个更大的分量。这个结论正是tarjan算法求有向图dcc的核心原理。）现在得到了一张新图，问题在于如何在一张包含点权、边权的DAG上求起始于定点的最长路。

这个问题可以用拓扑序DP求解。在dp求最长路的基础上，为了保证一定由s点所在分量起始，我们把该分量初状态设为其权值，其余点都赋初值为INT_MIN。

这样dp得到的最长路一定是基于f[dcc[s]]求出的。

另外，用SPFA算法来跑点权、边权交叉的最长路是可行的，不过应用于本题复杂度不如dp优秀。-----------------------------------------

在参阅题解后，基于一开始跑偏的假设，笔者又想到了一个貌似更优的解法。

实际上我们并不需要考虑原图的所有节点。容易想到，从给定起点向外作一轮tarjan算法（dfs）不能达到的点，在新图中也不可能走到。因此，我们只需要对图中以s为原点作一次tarjan能够跑到的几个连通分量进行缩点，这样能够到达的区域就变成了一棵以s为根的树（8月20日订正：这里的“树”更严谨的说法是“树形图”）。我们只需要再作一次dfs求出最深叶节点的深度即可。

(注：以下代码注释分部分为除最后一种思路的其余解法，仅供参考）

#include <cstdio>
#include <iostream>
#include <queue>
#include <climits>
#define rint register int
#define BUG putchar('*')
#define maxn 80010
#define maxm 200010
using namespace std;

struct E {
    int to, nxt, w;
    double op;
} edge[maxm], edge2[maxm];
int n, m, st;
int head[maxn], top;
inline void insert(int u, int v, int w, double op) {
    edge[++top] = (E) {v, head[u], w, op};
    head[u] = top;
}
int dfn[maxn], low[maxn], sta[maxn], stp, timer;
bool ins[maxn], vis[maxn];
int cnt, c[maxn];
void dfs(int u) {
    dfn[u] = low[u] = ++timer;
    sta[++stp] = u;
    ins[u] = true;
    vis[u] = true;//  仅搜一次标记所答点
    for (rint i = head[u]; i; i = edge[i].nxt) {
        int v = edge[i].to;
        if (!dfn[v]) {
            dfs(v);
            low[u] = min(low[u], low[v]);
        } else if (ins[v])
            low[u] = min(low[u], dfn[v]);
    }
    if (dfn[u] == low[u]) {
        ++cnt;
        int x;
        do {
            x = sta[stp--];
            ins[x] = false;
            c[x] = cnt;
        } while (x != u);
    }
}
void tarjan() {
//  for (int i = 1; i <= n; ++i) //  全图tarjan
//      if (!dfn[i]) dfs(i);
    dfs(st);
}
int head2[maxn], top2;
inline void insert2(int u, int v, int w) {
    edge2[++top2] = (E) {v, head2[u], w, 0};
    head2[u] = top2;
}
int val[maxn], ind[maxn];
void build() {
    rint v, w;
    for (rint u = 1; u <= n; ++u)
        if (vis[u])//  仅考虑一次搜索 缩点得树
        for (int i = head[u]; i; i = edge[i].nxt) {
            v = edge[i].to;
            w = edge[i].w;
            if (c[u] == c[v]) {
                register double op = edge[i].op;
                while (w)
                    val[c[u]] += w, w *= op;
            } else
                insert2(c[u], c[v], w), ind[c[v]]++;
        }
}
//************************
/*  DAG 拓扑序dp
int f[maxn];
queue<int> q;
int dp() {
    int ans = val[c[st]];
    for (int i = 1; i <= cnt; ++i) {
        f[i] = INT_MIN;
        if (!ind[i]) q.push(i);
    }
    f[c[st]] = val[c[st]];
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int i = head2[u]; i; i = edge2[i].nxt) {
            int v = edge2[i].to;
            f[v] = max(f[v], f[u] + edge2[i].w + val[v]);
            --ind[v];
            if (!ind[v])
                ans = max(ans, f[v]), q.push(v);
        }
    }
    return ans;
}
*/
//**************************
/*  spfa
bool inq[maxn];
int dist[maxn];
int spfa() {
    for (int i = 1; i <= cnt; ++i)
        dist[i] = INT_MIN;
    dist[c[st]] = val[c[st]];
    queue<int> q;
    inq[c[st]] = true, q.push(c[st]);
    while (!q.empty()) {
        int u = q.front();
        q.pop(), inq[u] = false;
        for (int i = head2[u]; i; i = edge2[i].nxt) {
            int v = edge2[i].to;
            if (dist[v] < dist[u] + edge2[i].w + val[v]) {
                dist[v] = dist[u] + edge2[i].w + val[v];
                if (!inq[v])
                    q.push(v), inq[v] = true;
            }
        }
    }
    int ans = 0;
    for (int i = 1; i <= cnt; ++i)
        ans = max(ans, dist[i]);
    return ans;
}*/
//***************************
int ans;
void dfs2(int u, int dist) {
    dist += val[u];
    if (!head2[u]) {
        ans = max(ans, dist);
        return;
    }
    for (int i = head2[u]; i; i = edge2[i].nxt)
        dfs2(edge2[i].to, dist + edge2[i].w);
}
int main() {
    scanf("%d %d", &n, &m);
    int u, v, w;
    double op;
    for (rint i = 1; i <= m; ++i) {
        scanf("%d %d %d %lf", &u, &v, &w, &op);
        insert(u, v, w, op);
    }
    scanf("%d", &st);
    tarjan();
    build();
//  printf("%d", spfa());
//  printf("%d", dp());
    dfs2(c[st], 0);
    printf("%d", ans);
    return 0;
}

 这个题最大的收获是发现有向图缩点总跟DAG上的topo+DP有联系。按拓扑序遍历到某一点u，意味u点所有的入点都已经对其完成了更新，此时u点的状态满足无后效性。以及在DAG上求解始于某点的最长路径时，对f数组的特殊处理。