CF671D：Roads in Yusland

n<=300000个点的树，给m<=300000条带权路径（ui,vi,保证vi是ui的祖先）求覆盖整棵树每条边的最小权和。

好题好姿势！直观的看到可以树形DP，f[i]表示把点i包括它爸爸下面那条边都覆盖的最小权，就用经过他爸爸那条边的所有路径，各条路径加上一些子树信息来更新即可。

这样时间炸，那看看怎么优化。实际上我们不是在单纯地用一条路径更新答案，而是这样一个东西：

其中红色那条是题目给的路径，实际上是加上蓝色边连接的点的f[i]来更新边2上端的那个点的答案的。也就是说，一条路径来更新答案，要在这条路径的尾部加上那些点权（1），然后在更新某个点的答案的时候加上这个点下面的这条路径的分叉（2）。而更新一个点的路径，其实都是这个点对应子树的路径。至于子树中那些够不到这个点的路径，只需在扫到头的时候把这条路径的答案变inf即可。

为了实现这个操作，即找到“起点在子树里的所有路径的答案”，我们用dfs序给每个路径的起点（下端点）编号，再dfs求每个点的答案；每次求答案时，先把以该点为起点的新路径赋初值，即该点所有子树的f[j]和，并把终点在该点的路径答案置inf；然后给经过该点的路径加“分叉”；由于dfs序编号好了，能更新这个节点的路径（上面提到的起点在这个子树内的路径）是连续的一个区间，因此用个线段树维护区间min即可。

至于加“分叉”，观察可以发现：假如经过i的某路径来自子树j，那么应该把它答案加上点i其他儿子的f和。所以在加“分叉”时只需要再枚举一次孩子，把孩子子树内所有的路径加上其他孩子的f[j]和即可。

废话少说见代码！

 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>
 #include<algorithm>
 //#include<iostream>
 using namespace std;

 int n,m;
 #define maxn 300011
 struct Edge{int to,next;}edge[maxn*];int first[maxn],start[maxn],end[maxn],le=;
 void in(int x,int y,int* first) {edge[le].to=y;edge[le].next=first[x];first[x]=le++;}
 void insert(int x,int y,int* first) {in(x,y,first);in(y,x,first);}
 int dfn[maxn],Left[maxn],Right[maxn],Time=;
 void dfs(int x,int fa)
 {
     Left[x]=Time+;
     for (int i=start[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];
         dfn[e.to]=++Time;
     }
     for (int i=first[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];
         if (e.to!=fa) dfs(e.to,x);
     }
     Right[x]=Time;
 }
 #define LL long long
 LL val[maxn];
 const LL inf=1e15+;
 struct SMT
 {
     struct Node
     {
         LL Min;
         LL add;
         int l,r;
         int ls,rs;
     }a[maxn*];
     int size;
     SMT() {size=;}
     void build(int &x,int L,int R)
     {
         x=++size;
         a[x].Min=inf;a[x].add=;
         a[x].l=L;a[x].r=R;
         if (L==R) {a[x].ls=a[x].rs=;}
         else
         {
             const int mid=(L+R)>>;
             build(a[x].ls,L,mid);
             build(a[x].rs,mid+,R);
         }
     }
     void build() {int x;build(x,,m);}
     void up(int x)
     {
         const int &p=a[x].ls,&q=a[x].rs;
         a[x].Min=min(a[p].Min,a[q].Min);
     }
     void addsingle(int x,LL v)
     {
         a[x].Min+=v;
         a[x].Min=min(inf,a[x].Min);
         a[x].add+=v;
     }
     void down(int x)
     {
         const int &p=a[x].ls,&q=a[x].rs;
         if (a[x].add)
         {
             addsingle(p,a[x].add);
             addsingle(q,a[x].add);
             a[x].add=;
         }
     }
     int ql,qr;LL v;
     void be(int x)
     {
         if (a[x].l==a[x].r) {a[x].Min=v;return;}
         down(x);
         const int mid=(a[x].l+a[x].r)>>;
         if (ql<=mid) be(a[x].ls);
         if (ql> mid) be(a[x].rs);
         up(x);
     }
     void be(int p,LL v) {ql=qr=p;this->v=v;be();}
     void Add(int x)
     {
         if (ql<=a[x].l && a[x].r<=qr) {addsingle(x,v);return;}
         down(x);
         const int mid=(a[x].l+a[x].r)>>;
         if (ql<=mid) Add(a[x].ls);
         if (qr> mid) Add(a[x].rs);
         up(x);
     }
     void Add(int L,int R,LL v) {if (L>R) return;ql=L;qr=R;this->v=v;Add();}
     LL query(int x)
     {
         if (ql<=a[x].l && a[x].r<=qr) return a[x].Min;
         down(x);
         const int mid=(a[x].l+a[x].r)>>;LL ans=inf;
         if (ql<=mid) ans=min(ans,query(a[x].ls));
         if (qr> mid) ans=min(ans,query(a[x].rs));
         return ans;
     }
     LL query(int L,int R) {if (L>R) return inf;ql=L;qr=R;return query();}
 }t;
 LL f[maxn];
 void play(int x,int fa)
 {
     LL tot=;
     for (int i=first[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];if (e.to==fa) continue;
         play(e.to,x);
         tot=min(inf,f[e.to]+tot);
     }
     for (int i=start[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];
         t.be(dfn[e.to],tot+val[e.to]);
     }
     for (int i=end[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];
         t.be(dfn[e.to],inf);
     }
     if (x==) f[]=tot;
     else if (tot<inf)
     {
         for (int i=first[x];i;i=edge[i].next)
         {
             Edge &e=edge[i];if (e.to==fa) continue;
             t.Add(Left[e.to],Right[e.to],tot-f[e.to]);
         }
         f[x]=t.query(Left[x],Right[x]);
     }
     else f[x]=inf;
 }
 void play()
 {
     dfs(,);
     t.build();
     play(,);
 }
 int x,y;LL v;
 int main()
 {
     scanf("%d%d",&n,&m);
     for (int i=;i<n;i++)
     {
         scanf("%d%d",&x,&y);
         insert(x,y,first);
     }
     for (int i=;i<=m;i++)
     {
         scanf("%d%d%I64d",&x,&y,&val[i]);
         in(x,i,start);
         in(y,i,end);
     }
     play();
     printf(f[]>=inf?"-1\n":"%I64d\n",f[]);
     return ;
 }

还有一种贪心写法哦！