洛谷 4383 [八省联考2018]林克卡特树lct——树形DP+带权二分

题目：https://www.luogu.org/problemnew/show/P4383

关于带权二分：https://www.cnblogs.com/flashhu/p/9480669.html

自己只能想到 “如果把负边看作不存在，那么分出的连通块的直径一定可以被整个连进最终路径里”。然后就不知道连通块不是恰好 K+1 个怎么办，且也不知道是不是对的……

原来可以直接把问题看成 “选出恰好 K+1 条不相交路径” 。这样也考虑到了 “恰好 K 条” 的限制，并且好像挺对的。

结果自己还是不太会……看题解发现原来只需记录 [ 0 / 1 / 2 ] 表示 “未连边” 、 “和孩子连了一条边” 、 “和孩子连了两条边” 就能转移了。

自己把 [ 0 ] 视作 “不向上传” ，那么 return 的时候 [ 0 ] 就可以对 [ 1 ] 、 [ 2 ] 取 max 了。

在 “向上传” 的过程中， [ 2 ] 是没用的。之所以要记录，是为了让 “ [ 1 ] + [ 1 ] ” 的情况不要转移到 [ 0 ] ，这样当前点就不会匹配很多路径了。

于是可以 n*K² DP。自己写了一下只得了 35 分……

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
int rdn()
{
  int ret=;bool fx=;char ch=getchar();
  while(ch>''||ch<''){if(ch=='-')fx=;ch=getchar();}
  while(ch>=''&&ch<='')ret=ret*+ch-'',ch=getchar();
  return fx?ret:-ret;
}
ll Mx(ll a,ll b){return a>b?a:b;}
ll Mn(ll a,ll b){return a<b?a:b;}
const int N=3e5+,M=; const ll INF=3e11+;
int n,m,hd[N],xnt,to[N<<],nxt[N<<],w[N<<];
int siz[N]; ll dp[N][][M];
void add(int x,int y,int z)
{to[++xnt]=y;nxt[xnt]=hd[x];hd[x]=xnt;w[xnt]=z;}
void cz(int cr,int i,int j,ll s)
{dp[cr][i][j]=Mx(dp[cr][i][j],s);}
void dfs(int cr,int fa)
{
  for(int i=;i<;i++)
    for(int j=;j<=m;j++) dp[cr][i][j]=-INF;
  dp[cr][][]=; siz[cr]=;
  for(int i=hd[cr],v;i;i=nxt[i])
    if((v=to[i])!=fa)
      {
    dfs(v,cr); siz[cr]+=siz[v];
    for(int j=Mn(siz[cr],m);j>=;j--)
      for(int k=;k<=j&&k<=siz[v];k++)
        {
          cz(cr,,j,dp[cr][][j-k]+dp[v][][k]);
          if(k)cz(cr,,j,dp[cr][][j-k+]+dp[v][][k]+w[i]);
          cz(cr,,j,Mx(dp[cr][][j-k]+dp[v][][k]+w[i],
               dp[cr][][j-k]+dp[v][][k]));
          cz(cr,,j,dp[cr][][j-k]+dp[v][][k]);
        }
      }
  for(int j=;j<=m;j++)
    dp[cr][][j]=Mx(dp[cr][][j],Mx(dp[cr][][j],dp[cr][][j]));
  dp[cr][][]=Mx(dp[cr][][],);
}
int main()
{
  n=rdn();m=rdn()+;
  for(int i=,u,v,z;i<n;i++)
    {
      u=rdn();v=rdn();z=rdn();
      add(u,v,z);add(v,u,z);
    }
  dfs(,);
  printf("%lld\n",dp[][][m]);
  return ;
}

可以用带权二分的知识来优化。

随着 K 的增加，答案是先增大再减小的。可以感性理解。

所以就可以带权二分。二分选一条路径额外带来的收益（可为负），然后不限制路径条数地 DP ，只是附带着记录一下选了几条路。最后看选出来的路径如果多于 K+1 条，说明选一条路径的收益太高；不然说明收益太低。当不看路径条数地 DP 的最优解恰好选了 K+1 条路径时就可以退出了。答案就是现在这个最优解减去 “路径条数 * mid” 。

