题链：
http://www.lydsy.com/JudgeOnline/problem.php?id=3672
题解：
斜率优化DP，点分治（树上CDQ分治...）
这里有一个没有距离限制的简单版：BZOJ 1767 [Ceoi2009]harbingers
定义$DP[i]$为从i出发到1号点的最小花费，$dis_i$为i到1号点的距离：
转移：
$DP[i]=min(DP[j]+(dis_i-dis_j)P_j)+Q_i$
$\quad=min(DP[j]-dis_jP_i)+dis_iP_i+Q_i$
显然这个$O(N^2)$的转移会超时。
考虑优化：
假设对于当前计算的DP[i],有两个转移来源点：k,j，同时dis[k]<dis[j],设j点比k点优。
那么有：$DP[j]-dis_j*P_i-(DP[k]-dis_k*P_i)<0$
则: $\frac{DP[j]-DP[k]}{dis[j]-dis[k]}<P[i]$
如果令 Slope(j,k)=$\frac{DP[j]-DP[k]}{dis[j]-dis[k]}$
那么得到结论，如果 $dis_k<dis_j$,且Slope(j,k)<P[i]的话，则j点优于k点。
同时如果存在三个转移来源点：k,j,i，满足$dis_k<dis_j<dis_i$，
同时Slope(i,j)<Slope(j,k),则j点无效。
所以对于每个来源点二元组(dis[j],DP[j])，只需要在平面上维护一个下凸壳即可。
1).如果问题不在一颗树上，而是在一个序列上，这个应该比较容易吧：一个裸的CDQ就可以解决了。
2).而如果问题没有limit这个距离限制，即使在树上，也比较容易了，因为随着DFS遍历树时，dis是单增的，所以可以直接维护单调栈（详细见BZOJ 1767 [Ceoi2009]harbingers）
但是现在既在树上又有距离限制怎么办呢？这里采用点分治来实现CDQ分治的功能，（可以叫做树上CDQ分治么）
对于当前的子树，我们令根为u，（这个根是子树内的点在前往1号点时都要经过的地方）。
并找到子树内的重心cg（the center of gravity）,
然后先递归处理cg为根时含有u的那颗子树，
不难发现，cg的其它子树的点(令这些点的集合为R)在前往1号点时，都会进过cg～u这一条链，
即这条链上的点可能会成为R里的点的转移点。
同时为了满足距离这一限制，即每个点i最多只能向上到达 $dis_i-limit_i$这个位置
所以把R里的点按 $dis_i-limit_i$排序后，从大到小枚举R里的i点，并把cg～u这条链上dis小于$dis_i-limit_i$的点用单调栈维护一个下凸壳。
接着在凸壳里二分最优的转移来源点即可。
整个过程是$O(Nlog_2^2N)$的。
（伤不起,读入居然要long long!）
代码：PoPoQQQ的代码写得很棒呀！
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define MAXN 200050
#define ll long long
using namespace std;
ll DP[MAXN],P[MAXN],Q[MAXN],G[MAXN],dis[MAXN];
int fa[MAXN],siz[MAXN];
int N,t;
struct Edge{
ll val[MAXN];
int to[MAXN],nxt[MAXN],head[MAXN],ban[MAXN],ent;
Edge(){ent=2;}
void Adde(int u,int v,ll w){
to[ent]=v; val[ent]=w; nxt[ent]=head[u]; head[u]=ent++;
}
}E;
struct Mostk{
int s[MAXN],top;
#define Slope(i,j) (1.0*(DP[i]-DP[j])/(dis[i]-dis[j]))
void Reset(){top=0;}
void Push(int i){
if(top&&dis[s[top]]==dis[i])
{if(DP[i]<DP[s[top]]) top--; else return;}
while(top>1&&Slope(s[top-1],s[top])<Slope(s[top],i)) top--;
s[++top]=i;
}
int Query(int i){//二分单调栈
static int l,r,mid,ret;
if(!top) return 0;
l=2; r=top; ret=1;
while(l<=r){
mid=(l+r)>>1;
if(Slope(s[mid-1],s[mid])>=P[i]) ret=mid,l=mid+1;
else r=mid-1;
}
return s[ret];
}
}S;
void dfs(int u){
for(int i=E.head[u];i;i=E.nxt[i]){
int v=E.to[i];
dis[v]=dis[u]+E.val[i];
dfs(v);
}
}
void getcg(int u,int &cg,int &num,int sum){
int maxnum=0; siz[u]=1;
for(int i=E.head[u];i;i=E.nxt[i]){
int v=E.to[i]; if(E.ban[i]) continue;
getcg(v,cg,num,sum);
maxnum=max(maxnum,siz[v]);
siz[u]+=siz[v];
}
maxnum=max(maxnum,sum-siz[u]);
if(maxnum<=num) num=maxnum,cg=u;
}
void trave(int u,int &cr,int *R){
R[++cr]=u;
for(int i=E.head[u];i;i=E.nxt[i]){
if(E.ban[i]) continue;
trave(E.to[i],cr,R);
}
}
bool cmp(int i,int j){
return dis[i]-G[i]>dis[j]-G[j];
}
void solve(int u,int num){
static int R[MAXN],cr,maxnum;
if(num==1) return;
int cg=u; maxnum=num;
getcg(u,cg,maxnum,num);
//-----------------------------准备递归u区域
for(int i=E.head[cg];i;i=E.nxt[i]) E.ban[i]=1;
solve(u,num-siz[cg]+1);
//-----------------------------开始解决当前层的贡献
cr=0; S.Reset();
for(int i=E.head[cg];i;i=E.nxt[i]) trave(E.to[i],cr,R);
sort(R+1,R+cr+1,cmp);
for(int i=1,j=cg,k;i<=cr;i++){
while(j!=fa[u]&&dis[j]>=dis[R[i]]-G[R[i]]) S.Push(j),j=fa[j];
k=S.Query(R[i]);
if(k) DP[R[i]]=min(DP[R[i]],DP[k]+(dis[R[i]]-dis[k])*P[R[i]]+Q[R[i]]);
}
//-----------------------------递归解决剩下子树区域
for(int i=E.head[cg];i;i=E.nxt[i])
solve(E.to[i],siz[E.to[i]]);
}
void read(ll &x){
static int sn; static char ch;
x=0; sn=1; ch=getchar();
while(ch<‘0‘||‘9‘<ch){if(ch==‘-‘)sn=-1;ch=getchar();}
while(‘0‘<=ch&&ch<=‘9‘){x=x*10+ch-‘0‘;ch=getchar();}
x=x*sn;
}
int main(){
scanf("%d%d",&N,&t);
memset(DP,0x3f,sizeof(DP));
DP[1]=0; ll f,s,p,q,g;
for(int i=2;i<=N;i++){
read(f); read(s); read(p); read(q); read(g);
fa[i]=f; P[i]=p; Q[i]=q; G[i]=g;
E.Adde(f,i,s);
}
dfs(1);
solve(1,N);
for(int i=2;i<=N;i++) printf("%lld\n",DP[i]);
return 0;
}
