2021牛客国庆集训派对day1 H - Longest Path

Description

给你一棵树，边有边权，
定义一条从u到v的路径,这一路上经过的点为$e_1,e_2,...,e_k$
定义这条路径的权值$f(u,v)$为$\sum (c_{e_i}-c_{e_{i+1}}{)}^2$

对于每个点x，你需要求出 A n s x = max ⁡ i { f ( x , i ) } Ans_x=\max_i\{f(x,i)\} Ansx​=maxi​{f(x,i)}

$1\le n\le 10^5,\sum n\le 10^6$

Solution

看到树上路径第一时间想到点分治，

考虑跨越当前重心的路径，
我们想更新某一个子树的答案，那肯定是从另一颗子树中找到贡献最大的哪一条路径带下去更新，这个找的过程拆试子后本质上就是维护直线找最大值，用set维护即可，

要注意我们每次只需要将，与当前重心连接的边加入set中维护，所以每条边都只会加入一次set中，

总复杂度：$O(n\log (n))$

---

我是zz，

根本不用什么点分治，也不用什么动态维护直线，

动态维护直线可以通过将边按边权排序变为用栈维护直线，
点分治根本没必要，直接跑两边dfs即可。

Code

#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;++i)
#define fod(i,a,b) for(int i=a;i>=b;--i)
#define efo(i,q) for(int i=0;i<(int)B[q].size();++i)
#define sqr(q) ((q)*(q))
using namespace std;
typedef long long LL;
typedef double db;
typedef pair<int,int> pii;
const int N=100500,INF=1e9+7,MXx=100500,MIx=0;
const db ESP=1e-9;
int read(int &n)
{
	bool q=0;n=0;char ch=' ';
	for(;ch!='-'&&(ch<'0'||ch>'9');ch=getchar());
	if(ch=='-')ch=getchar(),q=1;
	for(;ch>='0'&&ch<='9';ch=getchar())n=(n<<3)+(n<<1)+ch-48;
	return q?n=-n:n;
}
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
mt19937 rand_num(seed);  // 大随机数
uniform_int_distribution<int> dist(0, 1000000000);
int RD(int q){return rand_num()%q;}


int n,m;
vector<int>B[N],Bv[N];
int Si[N];
LL Ans[N];
bool z[N];
int ZX,ZX1;
void link(int q,int w,int e)
{
	B[q].push_back(w),Bv[q].push_back(e);
	B[w].push_back(q),Bv[w].push_back(e);
}
int dfsf(int q,int fa)
{
	Si[q]=1;
	efo(i,q)if(!z[B[q][i]]&&B[q][i]!=fa)Si[q]+=dfsf(B[q][i],q);
	return Si[q];
}
void dfss(int q,int fa,int Alln)
{
	int mx=Alln-Si[q];
	efo(i,q)if(!z[B[q][i]]&&B[q][i]!=fa)mx=max(mx,Si[B[q][i]]);
	if(mx<ZX1)ZX1=mx,ZX=q;
	efo(i,q)if(!z[B[q][i]]&&B[q][i]!=fa)dfss(B[q][i],q,Alln);
}
LL tmp;
void dfs(int q,int fa,LL la,LL t,LL tp)
{
	Ans[q]=max(Ans[q],t+tp);
	tmp=max(tmp,t);
	efo(i,q)if(!z[B[q][i]]&&B[q][i]!=fa)
	{
		dfs(B[q][i],q,Bv[q][i],t+sqr(Bv[q][i]-la),tp);
	}
}

struct Val
{
	LL k,b;
	db l,r;
	friend bool operator<(Val q,Val w)
	{
		if(q.l>MXx || w.l>MXx)return q.r<w.r;
		return (q.k<w.k);
	}
};
set<Val>d;
void Add_Line(LL k,LL b)
{
	if(d.size()<1)
	{
		d.insert(Val{k,b,MIx,MXx});
		return;
	}
	auto r=d.lower_bound(Val{k,1,1,1});
	if(r!=d.end() && k * r->l + b <= r->k * r->l + r->b )return;	

	auto l=r;

	db L,R;
	if(r!=d.end())L=r->l,R=r->l;
	else L=MXx,R=MXx;

	if(l==d.begin())l=d.end();
	else --l;

	for(;r!=d.end();)
	{
		db x=(db)(b - r->b)/(r->k - k);
		if(x >= r->r || r->k == k)
		{
			R=r->r;
			auto r1=r;++r1;
			d.erase(r);
			r=r1;
		}else{
			if(x+ESP< r->l)
			{
				R=MIx-1;break;
			}
			Val tmp=*r;
			d.erase(r);
			tmp.l=(x);
			R=(x);
			d.insert(tmp);
			break;
		}
	}

	for(;l!=d.end();)
	{
		db x=(db)(b - l->b)/(l->k - k);
		if(x <= l->l || l->k == k)
		{
			L=l->l;
			auto l1=l;
			if(l1!=d.begin())--l1;
				else l1=d.end();
			d.erase(l);
			l=l1;
		}else{
			if(x-ESP> l->r)
			{
				L=MXx+1;break;
			}
			Val tmp=*l;
			d.erase(l);
			tmp.r=(x);
			L=(x);
			d.insert(tmp);
			break;
		}
	}
	if(L<=R)
		d.insert(Val{k,b,L,R});
}
auto find_pos(db x)
{
	return d.lower_bound(Val{0,0,MXx+1.0,x});
}

void divide(int q)
{
	dfsf(q,0);
	ZX1=INF;
	dfss(q,0,Si[q]);
	z[q=ZX]=1;

	d.clear();
	efo(i,q)if(!z[B[q][i]])
	{
		LL ans=-INF;
		if(d.size())
		{
			auto t=find_pos(Bv[q][i]);
			if(t!=d.end())
			{
				ans=max(ans,t->b + sqr((LL)Bv[q][i]) + t->k * Bv[q][i]);
			}
			if(t!=d.begin())
			{
				--t;
				ans=max(ans,t->b + sqr((LL)Bv[q][i]) + t->k * Bv[q][i]);
			}
		}
		tmp=0;
		dfs(B[q][i],q,Bv[q][i],0,ans);

		Add_Line(-2*Bv[q][i],tmp + sqr((LL)Bv[q][i]));
	}

	d.clear();
	for(int i=(int)B[q].size()-1;i>=0;--i)if(!z[B[q][i]])
	{
		LL ans=-INF;
		if(d.size())
		{
			auto t=find_pos(Bv[q][i]);
			if(t!=d.end())
			{
				ans=max(ans,t->b + sqr((LL)Bv[q][i]) + t->k * Bv[q][i]);
			}
			if(t!=d.begin())
			{
				--t;
				ans=max(ans,t->b + sqr((LL)Bv[q][i]) + t->k * Bv[q][i]);
			}
		}
		tmp=0;
		dfs(B[q][i],q,Bv[q][i],0,ans);
		Ans[q]=max(Ans[q],tmp);
		Add_Line(-2*Bv[q][i],tmp + sqr((LL)Bv[q][i]));
	}

	efo(i,q)if(!z[B[q][i]])divide(B[q][i]);
}
int main()
{
	int q,w,e;
	while(scanf("%d",&n)!=EOF)
	{
		fo(i,1,n-1)read(q),read(w),read(e),link(q,w,e);

		divide(1);

		fo(i,1,n)printf("%lld\n",Ans[i]);

		fo(i,1,n)z[i]=0,B[i].clear(),Bv[i].clear();
		fo(i,1,n)Ans[i]=0;
	}

	return 0;
}