尽管是缩点的习题，思路也是在看了题解后才明白的。
首先，每个强连通分量内的点都是一定互通的，也就是可以完全把这里面的边都跑满，摘掉所有能摘的蘑菇。那么，考虑给每一个强连通分量化为的新点一个点权,代表摘光蘑菇能拿到的边权之和。然后，在新点之间保留原来的桥及其初始权值。（每一个桥一定只能跑一遍，否则说明这两个本应单向通行的分量之间有返回的路径，则二者可构成一个更大的分量。这个结论正是tarjan算法求有向图dcc的核心原理。）现在得到了一张新图，问题在于如何在一张包含点权、边权的DAG上求起始于定点的最长路。
这个问题可以用拓扑序DP求解。在dp求最长路的基础上，为了保证一定由s点所在分量起始，我们把该分量初状态设为其权值，其余点都赋初值为INT_MIN。
这样dp得到的最长路一定是基于f[dcc[s]]求出的。
另外，用SPFA算法来跑点权、边权交叉的最长路是可行的，不过应用于本题复杂度不如dp优秀。
-----------------------------------------
在参阅题解后，基于一开始跑偏的假设，笔者又想到了一个貌似更优的解法。
实际上我们并不需要考虑原图的所有节点。容易想到，从给定起点向外作一轮tarjan算法（dfs）不能达到的点，在新图中也不可能走到。因此，我们只需要对图中以s为原点作一次tarjan能够跑到的几个连通分量进行缩点，这样能够到达的区域就变成了一棵以s为根的树。我们只需要再作一次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;
- }
原文地址：https://www.cnblogs.com/TY02/p/11107925.html
时间： 2024-10-16 20:11:17