bzoj3697

一开始又看错题，以为同样路径上不同的休息站是算不同路径，后来发现休息站只是路径合法的条件
毫无疑问是树的分治，下面我们只要考虑计算能建休息站的路径
我们把阳看作路径权值为1，阴作为路径权值-1
点分治之后，休息站的建立只有三种情况，在根，在之前的子树路径上，在现在的子树路径上
我们先考虑休息站在根到子树的路径上，我们设d[x]表示点x到根的路径距离
能建也就是说在x到根的路径上存在一点y，d[y]=d[x]，也就是当前距离之前是否出现过，打个标记即可
然后我们只要分别记录一下当前由根出发路径和为x，能否在这条路径上建休息站的路径数目就很容易统计了
注意一些地方的漏算和重复计算

type node=record
       po,next,num:longint;
     end;

var w,g:array[-100010..100010,0..1] of int64;
    s,p,f,d:array[0..100010] of longint;
    v:array[0..100010] of boolean;
    can:array[-100010..100010] of longint;
    e:array[0..200010] of node;
    l,r,root,len,i,x,tot,y,z,n:longint;
    ans:int64;

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

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

procedure getroot(x,fa:longint);
  var i,y:longint;
  begin
    i:=p[x];
    s[x]:=1;
    f[x]:=0;
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] and (y<>fa) then
      begin
        getroot(y,x);
        s[x]:=s[x]+s[y];
        f[x]:=max(f[x],s[y]);
      end;
      i:=e[i].next;
    end;
    f[x]:=max(f[x],tot-s[x]);
    if f[x]<f[root] then root:=x;
  end;

procedure dfs(x,fa:longint);
  var i,y:longint;
  begin
    if can[d[x]]>0 then
    begin
      inc(g[d[x],1]);
      ans:=ans+w[-d[x],1]+w[-d[x],0];  
    end
    else begin
      inc(g[d[x],0]);
      ans:=ans+w[-d[x],1];
    end;
    inc(can[d[x]]);
    r:=max(r,d[x]);
    if l>d[x] then l:=d[x];
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] and (y<>fa) then
      begin
        d[y]:=d[x]+e[i].num;
        dfs(y,x);
      end;
      i:=e[i].next;
    end;
    dec(can[d[x]]);
  end;

procedure work(x:longint);
  var i,y,j:longint;
  begin
    v[x]:=true;
    i:=p[x];
    l:=0; r:=0;
    w[0,0]:=1;  //注意根节点可以作为终点
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        d[y]:=e[i].num;
        dfs(y,x);
        ans:=ans+(w[0,0]-1)*g[0,0];  //注意当前子树内不能建休息站且路径和为0可以和之前的子树内（不包括单独根节点）这样的路径组成合法路径（根节点是休息站），而之前的计算我们是没有算进去的
        for j:=l to r do
        begin
          w[j,0]:=w[j,0]+g[j,0];  //更新
          w[j,1]:=w[j,1]+g[j,1];
          g[j,0]:=0; g[j,1]:=0;
        end;
      end;
      i:=e[i].next;
    end;
    for j:=l to r do
    begin
      w[j,0]:=0;
      w[j,1]:=0;
    end;
    i:=p[x];
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        root:=0;
        tot:=s[y];
        getroot(y,0);
        work(root);
      end;
      i:=e[i].next;
    end;
  end;

begin
  readln(n);
  for i:=1 to n-1 do
  begin
    readln(x,y,z);
    if z=0 then z:=-1;
    add(x,y,z);
    add(y,x,z);
  end;
  f[0]:=n+1;
  tot:=n;
  len:=0;
  getroot(1,0);
  work(root);
  writeln(ans);
end.