Codeforces Round #384(Div. 2)D. Chloe and pleasant prizes【树形dp】

D. Chloe and pleasant prizes

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

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 a_i — 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·10⁵) — the number of gifts.

The next line contains n integers a₁, a₂, ..., a_n ( - 10⁹ ≤ a_i ≤ 10⁹) — the pleasantness of the gifts.

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

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.

Examples

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

题目大意：

已知一颗以1为根的树，让你找两个不相交的子树，使其和最大，如果找不到满足条件的解，输出Impossible

思路：

1、首先我们跑一遍Dfs，处理出sum【i】，sum【i】表示为以i为根的子树的所有节点的权值和.时间复杂度O（n）；

2、接下来我们考虑dp：

①设定dp【i】，表示以i为根的子树中的一颗子树的最大权值和。

②我们设定output，用于维护两颗子树的最大权值和。

③那么我们在Dfs过程中，output=max（output，dp【u】+dp【v】）；（此时dp【u】还没有通过dp【v】进行更新，那么此时dp【u】的值是之前子树中的最大子树权值和。）；并且同时dp【u】=max（dp【u】，dp【v】）；不断的维护最大的子树和。

3、注意数据范围，需要使用LL....

Ac代码：

#include<stdio.h>
#include<string.h>
#include<vector>
using namespace std;
#define ll __int64
#define inf 1000000000000000
int n;
vector<int >mp[500060];
ll a[500060];
ll sum[200500];
ll dp[200500];
ll output;
ll Dfs(int u,int from)
{
    if(sum[u]==-inf)
    {
        sum[u]=a[u];
        for(int i=0;i<mp[u].size();i++)
        {
            int v=mp[u][i];
            if(v==from)continue;
            sum[u]+=Dfs(v,u);
        }
        return sum[u];
    }
    else return sum[u];
}
ll Dfs_dp(int u,int from)
{
    for(int i=0;i<mp[u].size();i++)
    {
        int v=mp[u][i];
        if(v==from)continue;
        Dfs_dp(v,u);
        if(dp[u]!=-inf&&dp[v]!=-inf)
        output=max(output,dp[u]+dp[v]);
        dp[u]=max(dp[u],dp[v]);
    }
    dp[u]=max(dp[u],sum[u]);
}
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)dp[i]=-inf;
        for(int i=1;i<=n;i++)sum[i]=-inf;
        for(int i=1;i<=n;i++)
        {
            scanf("%I64d",&a[i]);
        }
        for(int i=0;i<n-1;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            mp[x].push_back(y);
            mp[y].push_back(x);
        }
        output=-inf;
        Dfs(1,-1);
        Dfs_dp(1,-1);
        if(output==-inf)printf("Impossible\n");
        else
        printf("%I64d\n",output);
    }
}