当路径条数不同但最优解相同地时候，可能二分不到 “恰好 K+1 条路径” 。所以 DP 的时候设第二关键字为路径条数，比如设成值相等时路径越少越好，那么最优解附带的路径条数 <= K+1 的时候也可能就是答案。所以认为答案是二分到的 “最大的 <= K+1 条路径” 的解即可。

关于二分的范围，自己是让 l = 所有正边权之和 ， r = 边权最大值。然后 l-- , r++ 。

　　想让路径选得最少，考虑选路径的最优情况就是把所有正边权都选上了，所以让 l 为这个值减1，这样最优就是一条边也不选；

　　想让路径选得最多，即每个点自己是一条路径。如果不是的话，就是在这个基础上把两个点连在一条路径里，好处是得到一个边权；所以让 r 是最大的边权加1，这样最优就是每个点自己是一条路径。

DP 的转移和暴力一样。

然后调了很久。终于发现自己把 “新增一条路径” 放在 “从孩子转移过来” 之后。这样的话 “以当前点为一个端点的路径” 就不能继承上 “在当前点子树（不含当前点）中完结的路径” 的贡献了！

发现自己的 n*K² DP 也在这个地方写错了。怪不得是 WA 而不是 TLE ……

#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
using namespace std;
int rdn()
{
  int ret=;bool fx=;char ch=getchar();
  while(ch>''||ch<''){if(ch=='-')fx=;ch=getchar();}
  while(ch>=''&&ch<='')ret=ret*+ch-'',ch=getchar();
  return fx?ret:-ret;
}
ll Mn(ll a,ll b){return a<b?a:b;}
ll Mx(ll a,ll b){return a>b?a:b;}
const int N=3e5+;ll INF=3e11+;
int n,m,hd[N],xnt,to[N<<],nxt[N<<],w[N<<];
ll dp[N][],mid; int f[N][];
void add(int x,int y,int z)
{to[++xnt]=y;nxt[xnt]=hd[x];hd[x]=xnt;w[xnt]=z;}
void cz(int cr,int i,ll w0,int f0,ll w1,int f1)
{
  if(w0==w1) dp[cr][i]=w0,f[cr][i]=Mn(f0,f1);//Mn
  else if(w0>w1)dp[cr][i]=w0,f[cr][i]=f0;
  else dp[cr][i]=w1,f[cr][i]=f1;
}
void dfs(int cr,int fa)
{
  /*dp[cr][0]=0; dp[cr][1]=dp[cr][2]=-INF;
    f[cr][0]=0; f[cr][1]=0; f[cr][2]=0;*/
  dp[cr][]=; dp[cr][]=mid; dp[cr][]=-INF;
  f[cr][]=; f[cr][]=; f[cr][]=;
  for(int i=hd[cr],v;i;i=nxt[i])
    if((v=to[i])!=fa)
      {
    dfs(v,cr);
    cz(cr,,dp[cr][]+dp[v][]+w[i]-mid,f[cr][]+f[v][]-,
       dp[cr][]+dp[v][],f[cr][]+f[v][]);
    cz(cr,,dp[cr][]+dp[v][],f[cr][]+f[v][],
       dp[cr][]+dp[v][]+w[i],f[cr][]+f[v][]);
    dp[cr][]+=dp[v][];
    f[cr][]+=f[v][];
      }
  cz(cr,,dp[cr][],f[cr][],dp[cr][],f[cr][]);
  cz(cr,,dp[cr][],f[cr][],dp[cr][],f[cr][]);
  //cz(cr,1,dp[cr][1],f[cr][1],mid,1);//new
}
int main()
{
  n=rdn();m=rdn()+;ll l=,r=-INF;
  for(int i=,u,v,z;i<n;i++)
    {
      u=rdn();v=rdn();z=rdn();
      add(u,v,z); add(v,u,z);
      if(z>=)l-=z; r=Mx(r,z);
    }
  l--; r++; ll ans,ret;
  while(l<=r)
    {
      mid=l+r>>;
      dfs(,);
      if(f[][]<=m)
    {
      ans=dp[][];ret=mid;l=mid+;
      if(f[][]==m)break;
    }
      else r=mid-;
    }
  printf("%lld\n",ans-ret*m);
  return ;
}