树形dp ---- 2018年杭电多校第二场 H travel

题目大意：

就是给你一个带点权的树，找到3条独立互不相交的路径使得权值和最大

---

解题思路：

很经典的树形dp

我们设$dp[root][j][k]$表示在$root$这个子树里面选出了$j$条路径，其中我们有$k$条路径经过了$root$。

$j\in [0,4],k\in [0,2]$
看代码注释

#include <bits/stdc++.h>
#define mid ((l + r) >> 1)
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define f first
#define s second
#define endl '\n'
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 9;
const int maxn = 500010;
const long double eps = 1e-5;
const int EPS = 500 * 500;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
template<typename T> void read(T &x) {
   x = 0;char ch = getchar();ll f = 1;
   while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
   while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
   read(first);
   read(args...);
}
int n;
vector<int> G[maxn];
ll dp[maxn][5][3];
int node[maxn];
// dp i, j, k 表示只考虑i为子树里面的情况下，里面选了j条 路径 并且其中有k条路径是连在i上面的最大权值是多少？
// 因为最多是三条链那么对于i而言最多就4条竖链
// k最多久2
inline void dfs(int u, int fa) {
    dp[u][0][0] = 0;
    dp[u][1][1] = node[u];
    for(auto v : G[u]) {
        if(v == fa) continue;
        dfs(v,u);
        for(int j = 4; j >= 1; j --) 
          for(int k = j-1; k >= 0; k --) { // 枚举从新加的子树里面取多少条路径路径里面
              ll tmp = -LLF;
              // u里面取k条，那么剩下的j-k条就是从新的子树里面取
              tmp = max(tmp,dp[u][k][2] + dp[v][j-k][0]);
              tmp = max(tmp,dp[u][k][2] + dp[v][j-k][1]);
              // 这里加1的原因是有2个路径经过k的时候本质是把两个路径合并成了一条
              tmp = max(tmp,dp[u][k+1][2] + dp[v][j-k][2]);
              tmp = max(tmp,dp[u][k][2] + dp[v][j-k+1][2]);
			  // 那么本质上你要额外加一条路径 可以来着你自己也可以是新的子树
			  
              tmp = max(tmp,dp[u][k][1] + dp[v][j-k][1]);
              dp[u][j][2] = max(tmp,dp[u][j][2]);
              
              tmp = -LLF;
              tmp = max(tmp,dp[u][k][1] + dp[v][j-k][0]);
              tmp = max(tmp,dp[u][k][1] + dp[v][j-k][1]);
              tmp = max(tmp,dp[u][k+1][1] + dp[v][j-k][2]);  
              tmp = max(tmp,dp[u][k][1] + dp[v][j-k+1][2]);  
              tmp = max(tmp,dp[u][k][0] + dp[v][j-k][1] + node[u]);
              dp[u][j][1] = max(tmp,dp[u][j][1]);

              tmp = -LLF;
              tmp = max(tmp,dp[u][k][0] + dp[v][j-k][0]);
              tmp = max(tmp,dp[u][k][0] + dp[v][j-k][1]);
              tmp = max(tmp,dp[u][k+1][0] + dp[v][j-k][2]);
              tmp = max(tmp,dp[u][k][0] + dp[v][j-k+1][2]);
              dp[u][j][0] = max(tmp,dp[u][j][0]);
          }  
    }
}

int main() {
    IOS;
    cin >> n;
    for(int i = 1; i <= n; ++ i) cin >> node[i];
    for(int i = 1; i < n; ++ i) {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    for(int i = 0; i <= n; ++ i)
      for(int j = 0; j <= 4; ++ j)
        for(int k = 0; k <= 2; ++ k)
          dp[i][j][k] = -LLF;
    dfs(1,0);
    cout << max(dp[1][4][2],max(dp[1][3][0],dp[1][3][1]));
    return 0;
}
/*
6
1 1 1 1 2 10
1 2
1 3
3 4
3 5
1 6
*/