【UOJ276】【清华集训2016】汽水（分数规划+点分治）

点此看题面

大致题意： 给你一棵树，要求你选择一条树上路径，使得这条路径上边权的平均值与定值\(k\)的差的绝对值最小。求出这个最小值。

分数规划

看到平均值，首先就应该想到分数规划吧。

我们二分答案\(x\)，设选择了\(m\)条边，每条边边权为\(a_i\)。

则答案\(x\)合法，需要满足：

\[|\frac{\sum_{i=1}^ma_i}m-k|\le x
\]

拆绝对值：

\[-x\le\frac{\sum_{i=1}^ma_i}m-k\le x
\]

每个式子同时乘上\(m\)，去分母：

\[-mx\le \sum_{i=1}^ma_i-mk\le mx
\]

可以将这整个式子分成两部分考虑。

对于左半部分：

\[\sum_{i=1}^ma_i-mk\ge -mx
\]

\[\sum_{i=1}^ma_i-mk+mx\ge0
\]

\[\sum_{i=1}^m(a_i-k+x)\ge0
\]

对于右半部分：

\[\sum_{i=1}^ma_i-mk\le mx
\]

\[\sum_{i=1}^ma_i-mk-mx\le0
\]

\[\sum_{i=1}^m(a_i-k-x)\le0
\]

也就是说，我们只需要判断是否存在一条路径，同时满足以下两个条件：

\[\sum_{i=1}^m(a_i-k+x)\ge0
\]

\[\sum_{i=1}^m(a_i-k-x)\le0
\]

不难发现，如果设\(v_i=a_i-k\)，那么式子就变成了：

\[\sum_{i=1}^m(v_i+x)\ge0
\]

\[\sum_{i=1}^m(v_i-x)\le0
\]

其实，这也就是在读入边权时就将其减去\(k\)，便能将式子化简许多。

点分治

对于树上路径问题，最容易想到的就是点分治了。

对于每一个分治中心\(rt\)，我们先遍历其子树，对于其子树内每一个点\(i\)，存储下三个信息：

1. \(i\)在\(rt\)哪一个子节点的子树中。
2. \(i\)到\(rt\)的路径上的\(\sum(v+x)\)。
3. \(i\)到\(rt\)的路径上的\(\sum(v-x)\)。

如果要符合条件，就需要存在一条路径或者两条不在同一子节点的子树中的路径的\(\sum(v+x)\ge0\)且\(\sum(v-x)\le0\)。

对此，我们只需要将节点信息按\(\sum(v+x)\)从小到大排序，枚举一条路径，用双指针思想来维护另一路径可选区间。

记录下可选区间中\(\sum(v-x)\)的最小值和与最小值不在同一子节点的子树内的另一最小值，然后就可以判断出对于这条路径是否存在另一条路径与其匹配能够符合条件了。

代码

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 50000
#define LL long long
#define DB long double
#define INF 1e18
#define eps 1e-4
#define add(x,y,z) (e[++ee].nxt=lnk[x],e[lnk[x]=ee].to=y,e[ee].v=z)
#define Gmax(x,y) (x<(y)&&(x=(y)))
using namespace std;
int n,ee,lnk[N+5];struct edge {int to,nxt;LL v;}e[N<<1];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		char c,*A,*B,FI[FS];
	public:
		I FastIO() {A=B=FI;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		#undef D
}F;
class DotDivideSolver//点分治
{
	private:
		DB p;int rt,sum,cnt,vis[N+5],Sz[N+5],Mx[N+5];
		struct data//存储一个节点的信息
		{
			int i;DB x,y;I data(CI p=0,Con DB& a=0,Con DB& b=0):i(p),x(a),y(b){}
			I bool operator < (Con data& o) Con {return x<o.x;}//用于排序
		}s[N+5],Mn,Sn;
		I void GetRt(CI x,CI lst=0)//找重心
		{
			Sz[x]=1,Mx[x]=0;for(RI i=lnk[x];i;i=e[i].nxt) !vis[e[i].to]&&
				e[i].to^lst&&(GetRt(e[i].to,x),Sz[x]+=Sz[e[i].to],Gmax(Mx[x],Sz[e[i].to]));
			Gmax(Mx[x],sum-Sz[x]),Mx[x]<Mx[rt]&&(rt=x);
		}
		I void Travel(CI x,CI lst,CI ty,Con DB& a,Con DB& b)//遍历某一子节点的子树
		{
			s[++cnt]=data(ty,a,b);for(RI i=lnk[x];i;i=e[i].nxt)//存储下节点信息
				!vis[e[i].to]&&e[i].to^lst&&(Travel(e[i].to,x,ty,a+e[i].v+p,b+e[i].v-p),0);
		}
		I bool Work(CI x,CI lst=0)
		{
			RI i,j;for(vis[x]=1,cnt=0,i=lnk[x];i;i=e[i].nxt)//遍历子树
				!vis[e[i].to]&&e[i].to^lst&&(Travel(e[i].to,x,e[i].to,e[i].v+p,e[i].v-p),0);
			for(Mn=Sn=data(0,INF,INF),sort(s+1,s+cnt+1),i=1,j=cnt;i<=cnt;++i)//排序
			{
				if(s[i].x>=0&&s[i].y<=0) return true;//如果这单条路径符合条件，返回true
				W(j&&s[i].x+s[j].x>=0)//双指针
					s[j].y<Mn.y?(Mn.i^s[j].i&&(Sn=Mn,0),Mn=s[j],0)//与最小值相比较
					:Mn.i^s[j].i&&s[j].y<Sn.y&&(Sn=s[j],0),--j;//与另一最小值相比较
				if(s[i].i^Mn.i?(s[i].y+Mn.y<0):(s[i].y+Sn.y<0)) return true;//判断是否合法
			}
			for(i=lnk[x];i;i=e[i].nxt) if(!vis[e[i].to])//递归处理子树
				if(rt=0,sum=Sz[e[i].to],GetRt(e[i].to,x),Work(rt,x)) return true;
			return false;
		}
	public:
		I void Clear() {memset(vis,0,sizeof(vis));}//清空
		I bool Solve(Con DB& x) {return p=x,Clear(),Mx[rt=0]=sum=n,GetRt(1),Work(rt);}//点分验证二分的答案
}D;
int main()
{
	RI i,x,y;LL z,t;for(F.read(n),F.read(t),i=1;i^n;++i)
		F.read(x),F.read(y),F.read(z),add(x,y,z-t),add(y,x,z-t);//建边，将边权减k
	DB l=0,r=INF,mid;W(r-l>eps) D.Solve(mid=(l+r)/2)?r=mid:l=mid;//二分答案
	return printf("%.0lf",(double)floor(r)),0;//输出答案，注意精度
}