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

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

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

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

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

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

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

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

1. #include 
2. #include 
3. #include 
4. #include 
5. #define rint register int
6. #define BUG putchar('*')
7. #define maxn 80010
8. #define maxm 200010
9. using namespace std;
10. struct E {
11. int to, nxt, w;
12. double op;
13. } edge[maxm], edge2[maxm];
14. int n, m, st;
15. int head[maxn], top;
16. inline void insert(int u, int v, int w, double op) {
17. edge[++top] = (E) {v, head[u], w, op};
18. head[u] = top;
19. }
20. int dfn[maxn], low[maxn], sta[maxn], stp, timer;
21. bool ins[maxn], vis[maxn];
22. int cnt, c[maxn];
23. void dfs(int u) {
24. dfn[u] = low[u] = ++timer;
25. sta[++stp] = u;
26. ins[u] = true;
27. vis[u] = true;//  仅搜一次标记所答点
28. for (rint i = head[u]; i; i = edge[i].nxt) {
29. int v = edge[i].to;
30. if (!dfn[v]) {
31. dfs(v);
32. low[u] = min(low[u], low[v]);
33. } else if (ins[v])
34. low[u] = min(low[u], dfn[v]);
35. }
36. if (dfn[u] == low[u]) {
37. ++cnt;
38. int x;
39. do {
40. x = sta[stp--];
41. ins[x] = false;
42. c[x] = cnt;
43. } while (x != u);
44. }
45. }
46. void tarjan() {
47. //  for (int i = 1; i <= n; ++i) //  全图tarjan
48. //      if (!dfn[i]) dfs(i);
49. dfs(st);
50. }
51. int head2[maxn], top2;
52. inline void insert2(int u, int v, int w) {
53. edge2[++top2] = (E) {v, head2[u], w, 0};
54. head2[u] = top2;
55. }
56. int val[maxn], ind[maxn];
57. void build() {
58. rint v, w;
59. for (rint u = 1; u <= n; ++u)
60. if (vis[u])//  仅考虑一次搜索 缩点得树
61. for (int i = head[u]; i; i = edge[i].nxt) {
62. v = edge[i].to;
63. w = edge[i].w;
64. if (c[u] == c[v]) {
65. register double op = edge[i].op;
66. while (w)
67. val[c[u]] += w, w *= op;
68. } else
69. insert2(c[u], c[v], w), ind[c[v]]++;
70. }
71. }
72. //************************
73. /*  DAG 拓扑序dp
74. int f[maxn];
75. queue q;
76. int dp() {
77. int ans = val[c[st]];
78. for (int i = 1; i <= cnt; ++i) {
79. f[i] = INT_MIN;
80. if (!ind[i]) q.push(i);
81. }
82. f[c[st]] = val[c[st]];
83. while (!q.empty()) {
84. int u = q.front(); q.pop();
85. for (int i = head2[u]; i; i = edge2[i].nxt) {
86. int v = edge2[i].to;
87. f[v] = max(f[v], f[u] + edge2[i].w + val[v]);
88. --ind[v];
89. if (!ind[v])
90. ans = max(ans, f[v]), q.push(v);
91. }
92. }
93. return ans;
94. }
95. */
96. //**************************
97. /*  spfa
98. bool inq[maxn];
99. int dist[maxn];
100. int spfa() {
101. for (int i = 1; i <= cnt; ++i)
102. dist[i] = INT_MIN;
103. dist[c[st]] = val[c[st]];
104. queue q;
105. inq[c[st]] = true, q.push(c[st]);
106. while (!q.empty()) {
107. int u = q.front();
108. q.pop(), inq[u] = false;
109. for (int i = head2[u]; i; i = edge2[i].nxt) {
110. int v = edge2[i].to;
111. if (dist[v] < dist[u] + edge2[i].w + val[v]) {
112. dist[v] = dist[u] + edge2[i].w + val[v];
113. if (!inq[v])
114. q.push(v), inq[v] = true;
115. }
116. }
117. }
118. int ans = 0;
119. for (int i = 1; i <= cnt; ++i)
120. ans = max(ans, dist[i]);
121. return ans;
122. }*/
123. //***************************
124. int ans;
125. void dfs2(int u, int dist) {
126. dist += val[u];
127. if (!head2[u]) {
128. ans = max(ans, dist);
129. return;
130. }
131. for (int i = head2[u]; i; i = edge2[i].nxt)
132. dfs2(edge2[i].to, dist + edge2[i].w);
133. }
134. int main() {
135. scanf("%d %d", &n, &m);
136. int u, v, w;
137. double op;
138. for (rint i = 1; i <= m; ++i) {
139. scanf("%d %d %d %lf", &u, &v, &w, &op);
140. insert(u, v, w, op);
141. }
142. scanf("%d", &st);
143. tarjan();
144. build();
145. //  printf("%d", spfa());
146. //  printf("%d", dp());
147. dfs2(c[st], 0);
148. printf("%d", ans);
149. return 0;
150. }

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