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*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;
}