bzoj3242

如果是树，那么一定选择树的直径的中点

套了个环？裸的想法显然是断开环，然后求所有树的直径的最小值

环套树dp的一般思路，先把环放到根，把环上点下面的子树dp出来，然后再处理环上的情况

设f[i]表示以i为根的子树向下延伸的最长链长度

我们把环上的点扩展一倍，用前缀和维护环上的边权

依次枚举断点，则对直径影响就是max(s[j]-s[i]+f[i]+f[j])

分别维护max(s[j]+f[j])和max(f[i]-s[i])

注意i≠j，所以我们还要维护一个次小值

type node=record
       po,next,num:longint;
     end;
     link=record
       loc:longint;
       mx:int64;
     end;

var tree:array[0..200010*4,1..2] of link;
    e:array[0..200010] of node;
    cut:array[0..200010] of boolean;
    a,b,p,fa:array[0..200010] of longint;
    v:array[0..200010] of boolean;
    f,s:array[0..200010] of int64;
    i,len,n,t,x,y,z:longint;
    ll,ans,lin:int64;
    l1,l2,tp:link;

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

function min(a,b:int64):int64;
  begin
    if a>b then exit(b) else exit(a);
  end;

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

procedure find(x:longint);
  var i,y,h:longint;
  begin
    i:=p[x];
    while i<>-1 do
    begin
      y:=e[i].po;
      if not cut[i] then
      begin
        if fa[y]<>0 then
        begin
          h:=x;
          while h<>y do
          begin
            inc(t);
            a[t]:=h;
            b[t]:=f[h];
            h:=fa[h];
          end;
          inc(t);
          a[t]:=h;
          b[t]:=e[i].num;
          break;
        end
        else begin
          cut[i]:=true;
          cut[i xor 1]:=true;
          fa[y]:=x;
          f[y]:=e[i].num;
          find(y);
        end;
      end;
      if t<>0 then break;
      i:=e[i].next;
    end;
  end;

procedure dfs(x:longint);
  var i,y:longint;
  begin
    v[x]:=true;
    f[x]:=0;
    i:=p[x];
    while i<>-1 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        dfs(y);
        lin:=max(lin,f[y]+f[x]+e[i].num);
        f[x]:=max(f[x],f[y]+e[i].num);
      end;
      i:=e[i].next;
    end;
  end;

procedure update(var c:link; a:link; b:link);
  begin
    c.mx:=a.mx;
    c.loc:=a.loc;
    if c.mx<b.mx then
    begin
      c.loc:=b.loc;
      c.mx:=b.mx;
    end;
  end;

procedure build(i,l,r:longint);
  var m:longint;
  begin
    if l=r then
    begin
      tree[i,1].mx:=f[a[l]]+s[l];
      tree[i,1].loc:=l;
      tree[i,2].mx:=f[a[l]]-s[l];
      tree[i,2].loc:=l;
    end
    else begin
      m:=(l+r) shr 1;
      build(i*2,l,m);
      build(i*2+1,m+1,r);
      update(tree[i,1],tree[i*2,1],tree[i*2+1,1]);
      update(tree[i,2],tree[i*2,2],tree[i*2+1,2]);
    end;
  end;

function ask(i,l,r,w,x,y:longint):link;
  var m:longint;
      s,s1,s2:link;
  begin
    if (x<=l) and (y>=r) then exit(tree[i,w])
    else begin
      m:=(l+r) shr 1;
      if x>m then exit(ask(i*2+1,m+1,r,w,x,y));
      if y<=m then exit(ask(i*2,l,m,w,x,y));
      s1:=ask(i*2,l,m,w,x,y);
      s2:=ask(i*2+1,m+1,r,w,x,y);
      update(s,s1,s2);
      exit(s);
    end;
  end;

begin
  len:=-1;
  fillchar(p,sizeof(p),255);
  readln(n);
  for i:=1 to n do
  begin
    readln(x,y,z);
    add(x,y,z);
    add(y,x,z);
  end;
  fa[1]:=-1;
  find(1);
  for i:=1 to t do
  begin
    v[a[i]]:=true;
    a[i+t]:=a[i];
    b[i+t]:=b[i];
  end;
  for i:=1 to 2*t do
    s[i]:=s[i-1]+b[i-1];
  for i:=1 to t do
    dfs(a[i]);
  build(1,1,2*t);
  ans:=1000000000000010;
  for i:=1 to t do
  begin
    l1:=ask(1,1,2*t,1,i+1,i+t);
    l2:=ask(1,1,2*t,2,i+1,i+t);
    if l1.loc=l2.loc then
    begin
      ll:=0;
      if l1.loc>i+1 then
      begin
        tp:=ask(1,1,2*t,2,i+1,l1.loc-1);
        ll:=max(ll,l1.mx+tp.mx);
      end;
      if l2.loc<i+t then
      begin
        tp:=ask(1,1,2*t,1,l2.loc+1,i+t);
        ll:=max(ll,l2.mx+tp.mx);
      end;
      ans:=min(ans,max(ll,lin));
    end
    else ans:=min(ans,max(l1.mx+l2.mx,lin));
  end;
  writeln(ans/2:0:1);
end.