dp凸优化/wqs二分学习笔记（洛谷4383 [八省联考2018]林克卡特树lct）

qwq
安利一个凸优化讲的比较好的博客

https://www.cnblogs.com/Gloid/p/9433783.html

但是他的暴力部分略微有点问题
qwq

我还是详细的讲一下这个题+这个知识点吧。

还是先从题目入手。

首先我们分析题目。
因为题目要删除$k$条边，然后再新建$k$条边，求两点的路径和。
那我们不妨这么考虑，对于新连接一条边，相当于链接了原树上的两条链，且链不存在交点。
那我们新建$k$条边，就相当于把原树上没有交的$k+1$条链连接起来。
既然要求权值最大。

那我们就可以直接把题目转换成求树上选出点不相交的$k+1$条链的最大收益。（每个点都是一条链）。

qwq
首先考虑应该怎么

暴力$dp$

由于对于$x$这颗子树，要分情况讨论他属于一条链的端点，中间点，还是不属于链。

所以我们定义状态$dp[i][j][0/1/2]$表示$i$的子树里，已经选了$j$条链，其中$i$这个点不属于链，属于一个链的端点，属于一个链的中心点的最大收益。

首先，因为负权，所以要把所有的$dp$弄成初始值是$-inf$的，其中$dp[i][0][0]$为0。

然后我们考虑应该怎么转移。
对于一个点来说，我们先枚举他的儿子，然后枚举他子树内的链数$j$，枚举分配给他的儿子的链数$z$

那么对于不同的$0/1/2$我们需要分情况讨论。
对于$0$来说，他可以从儿子的任意一个状态转移过来。
对于$1$来说，首先他可以由当前状态的$1$+儿子的$0/1/2$中最大的那个转移，表示不与当前的儿子构成链。
也可以从当前状态的0+儿子的1+$val[i]$，表示从当前儿子上来一条链。
另外的一种情况就是只选与当前儿子相连的边。

对于2来说，其实也是和1同理。

void solve(int x,int fa)
{	
  for (int i=point[x];i;i=nxt[i])
  {
    int p = to[i];
    if(p==fa) continue;
    solve(p,x);
    for (int j=min(k,size[x]);j>=1;j--)
    {
	  for (int z=0;z<=min(j,size[p]);z++)
	  {
	     dp[x][j][2]=max(dp[x][j][2],dp[x][j-z][2]+max(dp[p][z][0],max(dp[p][z][1],dp[p][z][2])));
		 dp[x][j][2]=max(dp[x][j][2],dp[x][j-z][1]+dp[p][z+1][1]+val[i]);
		 if (j>z) dp[x][j][2]=max(dp[x][j][2],dp[x][j-z][1]+val[i]+dp[p][z][0]);
	  	 //本身就有1一条链 
		 dp[x][j][1]=max(dp[x][j][1],dp[x][j-z][1]+max(dp[p][z][0],max(dp[p][z][1],dp[p][z][2])));
	  	 //和当前构成一条链
		 dp[x][j][1]=max(dp[x][j][1],dp[x][j-z][0]+dp[p][z][1]+val[i]);
		 if (j>z) dp[x][j][1]=max(dp[x][j][1],dp[x][j-z-1][0]+dp[p][z][0]+val[i]); 
		 dp[x][j][0]=max(dp[x][j][0],dp[x][j-z][0]+max(dp[p][z][0],max(dp[p][z][1],dp[p][z][2]))); 
      }
	}
  }
}

这里有两个需要注意的问题，首先是$j$要倒着枚举，因为一个链只能被选一次（防止出现旧自己更新新自己的情况）
其次$z$要循环到0（只是用来针对只算一条边的情况。）

然后通过以上的过程，我们就能轻松愉悦的通过$O(nk)$的60分了。
那么应该怎么优化这个过程呢。

凸优化

首先，我们通过做差分，即$ans[i][j]-ans[i][j-1]$，$ans[i][j]$表示$n=i,k=j$时候的答案，发现斜率是逐渐降低的，那我们不难发现在$i$一定的情况下，其实$ans$是关于$j$的上凸函数。（并且一定要满足斜率单调！！！！！！）、

