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 vi and 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.

设f[i]为控制了i点的子树的费用

显然f是存在后效性的,因为当前选的工人会影响祖先的状态

最暴力的方法f[x][i]表示工人最高控制到x,控制了i的子树,不过显然超时

想办法消除后效性

我们考虑把一些工人的属性叠加到一个工人上,那么我们最后查询时只要查询某些能维修完整棵树的最小值

因为我们已经的到了这几棵子树的最优答案,并且子树之间互不影响,那么我们考虑把控制其他子树费用叠加到一个子树工人上

假设儿子有p1,p2,p3,tot=∑f[p]

p1的儿子的工人加上tot-f[p1],其他同理

也就是说,每一个工人都有控制其他所有子树的花费

也就是说,祖先x要用到p儿子这个工人时,就可以直接算出控制p儿子及x的费用

而且没有后效性,因为工人存了包含此工人的最优解,而且工人一直到vi被消掉之前,

都可以覆盖当前点,所以把工人都计算,肯定能算出最优解

因为工人在到vi之前都需要

而且对于计算一个节点的f,我们要给开始的工人赋值,给结束的工人消值,且给子节点所有工人加数

所以我们用dfs序维护以工人为下标的线段树,这样给子节点的工人加数等于线段树的区间加法

 #include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
struct Node
{
int next,to;
}edge[],edgeS[],edgeT[];
int num,numS,numT,head[],headS[],headT[];
int L[],R[],cnt,dfn[],n,m;
ll c[],lazy[],val[],inf=2e15,f[];
void add(int u,int v)
{
num++;
edge[num].next=head[u];
head[u]=num;
edge[num].to=v;
}
void addS(int u,int v)
{
numS++;
edgeS[numS].next=headS[u];
headS[u]=numS;
edgeS[numS].to=v;
}
void addT(int u,int v)
{
numT++;而且没有后效性,因为
edgeT[numT].next=headT[u];
headT[u]=numT;
edgeT[numT].to=v;
}
void pushup(int rt)
{
c[rt]=min(c[rt*],c[rt*+]);
}
void pushdown(int rt)
{
if (lazy[rt])
{
c[rt*]+=lazy[rt];
c[rt*+]+=lazy[rt];
lazy[rt*]+=lazy[rt];
lazy[rt*+]+=lazy[rt];
lazy[rt]=;
}
}
void build(int rt,int l,int r)
{
c[rt]=inf;
if (l==r)
return;
int mid=(l+r)/;
build(rt*,l,mid);
build(rt*+,mid+,r);
}
void prework(int x,int pa)
{int i;
L[x]=cnt+;
for (i=headS[x];i;i=edgeS[i].next)
{
int v=edgeS[i].to;
dfn[v]=++cnt;
}
for (i=head[x];i;i=edge[i].next)
{
int v=edge[i].to;
if (v!=pa)
prework(v,x);
}
R[x]=cnt;
}
void update(int rt,int l,int r,int x,ll d)
{
if (l==r)
{
c[rt]=min(inf,d);
return;
}
pushdown(rt);
int mid=(l+r)/;
if (x<=mid) update(rt*,l,mid,x,d);
else update(rt*+,mid+,r,x,d);
pushup(rt);
}
void change(int rt,int l,int r,int L,int R,ll d)
{
if (L>R) return;
if (l>=L&&r<=R)
{
c[rt]+=d;
c[rt]=min(c[rt],inf);
lazy[rt]+=d;
lazy[rt]=min(lazy[rt],inf);
return;
}
pushdown(rt);
int mid=(l+r)/;
if (L<=mid) change(rt*,l,mid,L,R,d);
if (R>mid) change(rt*+,mid+,r,L,R,d);
pushup(rt);
}
ll query(int rt,int l,int r,int L,int R)
{
if (L>R) return inf;
if (l>=L&&r<=R)
{
return c[rt];
}
pushdown(rt);
int mid=(l+r)/;
ll s=inf;
if (L<=mid) s=min(s,query(rt*,l,mid,L,R));
if (R>mid) s=min(s,query(rt*+,mid+,r,L,R));
pushup(rt);
return s;
}
void dfs(int x,int pa)
{int i;
ll tot=;
for (i=head[x];i;i=edge[i].next)
{
int v=edge[i].to;
if (v==pa) continue;
dfs(v,x);
tot+=f[v];
tot=min(tot,inf);
}
if (x==)
{
f[]=tot;
return;
}
for (i=headS[x];i;i=edgeS[i].next)
{
int v=edgeS[i].to;
update(,,m,dfn[v],tot+val[v]);
}
for (i=headT[x];i;i=edgeT[i].next)
{
int v=edgeT[i].to;
update(,,m,dfn[v],inf);
}
for (i=head[x];i;i=edge[i].next)
{
int v=edge[i].to;
if (v==pa) continue;
change(,,m,L[v],R[v],tot-f[v]);
}
f[x]=query(,,m,L[x],R[x]);
}
int main()
{int i,u,v;
cin>>n>>m;
for (i=;i<=n-;i++)
{
scanf("%d%d",&u,&v);
add(u,v);add(v,u);
}
for (i=;i<=m;i++)
{
scanf("%d%d%I64d",&u,&v,&val[i]);
addS(u,i);addT(v,i);
}
prework(,);
build(,,m);
dfs(,);
if (f[]!=inf) cout<<f[];
else cout<<-;
}

