EOJ Monthly 2018.8 D. Delivery Service-树上差分(边权/边覆盖)(边权转点权)(模板题)

D. Delivery Service

单测试点时限: 2.5 秒

内存限制: 512 MB

EOJ Delivery Service Company handles a massive amount of orders in our nation. As is well known, our nation has ncities, with n−1 bi-directional paths connecting them, forming a tree. The length of the i-th path is wi, meaning that the time we have to spend walking through this path is wi.

Now, you, as the headquarter of EOJ, has somehow learned a magic spell. Each time you cast a spell on two paths, the lengths of these two paths magically swap with each other. You can do this magic as many times as you want(possibly none).

We have q orders waiting to be handled. The i-th order demands sending a package from city si to city ti. We kindly ask you to do your magic before all the deliveries start, such that the total time we have to spend on delivering these packages is minimized.

输入

The first line of the input contains one single integer n (1≤n≤2⋅105).

The next n−1 lines tell about the path information from path 1 to path n−1, the i-th of which contains three space-separated integers ui, vi and wi (1≤ui,vi≤n, ui≠vi, 1≤wi≤1000).

The next line contains one integer q (1≤q≤2⋅105).

The next q lines each contains two space-separated integers si and ti (1≤si,ti≤n,si≠ti).

输出

Output one integer, the minimum total time you can achieve.

样例

input

5
1 2 2
1 3 3
3 4 3
3 5 4
2
1 5
4 2

output

14

提示

In the example, we swap the weights between edge (1,2) and (1,3), so that the first order takes 2+4=6 time units to complete; the second order takes 2+3+3=8 time units. Thus the total time is 14.

题意就是给你一棵树，给你边(双向路径)和边权，边权是走这条路要花的时间，你有神奇的能力，可以交换任意两条边的边权，并且你可以无数次使用你的能力。然后给你m对点，表示要走路径<a，b>，要求你只能在他们开始走之前使用你的能力，问走完之后要花的最少时间是多少。

因为是走之前使用能力，所以可以提前处理出来，所以可以树上差分，所以树上差分，对边覆盖，把所有要走的路径先处理一下，sum[a]++,sum[b]++,sum[lca]-=2;然后Dfs遍历，求出来每条边走的次数，然后排个序，走的最多的路给最小的边权，就可以了。

代码:

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 #include<algorithm>
 #include<cstdlib>
 using namespace std;
 typedef long long ll;
 const int maxn=2e5+;

 struct node{
     int to,next;
 }edge[maxn<<];

 bool cmp(int a,int b)
 {
         return a>b;
 }
 int head[maxn<<],sum[maxn],dep[maxn],fa[maxn][],n,m,cnt,ans;

 void add(int x,int y){edge[++cnt].to=y,edge[cnt].next=head[x],head[x]=cnt;}

 void dfs(int u,int fath)//第一遍dfs，把信息处理出来
 {
     dep[u]=dep[fath]+,fa[u][]=fath;
     for(int i=;fa[u][i];++i) fa[u][i+]=fa[fa[u][i]][i];
     for(int i=head[u];i;i=edge[i].next){
         int v=edge[i].to;
         if(v!=fath) dfs(v,u);
     }
 }

 int LCA(int u,int v)//LCA
 {
     if(dep[u]>dep[v]) swap(u,v);
     for(int i=;i>=;i--) if(dep[u]<=dep[v]-(<<i)) v=fa[v][i];
     if(u==v) return u;
     for(int i=;i>=;i--) if(fa[u][i]!=fa[v][i]) u=fa[u][i],v=fa[v][i];
     return fa[u][];
 }

 void Dfs(int u,int fath)//遍历求和
 {
     for(int i=head[u];i;i=edge[i].next){
         int v=edge[i].to;
         if(v==fath) continue;
         Dfs(v,u);
         sum[u]+=sum[v];
     }
 }

 int w[maxn];

 int main()
 {
     int n;
     scanf("%d",&n);
     for(int i=;i<n;i++){
         int x,y,v;
         scanf("%d%d%d",&x,&y,&v);
         add(x,y);add(y,x);
         w[i]=v;
     }
     dfs(,);
     int q;
     scanf("%d",&q);
     for(int i=;i<=q;i++){
         int x,y;
         scanf("%d%d",&x,&y);
         int lca=LCA(x,y);
         sum[x]++;sum[y]++;sum[lca]-=;
     }
     Dfs(,);
     sort(w+,w++n-);
     sort(sum+,sum+n+,cmp);
     ll ans=;
     for(int i=;i<n;i++){
         ans+=(ll)w[i]*sum[i];
     }
     cout<<ans<<endl;
 }

溜了。。。