bzoj3672

感觉是noi2014中最有价值的一道题了

我们先考虑链上这个问题怎么做……

如果没限制，那就是SB的斜率优化

我们可以得到这个式子(f[j]-f[k])/(s[j]-s[k])<p[i]

点横坐标是单调的，我们只要维护凸壳然后二分即可

有距离限制？好像不好弄，不过我们记得cash那道坐标不单调的题我们是可以用cdq分治的

这道题也一样，划分，考虑左半部分对右半部分的影响

我们只要对右半部分距离限制排序然后依次加点维护凸壳然后二分即可

换到树上来那就是点分治啦，

我们找重心，先做重心子树外（就是包含根的那部分），做完之后

考虑重心的祖先对子树的影响，我们完全可以如法炮制

然后不断向下递归处理即可

这样noi2014的传统题就做完啦！

const inf=9223372036854775807;
      eps=1e-10;

type node=record
       po,next:longint;
     end;
     point=record
       x,y:int64;
     end;

var h,fp,p,fa,mx,s,q,b:array[0..200010] of longint;
    a:array[0..200010] of point;
    cut:array[0..200010] of boolean;
    e:array[0..200010] of node;
    w,f,d,kp,bp,lim:array[0..200010] of int64;
    x,t,i,len,n,ty,r:longint;

function max(a,b:longint):longint;
  begin
    if a>b then exit(a) else exit(b);
  end;

procedure min(var a:int64; b:int64);
  begin
    if a>b then a:=b;
  end;

procedure add(x,y:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].next:=p[x];
    p[x]:=len;
  end;

procedure bfs(st:longint);
  var i,f,x,y:longint;
  begin
    f:=1;
    r:=1;
    q[1]:=st;
    while f<=r do
    begin
      x:=q[f];
      i:=p[x];
      while i<>0 do
      begin
        if not cut[i] then
        begin
          inc(r);
          q[r]:=e[i].po;
        end;
        i:=e[i].next;
      end;
      inc(f);
    end;
  end;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function cmp(i,j:longint):boolean;
  begin
    exit(lim[i]-d[i]<lim[j]-d[j]);
  end;

procedure sort(l,r:longint);
  var i,j,x:longint;
  begin
    i:=l;
    j:=r;
    x:=b[(l+r) shr 1];
    repeat
      while cmp(b[i],x) do inc(i);
      while cmp(x,b[j]) do dec(j);
      if i<=j then
      begin
        swap(b[i],b[j]);
        inc(i);
        dec(j);
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

function getk(i,j:longint):extended;
  begin
    exit((a[i].y-a[j].y)/(a[i].x-a[j].x));
  end;

function find(l,r,x:longint):longint;
  var m:longint;
      s1,s2:int64;
  begin
    while l<r do
    begin
      m:=(l+r) shr 1;
      s1:=a[h[m]].y+a[h[m]].x*kp[x];
      s2:=a[h[m+1]].y+a[h[m+1]].x*kp[x];
      if s1>s2 then l:=m+1
      else r:=m;
    end;
    exit(h[l]);
  end;

procedure cdq(root:longint);
  var i,j,x,mid,m,y:longint;
  begin
    bfs(root);
    if r=1 then exit;
    mid:=0;
    for i:=r downto 1 do
    begin
      x:=q[i];
      s[x]:=1;
      mx[x]:=0;
      j:=p[x];
      while j<>0 do
      begin
        y:=e[j].po;
        if not cut[j] then
        begin
          s[x]:=s[x]+s[y];
          mx[x]:=max(mx[x],s[y]);
        end;
        j:=e[j].next;
      end;
      mx[x]:=max(mx[x],r-s[x]);
      if mx[x]<mx[mid] then mid:=x;
    end;
    if root<>mid then
    begin
      cut[fp[mid]]:=true;
      cdq(root);
      m:=0;
      x:=fa[mid];
      while x<>root do
      begin
        inc(m);
        a[m].x:=-d[x];  //为了方便改变一下形式
        a[m].y:=f[x];
        x:=fa[x];
      end;
      inc(m);
      a[m].x:=-d[x];
      a[m].y:=f[x];

      bfs(mid);
      for i:=1 to r do
        b[i]:=q[i];
      sort(1,r);
      t:=0;
      j:=1;
      for i:=1 to r do
      begin
        x:=b[i];
        while (j<=m) and (a[j].x<=lim[x]-d[x]) do
        begin
          while (t>1) and (getk(j,h[t])-eps<getk(h[t],h[t-1])) do dec(t);
          inc(t);
          h[t]:=j;
          inc(j);
        end;
        if t>0 then
        begin
          y:=find(1,t,x);
          min(f[x],a[y].y+kp[x]*(d[x]+a[y].x)+bp[x]);
        end;
      end;
    end;
    for i:=2 to r do
    begin
      x:=q[i];
      if d[x]-d[mid]<=lim[x] then
        min(f[x],f[mid]+kp[x]*(d[x]-d[mid])+bp[x]);
    end;
    i:=p[mid];
    while i<>0 do
    begin
      if not cut[i] then cdq(e[i].po);
      i:=e[i].next;
    end;
  end;

begin
  readln(n,ty);
  for i:=2 to n do
  begin
    readln(fa[i],w[i],kp[i],bp[i],lim[i]);
    add(fa[i],i);
    fp[i]:=len;
    f[i]:=inf;
  end;
  bfs(1);
  for i:=2 to r do
  begin
    x:=q[i];
    d[x]:=d[fa[x]]+w[x];
  end;
  mx[0]:=n+1;
  f[1]:=0;
  cdq(1);
  for i:=2 to n do
    writeln(f[i]);
end.