BZOJ 3672 NOI2014 购票 树的点分治+斜率优化

题目大意：给定一棵以1为根的有根树，每条边有边权，每个点有三个值pi,qi,li

从一个点可以走到它的某个祖先处，前提是距离d不超过li，花销为pi*d+qi

求从每个点到达根节点的最小花销

这道题的上一份题解：http://blog.csdn.net/popoqqq/article/details/39009219

很不幸我作死去重写了一发233

之前的写法真是SB的1B。。。 为何要暴力- - 明明是分治结构直接排序不行么- -

简述一下做法：

0.先推出斜率优化的动归方程

1.找到当前分治的树结构的重心

2.将分成的子树中含有根节点那部分连重心一并分治

3.将其余子树的点拎出来，按照能走到的最小深度从大到小排序

4.对于每个点，将重心到分治结构的根节点路径上所有的点中能到达的那些点维护一个凸包 然后二分查找

5.对其余子树进行分治

时间复杂度O(nlog^2n)

随便写了一发然后RANK6了- - 果然分治要比链剖要快啊233

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 200200
#define INF 1e15
using namespace std;
struct abcd{
	int to,next;
	long long f;
	bool ban;
}table[M];
int head[M],tot;
int n,type;
int fa[M],size[M],points[M];
long long f[M],p[M],q[M],limit[M],dis[M];
namespace Convex_Hull{
	struct Point{
		long long x,y;
		Point() {}
		Point(long long _,long long __):
			x(_),y(__) {}
	}stack[M];
	int top=M;
	double slope[M];
	double Get_Slope(const Point &p1,const Point &p2)
	{
		return (double)(p1.y-p2.y)/(p1.x-p2.x);
	}
	void Insert(int x)
	{
		Point p=Point(dis[x],f[x]);
		double s=M-top?Get_Slope(p,stack[top]):INF;
		while( M-top>=2 && s>=slope[top] )
			s=Get_Slope(p,stack[++top]);
		stack[--top]=p;
		slope[top]=s;
	}
	Point Query(double s)
	{
		int temp=lower_bound(slope+top,slope+M,s)-slope;
		return stack[temp];
	}
}
void Add(int x,int y,long long z)
{
	table[++tot].to=y;
	table[tot].f=z;
	table[tot].next=head[x];
	head[x]=tot;
}
void DFS1(int x)
{
	int i;
	for(i=head[x];i;i=table[i].next)
	{
		dis[table[i].to]=dis[x]+table[i].f;
		DFS1(table[i].to);
	}
}
void Get_Centre_Of_Gravity(int x,int size,int& cg)
{
	int i;bool flag=1;
	::size[x]=1;
	for(i=head[x];i;i=table[i].next)
		if(!table[i].ban)
		{
			Get_Centre_Of_Gravity(table[i].to,size,cg);
			::size[x]+=::size[table[i].to];
			if(::size[table[i].to]<<1>size)
				flag=0;
		}
	if( (size-::size[x])<<1>size )
		flag=0;
	if(flag) cg=x;
}
void Get_Points(int x)
{
	int i;
	points[++points[0]]=x;
	for(i=head[x];i;i=table[i].next)
		if(!table[i].ban)
			Get_Points(table[i].to);
}
bool Compare(int x,int y)
{
	return dis[x]-limit[x] > dis[y]-limit[y] ;	
}
void Tree_Divide_And_Conquer(int root,int size)
{
	int i,j,cg;
	if(size==1) return ;
	Get_Centre_Of_Gravity(root,size,cg);
	for(i=head[cg];i;i=table[i].next)
		table[i].ban=1;
	Tree_Divide_And_Conquer(root,size-::size[cg]+1);
	points[0]=0;
	for(i=head[cg];i;i=table[i].next)
		Get_Points(table[i].to);
	sort(points+1,points+points[0]+1,Compare);
	using namespace Convex_Hull;
	for(i=1,j=cg,top=M;i<=points[0];i++)
	{
		int x=points[i];
		for(;j!=fa[root]&&dis[j]>=dis[x]-limit[x];j=fa[j])
			Insert(j);
		if(top!=M)
		{
			Point p=Query(::p[x]);
			f[x]=min(f[x],p.y+::p[x]*(dis[x]-p.x)+q[x]);
		}
	}
	for(i=head[cg];i;i=table[i].next)
		Tree_Divide_And_Conquer(table[i].to,::size[table[i].to]);
}
int main()
{
	int i;
	long long length;
	cin>>n>>type;
	for(i=2;i<=n;i++)
	{
		scanf("%d%lld",&fa[i],&length);
		scanf("%lld%lld%lld",&p[i],&q[i],&limit[i]);
		Add(fa[i],i,length);
	}
	DFS1(1);
	memset(f,0x3f,sizeof f);f[1]=0;
	Tree_Divide_And_Conquer(1,n);
	for(i=2;i<=n;i++)
		printf("%lld\n",f[i]);
	return 0;
}