[BZOJ5252][八省联考2018]林克卡特树lct（DP凸优化/WQS二分）

题目：

我是超链接

题解：

题目等价于：在树上选择k+条不相交的链，使其权值和最大。

考虑树形DP（以下的k均为k+1）

一个很直观的想法是用f[i][j]表示第i个节点，子树中选了j条链的最大价值。

但这样是无法转移的，因此我们要考虑到根节点的情况，

令f[0/1/2][i][j]表示i号节点的子树中选了j条链，i节点度数为0/1/2的最大值。

更新的时候分三种情况讨论。

但是这样复杂度是O(N∗K)的，考虑继续优化。

看到这种带k限制类的问题，我们尝试wqs二分

按照套路，我们观察f数组在不同的k下的最优解，不难发现函数是上凸的。严格证明不会，自己意会一下吧。。

按照套路，二分一个边权，加到每条边上，我们可以通过控制边权来控制k的大小。如果边权都很小，肯定是少选几条链比较优，如果边权比较大，肯定是多选几条优。

按照套路，如果我们二分到一个边权，在这里恰好选了k条链，那么这种选法就是最优的。

也就是说，我们对于每一条链添加上一个mid的代价，用来调控选择链的数量

判断的时候不需要枚举k，因此DP一遍的复杂度为O(N)，总复杂度为O(NlogV)

还有就是这玩意儿二分的边界比较诡异。。。

引自这个dalao，学习自DP&dalao

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 1e9
#define LL long long 
using namespace std;
const int N=300005;
int tot,nxt[N*2],point[N],v[N*2];LL c[N*2],mid;
struct hh
{
    LL x,y;
    bool operator <(const hh &a) const {return x<a.x;}
    hh operator +(const hh &a) const {return (hh){x+a.x,y+a.y};}
    hh operator +(const int &bl) const {return (hh){x+bl,y};}
}f[3][N];
void addline(int x,int y,LL z)
{
    ++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; c[tot]=z;
    ++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; c[tot]=z;
}
hh add(hh a){return (hh){a.x-mid,a.y+1};}
void dfs(int x,int fa)
{
    for (int i=point[x];i;i=nxt[i])
        if (v[i]!=fa)
        {
            dfs(v[i],x);
            f[2][x]=max(f[2][x]+f[0][v[i]],add(f[1][x]+f[1][v[i]]+c[i]));
            f[1][x]=max(f[1][x]+f[0][v[i]],f[0][x]+f[1][v[i]]+c[i]);
            f[0][x]=f[0][x]+f[0][v[i]];
        }
    f[0][x]=max(f[0][x],max(add(f[1][x]),max(f[2][x],(hh){-mid,1})));
}
int main()
{
    int n;LL K;scanf("%d%lld",&n,&K);K++;
    LL l,r=0;
    for (int i=1;i<n;i++)
    {
        int x,y;LL z;scanf("%d%d%lld",&x,&y,&z);addline(x,y,z);
        r+=abs(z);
    }
    l=-r;
    while (l<=r)
    {
        mid=(l+r)>>1;
        memset(f,0,sizeof(f));
        dfs(1,0);
        if (f[0][1].y<=K) r=mid-1;
        else l=mid+1;
    }
    mid=l;memset(f,0,sizeof(f));
    dfs(1,0);
    printf("%lld",f[0][1].x+K*mid);
}