Sjekira（逆向思维+带权并查集）

Sjekira

题意：

给了你n个点权，n-1条边（题目保证这个图是棵树），问你将这n-1条边都砍掉的花费和最小是多少。
砍掉一条边的花费是这条边所连的两个联通块最大的点权之和。

Solution：

因为要使最后砍完n-1条边之后的花费最小，可以贪心的知道，每次都是先将点权最大的点所连的边先砍掉，这样能够保证点权大的点被用到的次数尽可能的少。因此每次都先砍掉点权最大的点所连的边，然后对这条边的另一个联通块（即与点权最大的点所连的边的另外一个联通块）求一下点权最大，每次都重复这样的操作（删除的边不用再重复删除）。但是这样写的话，可能比较复杂，因此我们反着进行思考，将点权从小到大排序，依次加入该点，并遍历与该点所连的所有边，如果这条边已经加入，那么跳过，否则加入与该点相连，并且另外一个点的点权比该点小的边。

代码：

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
typedef long long ll;
typedef pair<int,int>P;

int n;
int a[100005];
int f[100005];
int Find(int x){
   
    if(f[x]!=x)
    {
   
        int tem=f[x];
        f[x]=Find(f[x]);
        a[f[x]]=max(a[tem],a[f[x]]);
        a[tem]=a[f[x]];
    }
    return f[x];
}
void Union(int x,int y){
   
    int u=Find(x),v=Find(y);
    f[u]=v;
    a[v]=max(a[u],a[v]);
    a[u]=a[v];
}
vector<int> e[100005];
vector<P>g;
int main()
{
   
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
   scanf("%d",&a[i]);g.push_back(P(a[i],i));}
    sort(g.begin(),g.end());
    for(int i=1;i<=n;i++)f[i]=i;
    for(int i=0;i<n-1;i++)
    {
   
        int u,v;scanf("%d%d",&u,&v);
        if(a[u]>a[v])swap(u,v);
        e[v].push_back(u);
    }
    ll res=0;
    for(int i=0;i<g.size();i++)
    {
   
        int u=g[i].second;
        for(int j=0;j<e[u].size();j++)
        {
   
            int v=e[u][j];
            if(Find(u)!=Find(v))
            {
   
                res+=a[Find(u)]+a[Find(v)];
                Union(u,v);
            }
        }

    }
    printf("%lld",res);
    return 0;
}