[可持久化可并堆 || ST表 点分治] BZOJ 3784 树上的路径

显然是用堆来维护 每弹出一个解 加入其后继
怎么定义后继 经典做法是点分后维护一个类似超级钢琴的东西

首先对这棵树进行点分治，在分治的时候将所有点到根的距离依次放入一
个数组$q$中
对于一棵子树里的点，合法的路径一定是$ql$到$qr$的某个数加上自己到重心的距离
定义五元组$(v,l,m,r,w)$，表示当前路径长度为$v$，在$[l,r]$里选出最大值$m$，并加上$w$
用大根堆维护这些五元组，每次取出v最大的元素并扩展出$[l,m−1]$以及$[m+1,r]$两个状态，用ST表查询区间最大值

这里的路径是在点分时在重心被统计 然后我在考试时YY出了个做法
是在dfs树上的LCA处统计

我们考虑$lca$的一棵子树$A$以及$A$之后的所有子树的并$B$
我们分别从$A$里面选出一个点$u$ $B$里面选出一个点$v$ 然后就可以统计所有的路径
点之间按照深度 优先级不同 我们选出最深的$u$和最深的$v$ 然后之后再把$u$改成$u$的后继 $v$改成$v$的后继
我们显然可以用可持久化可并堆来维护后继这个东西 空间是$O(n\log n)$的
这样一定没有重复吗？答案是否定的

$$(u,v)-(u\prime,v)-(u\prime,v\prime)$$
$$(u,v)-(u,v\prime)-(u\prime,v\prime)$$
这样就产生了 $(u\prime,v\prime)$的重复
我们可以让 $u$先变化 然后$v$才变化 也就是一旦 $v$变化了 以后就只能变化$v$
这样就不会重复了

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<queue>
using namespace std;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
inline void write(int x) {
  if (!x) return (void) puts("0");
  static short s[12], t;
  while (x) s[++t] = x % 10, x /= 10;
  while (t) putchar('0' + s[t--]);
  putchar('\n');
}

const int N=50005;

struct edge{
  int u,v,w,next;
}G[N<<1]; int head[N],inum;
inline void add(int u,int v,int w,int p){
  G[p].u=u; G[p].v=v; G[p].w=w; G[p].next=head[u]; head[u]=p;
}

int dis[N]; int fat[N];

inline int ran(){
  static int x=31253125; x+=(x<<4)+1; return x&65536;
}

const int M=10000005;
struct node{
  int i; node *l,*r;
  int val(){ return dis[i]; }
}nodes[M];
int ncnt;

inline node *Mer(node *A,node *B){
  if (!A||!B) return A?A:B;
  if (A->val()<B->val()) return Mer(B,A);
  node *ret=nodes+(++ncnt);
  ret->i=A->i;
  if (ran()){
    ret->l=Mer(A->l,B); ret->r=A->r;
  }else{
    ret->r=Mer(A->r,B); ret->l=A->l;
  }
  return ret;
}

node *rt[N],*par[N];

#define V G[p].v

int lst[N],pnt;
node *tmp[N];

inline void dfs(int u,int fa){
  rt[u]=nodes+(++ncnt); fat[u]=fa; rt[u]->i=u;
  for (int p=head[u];p;p=G[p].next)
    if (V!=fa){
      dis[V]=dis[u]+G[p].w;
      dfs(V,u);
      rt[u]=Mer(rt[u],rt[V]);
    }
  pnt=0;
  for (int p=head[u];p;p=G[p].next)
    if (V!=fa)
      lst[++pnt]=V;
  tmp[pnt+1]=NULL;
  for (int i=pnt;i;i--)
    tmp[i]=Mer(tmp[i+1],rt[lst[i]]);
  for (int i=1;i<=pnt;i++)
    par[lst[i]]=tmp[i+1];
}

int n,m;

struct abcd{ //f==0 lca
  int f,lca; node *u,*v; int val;
  abcd(){ }
  abcd(int l,node *_u){
    f=0; lca=l; u=_u; val=u->val()-dis[lca];
  }
  abcd(int _f,int l,node *_u,node *_v){
    f=_f; lca=l; u=_u; v=_v; val=u->val()+v->val()-2*dis[lca];
  }
  void print(){
    if (f==0) printf("%d %d\n",lca,u->i);
    else printf("%d %d %d\n",lca,u->i,v->i);
  }
  bool operator < (const abcd &B) const{
    return val<B.val;
  }
};

priority_queue<abcd> Q;

int main(){
  int iu,iv,iw;
  freopen("b.in","r",stdin);
  freopen("b.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<n;i++)
    read(iu),read(iv),read(iw),add(iu,iv,iw,++inum),add(iv,iu,iw,++inum);
  dfs(1,0);
  for (int i=1;i<=n;i++)
    Q.push(abcd(i,rt[i]));
  for (int i=2;i<=n;i++)
    if (par[i]!=NULL)
      Q.push(abcd(1,fat[i],rt[i],par[i]));
  while (m--){
    abcd t=Q.top(); Q.pop();
    write(t.val);
    if (t.f==0){
      if (t.u->l) Q.push(abcd(t.lca,t.u->l));
      if (t.u->r) Q.push(abcd(t.lca,t.u->r));
    }else if (t.f==1){
      if (t.v->l) Q.push(abcd(1,t.lca,t.u,t.v->l));
      if (t.v->r) Q.push(abcd(1,t.lca,t.u,t.v->r));
      if (t.u->l) Q.push(abcd(2,t.lca,t.u->l,t.v));
      if (t.u->r) Q.push(abcd(2,t.lca,t.u->r,t.v));
    }else if (t.f==2){
      if (t.u->l) Q.push(abcd(2,t.lca,t.u->l,t.v));
      if (t.u->r) Q.push(abcd(2,t.lca,t.u->r,t.v));
    }
  }
  return 0;
}