codefoeces 671 problem D

D. Roads in Yusland

standard output

Mayor of Yusland just won the lottery and decided to spent money on something good for town. For example, repair all the roads in the town.

Yusland consists of n intersections connected by n - 1 bidirectional roads. One can travel from any intersection to any other intersection using only these roads.

There is only one road repairing company in town, named "RC company". Company's center is located at the intersection 1. RC company doesn't repair roads you tell them. Instead, they have workers at some intersections, who can repair only some specific paths. The i-th worker can be paid ci coins and then he repairs all roads on a path from ui to some vi that lies on the path from ui to intersection 1.

Mayor asks you to choose the cheapest way to hire some subset of workers in order to repair all the roads in Yusland. It's allowed that some roads will be repaired more than once.

If it's impossible to repair all roads print  - 1.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 300 000) — the number of cities in Yusland and the number of workers respectively.

Then follow n−1 line, each of them contains two integers xi and yi (1 ≤ xi, yi ≤ n) — indices of intersections connected by the i-th road.

Last m lines provide the description of workers, each line containing three integers ui, vi and ci (1 ≤ ui, vi ≤ n, 1 ≤ ci ≤ 109). This means that the i-th worker can repair all roads on the path from vi to ui for ci coins. It's guaranteed that vi lies on the path from ui to 1. Note that viand ui may coincide.

Output

If it's impossible to repair all roads then print  - 1. Otherwise print a single integer — minimum cost required to repair all roads using "RC company" workers.

Example

input

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

output

8

Note

In the first sample, we should choose workers with indices 1, 3, 4 and 5,

some roads will be repaired more than once but it is OK. The cost will be equal to 2 + 3 + 1 + 2 = 8 coins.

————————————————————————————————————

这道题简单来讲就是给你一棵大小为n的树 再给你m条链 每条链有覆盖的范围（只能往上）

也就是u v v一定是u的祖先 链还有代价 求用最小的代价覆盖整颗树 如果无解输出-1

我的写法是一波贪心 从叶子节点开始计算 把从每个点开始的所有的边扔在这个点的平衡树上的

要求长度小的价值一定要小（所以插入的时候记得可以弹掉别的边）

这样之后我们选择的时候每个点我们贪心的选那个最短也就是价值最小的

然后所有的边打一波减的标记（这个可以搞个全局变量） 这样贪心以后用别的边就相当于用别的边

代替现在的这条边 这就保证了答案的正确性

然后我们从叶子节点开始算 如果没有边在他的平衡树里的话就是无解

不然就选一个最小的然后把他剩余的东西扔给他的父亲 这里记得把选的这条边的两端扔在一个并查集里

表示这些点标记过了以后不需要用 然后把自己的边扔给父亲的时候用一波启发式合并 保证复杂度

这样之后总的复杂度就是（nloglog） 

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#define LL long long
const int M=3e5+7;
int read(){
    int ans=0,f=1,c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}
    while(c>='0'&&c<='9'){ans=ans*10+(c-'0'); c=getchar();}
    return ans*f;
}
LL ans;
int n,m;
int f[M];
int find(int x){while(f[x]!=x) x=f[x]=f[f[x]]; return x;}
int first[M],cnt;
struct node{int to,next;}e[2*M];
void ins(int a,int b){e[++cnt]=(node){b,first[a]}; first[a]=cnt;}
void insert(int a,int b){ins(a,b); ins(b,a);}
int deep[M],fa[M];
int dfs(int x,int last){
    for(int i=first[x];i;i=e[i].next){
        int now=e[i].to;
        if(now==last) continue;
        deep[now]=deep[x]+1;
        fa[now]=x;
        dfs(now,x);
    }
}
struct pos{
    int d,w;
    bool operator <(const pos &x)const{return d!=x.d?d>x.d:w>x.w;}
};
std::multiset<pos>tr[M];
typedef std::multiset<pos>::iterator IT;
void delet(int x,pos p,int s){
    p.w+=s;IT it=tr[x].upper_bound(p);
    if(it!=tr[x].begin()){
        it--;
        while(it->w>=p.w){
            if(it==tr[x].begin()){tr[x].erase(it);break;}
            IT now=it; --now;
            tr[x].erase(it);    
            it=now;
        }    
    }
    it=tr[x].upper_bound(p);
    if(it==tr[x].end()||it->w>p.w) tr[x].insert(p);
}
int dec[M];
void push_ans(int x){
    for(int i=first[x];i;i=e[i].next){
        int now=e[i].to;
        if(now==fa[x]) continue;
        push_ans(now);
        if(tr[now].size()>tr[x].size()) tr[x].swap(tr[now]),std::swap(dec[x],dec[now]);
        for(IT it=tr[now].begin();it!=tr[now].end();it++) delet(x,*it,dec[x]-dec[now]);
        tr[now].clear();
    }
    while(tr[x].size()){
        IT it=tr[x].begin();
        if(it->d==deep[x]) tr[x].erase(it);
        else break;
    }
    if(x!=1&&f[x]==x){
        if(tr[x].empty()) puts("-1"),exit(0);
        IT it=tr[x].begin();
        ans+=it->w-dec[x];
        dec[x]=it->w;
        int v=x; while(deep[v]>it->d) v=f[v]=find(fa[v]);
        tr[x].erase(it);
    }
}
int main(){
    int x,y,w;
    n=read(); m=read();
    for(int i=1;i<=n;i++) f[i]=i;
    for(int i=1;i<n;i++) x=read(),y=read(),insert(x,y);
    deep[1]=1; dfs(1,-1);
    for(int i=1;i<=m;i++){
        x=read(); y=read(); w=read();
        pos p=(pos){deep[y],w};
        delet(x,p,0);
    }
    push_ans(1);
    printf("%lld\n",ans);
    return 0;
}

View Code

 

转载于:https://www.cnblogs.com/lyzuikeai/p/7489204.html