HDU 6201 树形DP 或 最长路

简略题意：
$n$个节点，$n-1$条边，每个节点有一个点权$v[i]$，代表这个点的物品售价。
每条边有一个权值，代表走这条路的花费。问从任意一点购买，在任意一点卖出的最高收益是多少。

解法$1$：因为我们不知道从哪点出发到哪点终止。因此虚拟一个起点，一个终点，起点连接所有的节点，权值为$-v[i]$，代表买入的代价。
所有节点再连向终点，权值为$v[i]$，代表卖出的收益。每条边的权值置为负，代表走这条路需要花费代价。跑一次最长路即可。

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int maxn = 110000;

int t;
int n;
int val[maxn];
vector<pair<int, int>> G[maxn];
int dp[maxn];
int dis[maxn];
int vis[maxn];

void init() {
    for(int i = 0; i < maxn; i++) G[i].clear();
    memset(dp, 0x3f3f3f3f, sizeof dp);
    memset(dis, -0x3f3f3f3f, sizeof dis);
    memset(vis, 0, sizeof vis);
}

void spfa() {
    dis[0] = 0;
    vis[0] = 1;
    queue<int> q;
    q.push(0);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = 0;
        for(int i = 0; i < G[u].size(); i++) {
            int v = G[u][i].first, w = G[u][i].second;
            if(dis[v] < dis[u] + w) {
                dis[v] = dis[u] + w;
                if(!vis[v]) {
                    q.push(v);
                    vis[v] = 1;
                }
            }
        }
    }
}

int main() {
    scanf("%d", &t);
    while(t--) {
        init();
        scanf("%d", &n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &val[i]);
            G[0].push_back({i, -val[i]});
            G[i].push_back({n+1, val[i]});
        }
        for(int i = 1; i < n; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            G[u].push_back({v, -w});
            G[v].push_back({u, -w});
        }
        spfa();
        cout<<dis[n+1]<<endl;
    }
    return 0;
}

解法$2$：
显然这是一棵树，最优的答案必然是一个父亲节点到一个儿子节点，因此跑树形DP即可。
对于$dp[u]$,代表当前在$u$节点，我们已经购买了一本书，所需要花费的最小代价。
显然$dp[u]$从子树节点转移过来，或者从父亲节点转移过来。
答案即为$dp[i] + v[i], i \in [1, n]$。

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int maxn = 110000;

int t;
int n;
int val[maxn];
vector<pair<int, int>> G[maxn];
int dp[maxn];

void init() {
    for(int i = 0; i < maxn; i++) G[i].clear();
    memset(dp, 0x3f3f3f3f, sizeof dp);
}

void dfs1(int u, int fa) {
    dp[u] = -val[u];
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].first;
        int w = G[u][i].second;
        if(v == fa) continue;
        dfs1(v, u);
    }
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].first;
        int w = G[u][i].second;
        if(v == fa) continue;
        dp[u] = max(dp[u], dp[v] - w);
    }
}

void dfs2(int u, int fa, int w) {
    if(fa != -1) {
        dp[u] = max(dp[u], dp[fa] - w);
    }
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].first;
        if(v == fa) continue;
        dfs2(v, u, G[u][i].second);
    }
}

int main() {
    scanf("%d", &t);
    while(t--) {
        init();
        scanf("%d", &n);
        for(int i = 1; i <= n; i++) scanf("%d", &val[i]);
        for(int i = 1; i < n; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            G[u].push_back({v, w});
            G[v].push_back({u, w});
        }
        dfs1(1, -1);
        dfs2(1, -1, 0);
        int ans = 0;
        for(int i = 1; i <= n; i++)
            ans = max(ans, dp[i]+val[i]);
        cout<<ans<<endl;
    }
    return 0;
}