[bzoj5129][点分治][最短路]树上传送

Description

扔个传送门

题解

为什么OZY这么强啊…
我还打个屁啊…
一开始就想歪了想到优化建图去了…一通魔搞之后无功而返
单考虑dij怎么做，我们发现从堆中拿出来一个点之后，能扩展的点的权是都是$d[x]+cost[x]$
于是可以堆按照$d[x]+cost[x]$排序，这样显然能被扩展到的点一定是最小的
于是我们就需要保证每个点被扩展的次数小于某个定值
对这棵树点分，每个点保存以他为重心后BFS序开始扫的序号
当我们从堆中拿出这个点的时候，跳他的分治父亲，显然可以通过到父亲的距离和BFS序开始扫的编号确定这个点到下一个被扩展的点的最长距离是什么
我们发现，在这种情况下，每个点只会被扩展一次
复杂度就是$nlogn$的了

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline int read()
{
	int f=1,x=0;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
int stack[20];
inline void write(LL x)
{
	if(x<0){putchar('-');x=-x;}
    if(!x){putchar('0');return;}
    int top=0;
    while(x)stack[++top]=x%10,x/=10;
    while(top)putchar(stack[top--]+'0');
}
inline void pr1(int x){write(x);putchar(' ');}
inline void pr2(LL x){write(x);putchar('\n');}
const int MAXN=300005;
struct node{int x,y,next;}a[2*MAXN];int len,last[MAXN];
void ins(int x,int y){len++;a[len].x=x;a[len].y=y;a[len].next=last[x];last[x]=len;}

int first[MAXN],Log[2*MAXN],bin[25],dep[MAXN],dfn[2*MAXN],id;
void pre_tree_node(int x,int fa)
{
	dfn[++id]=x;first[x]=id;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa)
		{
			dep[y]=dep[x]+1;
			pre_tree_node(y,x);
			dfn[++id]=x;
		}
	}
}
int mn[25][2*MAXN];
void init()
{
	for(int i=1;i<=id;i++)mn[0][i]=dfn[i];
	for(int i=1;bin[i]<=id;i++)
		for(int x=1;x+bin[i]-1<=id;x++)
			mn[i][x]=dep[mn[i-1][x]]<dep[mn[i-1][x+bin[i-1]]]?mn[i-1][x]:mn[i-1][x+bin[i-1]];
}
int lca(int x,int y)
{
	x=first[x];y=first[y];
	if(x>y)swap(x,y);
	int K=Log[y-x+1];
	return dep[mn[K][x]]<dep[mn[K][y-bin[K]+1]]?mn[K][x]:mn[K][y-bin[K]+1];
}
int dis(int x,int y)
{
	int LA=lca(x,y);
	return dep[x]+dep[y]-2*dep[LA];
}
	

vector<pii> vec[MAXN];int begin[MAXN];
queue<pii> li;
bool vis[MAXN];
int in[MAXN],tim;
void BFS(int S)
{
	li.push(mp(S,0));tim++;
	while(!li.empty())
	{
		int x=li.front().first,de=li.front().second;li.pop();
		in[x]=tim;vec[S].push_back(mp(x,de));
		for(int k=last[x];k;k=a[k].next)if(in[a[k].y]!=tim&&vis[a[k].y])li.push(mp(a[k].y,de+1));
	}
}
int tot[MAXN],f[MAXN],totsum,G;
void go(int x,int fa)
{
	tot[x]=1;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa&&vis[y])go(y,x),tot[x]+=tot[y];
	}
}
void dfs(int x,int fa)
{
	tot[x]=1;f[x]=0;
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(y!=fa&&vis[y])dfs(y,x),tot[x]+=tot[y],f[x]=max(f[x],tot[y]);
	}
	f[x]=max(f[x],totsum-tot[x]);
	if(!G||f[x]<f[G])G=x;
}
int refa[MAXN];
void getrt(int x)
{
	vis[x]=false;
	BFS(x);go(x,0);int lin=tot[x];
	for(int k=last[x];k;k=a[k].next)
	{
		int y=a[k].y;
		if(vis[y])
		{
			totsum=lin;G=0;
			dfs(y,x);refa[G]=x;
			getrt(G);
		}
	}
}

int lim[MAXN],cost[MAXN];
priority_queue<pll,vector<pll>,greater<pll> > hp;
LL d[MAXN];

int main()
{
	bin[0]=1;for(int i=1;i<=20;i++)bin[i]=bin[i-1]<<1;
	Log[1]=0;for(int i=2;i<2*MAXN;i++)Log[i]=Log[i>>1]+1;
	int n=read(),st=read();
	for(int i=1;i<n;i++)
	{
		int x=read(),y=read();
		ins(x,y);ins(y,x);
	}
	pre_tree_node(1,0);
	init();
	memset(vis,true,sizeof(vis));
	totsum=n;dfs(1,0);
	getrt(G);
	
	for(int i=1;i<=n;i++)lim[i]=read(),cost[i]=read();
	
	memset(d,63,sizeof(d));d[st]=0;
	memset(vis,false,sizeof(vis));
	hp.push(mp(d[st]+cost[st],st));
	while(!hp.empty())
	{
		int x=hp.top().second;hp.pop();
		if(vis[x])continue;vis[x]=1;
		int temp=x;
		while(x!=0)
		{
			int nw=-1,d1=dis(temp,x);
			for(int i=begin[x];i<vec[x].size();i++)
			{
				int d2=vec[x][i].second,u1=vec[x][i].first;
				if(d1+d2>lim[temp]){nw=i;break;}
				if(d[u1]>d[temp]+cost[temp])
				{
					d[u1]=d[temp]+cost[temp];
					hp.push(mp(d[u1]+cost[u1],u1));
				}
			}
			if(nw==-1)begin[x]=vec[x].size();
			else begin[x]=nw;
			x=refa[x];
		}
	}
	for(int i=1;i<=n;i++)pr2(d[i]);
	return 0;
	
}