codesforces 671D Roads in Yusland的更多相关文章

  1. Codeforces 671D Roads in Yusland [树形DP,线段树合并]

    洛谷 Codeforces 这是一个非正解,被正解暴踩,但它还是过了. 思路 首先很容易想到DP. 设\(dp_{x,i}\)表示\(x\)子树全部被覆盖,而且向上恰好延伸到\(dep=i\)的位置, ...

  2. codeforces 671D Roads in Yusland & hdu 5293 Tree chain problem

    dp dp优化 dfs序 线段树 算是一个套路.可以处理在树上取链的问题.

  3. Codeforces 671D. Roads in Yusland(树形DP+线段树)

    调了半天居然还能是线段树写错了,药丸 这题大概是类似一个树形DP的东西.设$dp[i]$为修完i这棵子树的最小代价,假设当前点为$x$,但是转移的时候我们不知道子节点到底有没有一条越过$x$的路.如果 ...

  4. CF 671D Roads in Yusland

    弄完之后点进去一看,竟然是div1的D题……最近真是天天被题虐哭 推荐这一篇博客 https://www.cnblogs.com/Sakits/p/8085598.html 感觉讲清楚了,也是基本照着 ...

  5. Codeforces 671 D. Roads in Yusland

    题目描述 Mayor of Yusland just won the lottery and decided to spent money on something good for town. Fo ...

  6. 【CF671D】Roads in Yusland(贪心,左偏树)

    [CF671D]Roads in Yusland(贪心,左偏树) 题面 洛谷 CF 题解 无解的情况随便怎么搞搞提前处理掉. 通过严密(大雾)地推导后,发现问题可以转化成这个问题: 给定一棵树,每条边 ...

  7. [Codeforces671D]Roads in Yusland

    [Codeforces671D]Roads in Yusland Tags:题解 题意 luogu 给定以1为根的一棵树,有\(m\)条直上直下的有代价的链,求选一些链把所有边覆盖的最小代价.若无解输 ...

  8. 【CF617D】Roads in Yusland

    [CF617D]Roads in Yusland 题面 蒯的洛谷的 题解 我们现在已经转化好了题目了,戳这里 那么我们考虑怎么求这个东西,我们先判断一下是否所有的边都能被覆盖,不行的话输出\(-1\) ...

  9. 【CodeForces】671 D. Roads in Yusland

    [题目]D. Roads in Yusland [题意]给定n个点的树,m条从下往上的链,每条链代价ci,求最少代价使得链覆盖所有边.n,m<=3*10^5,ci<=10^9,time=4 ...

随机推荐

  1. Leetcode 1——twosum

    Given an array of integers, return indices of the two numbers such that they add up to a specific ta ...

  2. JavaScript(第二十四天)【事件对象】

    JavaScript事件的一个重要方面是它们拥有一些相对一致的特点,可以给你的开发提供更多的强大功能.最方便和强大的就是事件对象,他们可以帮你处理鼠标事件和键盘敲击方面的情况,此外还可以修改一般事件的 ...

  3. Python 单向循环链表

    操作 is_empty() 判断链表是否为空 length() 返回链表的长度 travel() 遍历 add(item) 在头部添加一个节点 append(item) 在尾部添加一个节点 inser ...

  4. io多路复用(一)

    sever端 1 import socket sk1 = socket.socket() sk1.bind(('127.0.0.1',8001,)) sk1.listen() sk2 = socket ...

  5. Java并发编程实战 之 线程安全性

    1.什么是线程安全性 当多个线程访问某个类时,不管运行时环境采用何种调用方式或者这些线程将如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类是线程安全 ...

  6. token 验证

    组件: https://jwt.io/#libraries-io

  7. C#之Socket通信

    0.虽然之前在项目中也有用过Socket,但始终不是自己搭建的,所以对Server,Clinet端以及心跳,断线重连总没有很深入的理解,现在自己搭建了一遍加深一下理解. 服务端使用WPF界面,客户端使 ...

  8. Django REST framework+Vue 打造生鲜超市(三)

    四.xadmin后台管理 4.1.xadmin添加富文本插件 (1)xadmin/plugins文件夹下新建文件ueditor.py 代码如下: # xadmin/plugins/ueditor.py ...

  9. SpringCloud的Hystrix(二) 某消费者应用(如:ui、网关)访问的多个微服务的断路监控

    一.验证断路保护监控是否管理多个消费者 app 1.第1个消费者应用:访问自己封装rest服务 saleProd 2.第2个消费者应用:第二个应用没有反应 说明 1.每个应用实例的断路保护机制,只对本 ...

  10. NHibernate与IbatisNet的简单比较

    NHibernate是当前最流行的Java O/R mapping框架Hibernate的移植版本,当前版本是1.0 rc-1.它出身于sf.net..IbatisNet是另外一种优秀的Java O/ ...