codeforces 437 c 贪心+图论

题目：

C. The Child and Toy

time limit per test
1 second

memory limit per test
256 megabytes

input
standard input

output
standard output

On Children's Day, the child got a toy from Delayyy as a present. However, the child is so naughty that he can't wait to destroy the toy.

The toy consists of n parts and m ropes.
Each rope links two parts, but every pair of parts is linked by at most one rope. To split the toy, the child must remove all its parts. The child can remove a single part at a time, and each remove consume an energy. Let's define an energy value of part i as vi.
The child spend vf1 + vf2 + ... + vfk energy
for removing part i where f1, f2, ..., fk are
the parts that are directly connected to the i-th and haven't been removed.

Help the child to find out, what is the minimum total energy he should spend to remove all n parts.

Input

The first line contains two integers n and m (1 ≤ n ≤ 1000; 0 ≤ m ≤ 2000).
The second line contains n integers: v1, v2, ..., vn(0 ≤ vi ≤ 105).
Then followed m lines, each line contains two integers xi and yi,
representing a rope from part xi to
part yi(1 ≤ xi, yi ≤ n; xi ≠ yi).

Consider all the parts are numbered from 1 to n.

Output

Output the minimum total energy the child should spend to remove all n parts of the toy.

Examples

input

4 3
10 20 30 40
1 4
1 2
2 3

output

40

input

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

output

400

input

7 10
40 10 20 10 20 80 401 5
4 7
4 5
5 2
5 7
6 4
1 6
1 3
4 3
1 4

output

160

Note

One of the optimal sequence of actions in the first sample is:

First, remove part 3, cost of the action is 20.

Then, remove part 2, cost of the action is 10.

Next, remove part 4, cost of the action is 10.

At last, remove part 1, cost of the action is 0.

So the total energy the child paid is 20 + 10 + 10 + 0 = 40, which is the minimum.

In the second sample, the child will spend 400 no matter in what order he will remove the parts.

题意：

n个点m条边，没有多重边，要把这张图拆成n个部分。每拆出一个部分需要花费一个能量值，这个能量值是当前顶点所连向的所有顶点的vf值之和。拆点顺序任意，求拆出n个点所需能量的最小值。

思路：

拆点其实是在拆边。由于没有多重边，拆成n个点意味着所有的边都要被拆掉。而对于一条边a<->b，将a分离出来的时候拆边需要vfb的能量，将b分离出来的时候需要vfa的能量。因此拆每一条边只要选择所连接的两个顶点的最小能量值就可以了。

（一开始没有想到拆点可以转化为拆边..以为要用一个优先队列维护最好拆的点，然后每次更新，，结果感觉实现起来比较费劲...就google了一发

代码：

贴一发用vector 实现的代码 熟悉一下几个函数

#include<algorithm>
#include<string>
#include<iostream>
#include<stack>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 1010;
const int maxm = 2010;

int main(){
vector<int> val;
int size, edges, minEnergy ,tmp;
cin >> size >> edges;

val.reserve(size+1);// 开辟空间但没有初始化元素
val.push_back(-1); // 使得下标从1开始 ==insert(val.end(),-1); //在 val.end() 之前加一个-1

for (int i = 0; i < size; ++i) {
cin >> tmp;
val.push_back(tmp);
}
minEnergy = 0;
int c, d;
for (int i = 0; i < edges; ++i) {
cin >> c >> d;
minEnergy += (val[c] < val[d] ? val[c] : val[d]);
}
cout << minEnergy;
return 0;
}

顺便温习了一下优先队列

//priority_queue<int,vector <int>,grater <int> > qu;//由小到大 

//priority_queue<int,vector <int>,less <int> > qu;//由大到小 默认这样 相当于大顶堆