cf 671D Roads in Yusland

大意：

给出一棵n个节点的有根树，1号节点是根。

给出树上的m条路径，ui,vi,ci,可以用ci的价值覆盖ui到vi的边，其中vi一定是ui的祖先。

要求覆盖树上所有的边的最小代价。

---

dp[i]表示覆盖i子树以及i到其父亲的边的最小代价。枚举link（覆盖用的边）很好转移，但是要累加一大堆dp值，线段树维护cost[i]表示当前节点选择以v为下端点的link的最小代价，修改的时候对于i的儿子k子树内部的节点，加上i的儿子dp值的和-dp[k]（dfs序实现），然后注意增加和删除link就好了。

//QWsin
#include<set>
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll INF=1ll<<60;
const int maxn=300000+10;
const int maxm=600000+10;

int first[maxn],next[maxm],ecnt;
struct Edge{int u,v;Edge(int u=0,int v=0):u(u),v(v){}}e[maxm];
inline void add_edge(int u,int v){
    next[ecnt]=first[u];first[u]=ecnt;e[ecnt++]=Edge(u,v);  
    next[ecnt]=first[v];first[v]=ecnt;e[ecnt++]=Edge(v,u);  
}

struct Node{
    ll tag,m;Node *lc,*rc;
    Node(){tag=0;m=INF;lc=rc=NULL;}
    inline void up(){m=min(lc->m,rc->m);}
    inline void push(){
        if(tag){
            lc->m+=tag;rc->m+=tag;
            lc->tag+=tag;rc->tag+=tag;
            tag=0;
        }
    }
}*root;

#define mid ((l+r)>>1)
void build(Node* &p,int l,int r){
    p=new Node();if(l==r) return ;
    build(p->lc,l,mid);build(p->rc,mid+1,r);p->up();    
}

void updata(Node* p,int l,int r,const int &pos,const ll &val,int kind)//0表示覆盖，1表示加 
{
    if(l==r) {p->m=kind?p->m+val:val;return ;}
    p->push();
    if(pos<=mid) updata(p->lc,l,mid,pos,val,kind);
    else updata(p->rc,mid+1,r,pos,val,kind);
    p->up();
}

void updata1(Node* p,int l,int r,const int &L,const int &R,const ll &val)
{
    if(L<=l&&r<=R) {p->m+=val;p->tag+=val;return ;}
    p->push();
    if(L<=mid) updata1(p->lc,l,mid,L,R,val);
    if(mid <R) updata1(p->rc,mid+1,r,L,R,val);
    p->up();
}

ll query(Node* p,int l,int r,const int &L,const int &R)
{
    if(L<=l&&r<=R) return p->m;
    p->push();
    ll ret=INF;
    if(L<=mid) ret=min(ret,query(p->lc,l,mid,L,R));
    if(mid< R) ret=min(ret,query(p->rc,mid+1,r,L,R));
    return ret; 
}

ll dp[maxn];
int n,m,dfs_clk,ok=1,L[maxn],R[maxn];

struct A{int v,c;A(int v=0,int c=0):v(v),c(c){}};

multiset<int>linkcost[maxn];
vector<A>link[maxn];

ll dfs(int u,int fa)
{
    L[u]=++dfs_clk;
    ll sum=0;
    for(int i=first[u];i!=-1;i=next[i])
        if(e[i].v!=fa) sum+=dfs(e[i].v,u);  

    R[u]=dfs_clk;

    for(int i=first[u];i!=-1;i=next[i])
    {
        int v=e[i].v;
        if(v==fa) continue;
        updata1(root,1,n,L[v],R[v],sum-dp[v]);//加上需要累加的dp值 
    }
    if(linkcost[u].size()) updata(root,1,n,L[u],*linkcost[u].begin()+sum,0);//updata从这里开始的link 

    if(u!=1) {//删去在这里结束的边，因为要覆盖到到父亲的边（根不用） 
        for(int i=0,sz=link[u].size();i<sz;++i)
        {
            int v=link[u][i].v,c=link[u][i].c;
            linkcost[v].erase(linkcost[v].find(c));//multiset注意 
            if(linkcost[v].size()==0) updata(root,1,n,L[v],INF,0);//没有连到更上边的边了 
            else {
                int newc=*linkcost[v].begin();
                if(newc > c){
                    updata(root,1,n,L[v],newc-c,1);//更新代价，只是更换了linkcost，之前的要保留所以是+不是覆盖 
                }
            }
        }
    }

    dp[u]=query(root,1,n,L[u],R[u]);

    if(dp[u]==INF)ok=0;//无法覆盖 

    return dp[u]; 
}   

inline void out(vector<A>&vc,int id)
{
    printf("vector:%d\n",id);
    for(int i=0;i<vc.size();++i) {
        printf("v:%d c:%d\n",vc[i].v,vc[i].c);
    }
    printf("\n");
}

inline void init_data()
{
    cin>>n>>m;memset(first,-1,sizeof first);
    int u,v,c;
    for(int i=1;i<n;++i){
        scanf("%d%d",&u,&v);add_edge(u,v);
    }
    for(int i=1;i<=m;++i){
        scanf("%d%d%d",&u,&v,&c);swap(u,v);
        link[u].push_back(A(v,c));
        linkcost[v].insert(c);//直接insert不会有影响，用到的时候必然在需要insert之后 
    }

//  for(int i=1;i<=n;++i) out(link[i],i);

    build(root,1,n);
}

inline void solve()
{
    if(n==1) {puts("0");return ;}//特判 
    ll ans=dfs(1,1);//dp
    if(!ok) puts("-1");
    else cout<<ans;
}


int main()
{
    init_data();
    solve();
    return 0;
}