xtu 1252

http://202.197.224.59/OnlineJudge2/index.php/Problem/read/id/1252

Defense Tower

In ICPCCamp, there are n cities and (n−1) (bidirectional) roads between cities. The i-th road is between the ai-th and bi-th cities. It is guaranteed that cities are connected.

In the i-th city, there is a defense tower with power pi. The tower protects all cities with a road directly connected to city i. However, the tower in city i does not protect city i itself.

Bobo would like to destroy all defense towers. When he tries to destroy the tower in city i, any not-destroyed tower protecting city i will deal damage whose value equals to its power to Bobo.

Find out the minimum total damage Bobo will receive if he chooses the order to destroy the towers optimally.

Input

The input contains at most 30 sets. For each set:

The first line contains an integer n (1≤n≤105).

The second line contains n integers p1,p2,…,pn (1≤pi≤104).

The i-th of the last (n−1) lines contains 2 integers ai,bi (1≤ai,bi≤n).

Output

For each set, an integer denotes the minimum total damage.

Sample Input

3
1 2 3
1 2
2 3
3
1 100 1
1 2
2 3

Sample Output

3
2

湘潭去年比赛的题目，与我们最开始想的题目的类型都不同，我们最开始以为是模拟题，不知道怎么模拟，然后做不了，其实这是个贪心的题目
题意：就是在每个城市有个防御塔，这个塔有攻击力，可以保护与这个城市相连的其他城市，但是不能保护自己，求要破坏所有的塔所受最少的伤害
思路：就是贪心，用优先队列，每次取伤害最高的塔所在的城市，攻击这个城市，然后把与其相连的城市的攻击力加起来。

#include <stdio.h>
#include <string.h>
#include <queue>
#include <vector>

using namespace std;

vector<int >edge[100005];

struct node{
    int a,b;
     friend bool operator<(node a,node b)
    {
        return a.b<b.b;
    }
}pow[100005];


priority_queue<node>s;

int main()
{
    int n,a,b,ans;
    node tmp;
    bool flag[100005];
    while(~scanf("%d",&n))
    {
        memset(flag,true,sizeof(flag));
        for(int i = 1;i<=n;i++)
            edge[i].clear();
        ans = 0;
        for(int i = 1;i<=n;i++)
        {
            pow[i].a = i;
            scanf("%d",&pow[i].b);
            s.push(pow[i]);
        }
        for(int i = 1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            edge[a].push_back(b);
            edge[b].push_back(a);
        }
        while(!s.empty())
        {
            tmp = s.top();
            for(int i =0;i<edge[tmp.a].size();i++)
            {
                    if(flag[edge[tmp.a][i]])
                    {
                        ans+=pow[edge[tmp.a][i]].b;
                    }
            }
            flag[tmp.a] = false;
            s.pop();
        }
        printf("%d
",ans);
    }
    return 0;
}