codeforces 894E

原創

Site1997

2020-02-21 10:40

（強連通+dp）
題意：給定一個單向邊的圖(n,m<106) ，每條路上都有wi 個寶石，每次經過一條路可將這條邊上的寶石撿完，第i 次經過該路，能撿到的寶石數量爲wi−i∗(i+1)/2 ，直到寶石數目爲0 。問從指定一點出發，最多能撿到多少寶石？

思路：由於每條路可以走很多遍，那麼最好情況下是一直將每這條路重複走，直至該路上寶石被撿完。於是想到只有圖中出現環可以這樣，於是想到了tarjan縮點。縮點後，對於強連通內部的點來說，最關鍵的是想到：無論從哪一點出發，終點在哪裏，在內部能撿到的寶石數目都是相同的，然後對於每個強連通計數即可；而對於強連通外部的DAG上，利用dp或者記憶化搜索的方式求解全局最優就好。

時間複雜度：縮點和計數的複雜度均爲O(n+m)

#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <stack>
#define LL long long

using namespace std;
const int maxn = 1000050;
const int inf = 0x3f3f3f3f;

// basic structure
int head[maxn], cnt;
struct edge{
    int to, next, w;
}edge[maxn];
void add_edge(int u, int v, int w) {
    edge[cnt].to = v; edge[cnt].w = w;
    edge[cnt].next = head[u]; head[u] = cnt ++;
}
// old_graph
stack<int> s;
int scc, dfs_clock;
int DFN[maxn], low[maxn], blg[maxn]; //Depth First Number, low, belong
bool instack[maxn]; //vis
// new_graph
LL dp[maxn], dis[maxn];
int new_edge[maxn][3], new_cnt;

void init_graph() {
    cnt = 0;
    memset(head, -1, sizeof(head));
}

void init_scc(int n) {
    scc = dfs_clock = 0;
    memset(DFN, -1, sizeof(DFN));
    memset(instack, 0, sizeof(instack));
    while(!s.empty()) s.pop();
}

void tarjan(int u) {
    int v = 0;
    DFN[u] = low[u] = dfs_clock ++;
    s.push(u);
    instack[u] = 1;
    for(int k=head[u]; k!=-1; k=edge[k].next) {
        v = edge[k].to;
        if(DFN[v] == -1)
            tarjan(v),low[u] = min(low[u],low[v]);
        else if(instack[v])
            low[u] = min(low[u],DFN[v]);
    }
    if(low[u] == DFN[u]) {
        scc ++;
        do {
            v = s.top(); s.pop();
            blg[v] = scc;
            instack[v] = 0;
        }
        while(v != u);
    }
}

void rebuild_graph(int n) {
    new_cnt = 0;
    for(int u=1; u<=n; u++) {
        for(int k=head[u]; k!=-1; k=edge[k].next) {
            int v = edge[k].to, w = edge[k].w;
            if(blg[u] == blg[v]) {
                int t = floor((-1+sqrt(1+8*w))/2); // n
                dp[blg[u]] += (LL)(t+1)*w - (LL)t*(t+1)*(t+2)/6;
            }
            else {
                new_edge[new_cnt][0] = blg[u], new_edge[new_cnt][1] = blg[v];
                new_edge[new_cnt][2] = w; new_cnt ++;
            }
        }
    }
    init_graph();
    for(int i=0; i<new_cnt; i++)
        add_edge(new_edge[i][0], new_edge[i][1], new_edge[i][2]);
}

LL dfs(int u) {
    if(dis[u] != -1) return dis[u];
    LL ret = dp[u];
    for(int k=head[u]; k!=-1; k=edge[k].next) {
        int v = edge[k].to, w = edge[k].w;
        ret = max(ret, dp[u] + (LL)w + dfs(v));
    }
    dis[u] = ret;
    return ret;
}

int main() {
    //freopen("test.txt","r",stdin);
    int n, m, start;
    scanf("%d%d",&n,&m);
    init_graph();
    init_scc(n);
    while(m --) {
        int u, v, w;
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u, v, w);
    }
    scanf("%d",&start);
    for(int i=1; i<=n; i++)
        if(DFN[i] == -1) tarjan(i);
    rebuild_graph(n);
    for(int i=1; i<=scc; i++)
        dis[i] = -1;
    LL ans = dfs(blg[start]);
    printf("%I64d\n",ans);
    return 0;
}