显然是用堆来维护 每弹出一个解 加入其后继
怎么定义后继 经典做法是点分后维护一个类似超级钢琴的东西
首先对这棵树进行点分治,在分治的时候将所有点到根的距离依次放入一
个数组 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
以及
我们分别从
点之间按照深度 优先级不同 我们选出最深的
我们显然可以用可持久化可并堆来维护后继这个东西 空间是
这样一定没有重复吗?答案是否定的
这样就产生了 (u′,v′) 的重复
我们可以让 u 先变化 然后
这样就不会重复了
#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;
}