Codeforces743D Chloe and pleasant prizes（树形dp）

D. Chloe and pleasant prizes

Generous sponsors of the olympiad in which Chloe and Vladik took part allowed all the participants to choose a prize for them on their own. Christmas is coming, so sponsors decided to decorate the Christmas tree with their prizes.

They took n prizes for the contestants and wrote on each of them a unique id (integer from 1 to n). A gift i is characterized by integer ai — pleasantness of the gift. The pleasantness of the gift can be positive, negative or zero. Sponsors placed the gift 1 on the top of the tree. All the other gifts hung on a rope tied to some other gift so that each gift hung on the first gift, possibly with a sequence of ropes and another gifts. Formally, the gifts formed a rooted tree with n vertices.

The prize-giving procedure goes in the following way: the participants come to the tree one after another, choose any of the remaining gifts and cut the rope this prize hang on. Note that all the ropes which were used to hang other prizes on the chosen one are not cut. So the contestant gets the chosen gift as well as the all the gifts that hang on it, possibly with a sequence of ropes and another gifts.

Our friends, Chloe and Vladik, shared the first place on the olympiad and they will choose prizes at the same time! To keep themselves from fighting, they decided to choose two different gifts so that the sets of the gifts that hang on them with a sequence of ropes and another gifts don't intersect. In other words, there shouldn't be any gift that hang both on the gift chosen by Chloe and on the gift chosen by Vladik. From all of the possible variants they will choose such pair of prizes that the sum of pleasantness of all the gifts that they will take after cutting the ropes is as large as possible.

Print the maximum sum of pleasantness that Vladik and Chloe can get. If it is impossible for them to choose the gifts without fighting, print Impossible.

Input

The first line contains a single integer n (1 ≤ n ≤ 2·105) — the number of gifts.

The next line contains n integers a1, a2, ..., an ( - 109 ≤ ai ≤ 109) — the pleasantness of the gifts.

The next (n - 1) lines contain two numbers each. The i-th of these lines contains integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the description of the tree's edges. It means that gifts with numbers ui and vi are connected to each other with a rope. The gifts' ids in the description of the ropes can be given in arbirtary order: vi hangs on ui or ui hangs on vi.

It is guaranteed that all the gifts hang on the first gift, possibly with a sequence of ropes and another gifts.

Output

If it is possible for Chloe and Vladik to choose prizes without fighting, print single integer — the maximum possible sum of pleasantness they can get together.

Otherwise print Impossible.

Example
input
8
0 5 -1 4 3 2 6 5
1 2
2 4
2 5
1 3
3 6
6 7
6 8
output
25
input
4
1 -5 1 1
1 2
1 4
2 3
output
2
input
1
-1
output
Impossible

题意：给你一棵树，每棵树的结点都有一个权值，问你任意两棵不相交的子树结点的和的最大值是多少。

解法：树形dp + DFS

本题其实就是一个极其巧妙的DFS

关键在于需要找到两棵不相交的子树并随时可以知道两者的和。

那么我们用dp[i]表示每个结点为根的树和所有其子树的最大值，一开始全部初始化为-inf

用sum[i]表示每个结点为根的树所有节点的值的和

每次dfs的时候进行实时更新。

这里有两种情况：

1）取某一个结点为根其下的两棵子树的最大值

2）取以改结点为根的子树的值。

每次dfs的时候，如果这个点是根结点，那么其dp值就等于sum值

否则的话 遍历其子结点

每次dfs回来的时候首先更新sum值加到根结点的sum中；

如果此时根结点的dp值已经被更新过了，意味着此时至少之前有一棵子树被求出来了

更新ans值为与根结点的dp值和子结点的dp值和的较大值（其实此时的根结点dp值还没被更新完全）

每次遍历完子结点，再用sum值去更新此时的根结点的dp值。

即：对于一个结点而言，其dp值等于sum值和其子树的dp值的最大值。

dfs完成时，此时的ans即为答案。如果ans没有被更新，则说明答案不存在，输出Impossible

确实是很巧妙的dfs

#include <bits/stdc++.h>
#define ll long long
#define __max(a,b) a > b ? a : b
#define pll pair<ll, ll>
using namespace std;
const int maxn = 2e5 + 10;
const int oo = 0x7fffffff;
ll dp[maxn];//记录每个结点的其子树的权值最大和
ll sum[maxn];//记录每个结点及其子树的权值和
vector<int> tree[maxn];
ll ans = -oo;
void dfs(int node, int pre)
{
    for(auto idx: tree[node])
    {
        if(idx != pre)
        {
            dfs(idx, node);
            sum[node] += sum[idx];
            if(dp[node] != -oo)
                ans = max(dp[node] + dp[idx], ans);
            dp[node] = max(dp[node], dp[idx]);//每次新处理完一棵子树要更新node的dp值
        }
    }
    dp[node] = max(dp[node], sum[node]);
}
int main()
{
//    freopen("/Users/vector/Desktop/out.txt", "w", stdout);
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        cin >> sum[i];
        dp[i] = -oo;
    }
    for(int i = 1; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        tree[x].push_back(y);
        tree[y].push_back(x);
    }
    dfs(1, -1);
    if(ans != -oo)
        cout << ans << endl;
    else
        cout << "Impossible" << endl;
    return 0;
}