那我们实际上就是要求出来在$j=k$的时候的那个对应的凸包的点是多少。
根据斜率单调
我们可以直接二分一个$mid$，然后让所有的边权都加上$mid$，然后不限制选的链的条数，求最大收益和链数，这个复杂度是$O(n)$的。

因为我们发现，当$mid=inf$的时候，一定是选$n$条，当$inf=-mid$的时候，是选0条，那么因为斜率单调（所以选择的条数一定是随着mid单调变大的），所以我们一定能通过改变这个$mid$，存在某一个$mid$满足恰好选择$k$条，那么正好符合题目要求。

另外一种理解方式。

qwq这个理解方式，每次要减去$mid$，其实本质是一样的。
我们相当于对于每个点求出他的正上方所对应的凸包的点是啥，那么我们通过$erf$这个东西，相当于把原图的上的每个点$x$向下移动$mid\ast x$，那么我们可以发现，随着$mid$的变大，每次随便选的取到的收益的最高的地方，是单调右移的。我们只需要记录一下选的最大收益和链数，然后找到链数等于$k$所对应的$mid$，计算一遍贡献就行。

至于如何做不限制条数的收益，和$nk$类似的$dp$

感觉这个东西要感性+理性啊

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#define mk make_pair
#define ll long long
#define int long long
using namespace std;
inline int read()
{
  int x=0,f=1;char ch=getchar();
  while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
  while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
  return x*f;
}
const int maxn = 3e5+1e2;
const int maxm = 2*maxn;
const int inf = 1e12;
int point[maxn],nxt[maxm],to[maxm],val[maxm];
int n,m,cnt;
int l,r,ans,k;
struct ymh{
	int val,num;
	ymh operator + (ymh b)
	{
		return (ymh){val+b.val,num+b.num};
	}
}; 
ymh max(ymh a,ymh b)
{
	if(a.val==b.val) 
	{
		if(a.num<b.num) return a;
		else return b;
	}
	else
	{
		if(a.val<b.val)  return b;
		else return a;
	}
}
void addedge(int x,int y,int w)
{
	nxt[++cnt]=point[x];
	to[cnt]=y;
	val[cnt]=w;
	point[x]=cnt;
}
ymh dp[maxn][3];
void dfs(int x,int fa,int lim)
{
	dp[x][0]=(ymh){0,0};
	dp[x][1]=(ymh){-inf,-inf};//不存在这种情况 
	dp[x][2]=(ymh){lim,1};//可以将一个点看成一条链 
	for (int i=point[x];i;i=nxt[i])
	{
		int p = to[i];
		if (p==fa) continue;
		dfs(p,x,lim); 
		ymh now = max(dp[p][0],max(dp[p][1],dp[p][2]));
		dp[x][2]=max(dp[x][2],dp[x][2]+now); //本身就有链 
		dp[x][2]=max(dp[x][2],dp[x][1]+dp[p][0]+(ymh){val[i],0}); //新加一条边 
		dp[x][2]=max(dp[x][2],dp[x][1]+dp[p][1]+(ymh){val[i]-lim,-1});//用一条边合并两个链（链数会减一）
		dp[x][1]=max(dp[x][1],dp[x][1]+now);
		dp[x][1]=max(dp[x][1],dp[x][0]+dp[p][1]+(ymh){val[i],0});//沿着之前的链 
		dp[x][1]=max(dp[x][1],dp[x][0]+dp[p][0]+(ymh){val[i]+lim,1});//新增一个链
		dp[x][0]=max(dp[x][0],dp[x][0]+now); 
	}
}
signed main()
{
  n=read(),k=read();
  for (int i=1;i<n;i++)
  {
  	 int x=read(),y=read(),w=read();
  	 addedge(x,y,w);
  	 addedge(y,x,w);
  	 r+=w;
  }
  k++;
  r=inf,l=-inf;
  while(l<=r)
  {
  	 int mid = l+r >> 1;
  	 memset(dp,0,sizeof(dp));
  	 dfs(1,0,mid);
  	 ymh now = max(dp[1][0],max(dp[1][1],dp[1][2]));
  	 if (now.num<=k) ans=mid,l=mid+1;
  	 else r=mid-1;
  }
  memset(dp,0,sizeof(dp));
  dfs(1,0,ans);
  ymh now = max(dp[1][0],max(dp[1][1],dp[1][2]));
  cout<<now.val-k*ans;
  return 0;
}