洛谷 P4362 [NOI2002]贪吃的九头龙

https://www.luogu.org/problemnew/show/P4362

首先有个很显然的dp：ans[i][j][k]表示i节点用j号头，i节点为根的子树中共有k个点用大头时i节点为根的子树内的最小答案

可以发现复杂度不太对。。

研究一下，可以发现：如果没有大头的限制，且有>=2个头，那么答案一定是0

毕竟，只要把所有节点按深度分类，同一深度的用同一种头，深度相差1的任意两类用不同种头，那么答案就是0了

也可以发现：有了大头的限制，且有>=3个头，那么确定每个节点是否用大头之后，一定可以确定一种方案（即确定所有不是大头的节点具体用哪个头），并保证任意两个不是大头的节点间不产生贡献（只要把所有不是大头的节点按深度分类就行了）

那么，状态简化为：ans[i][j][k]表示i号节点是/否用大头（由k决定），i号节点为根的子树中有j个点用大头时，i号节点为根的子树中的最小答案

可以做了。。如果有>=3个头，照上面的做dp；如果只有2个头，与>=3个头时的区别仅仅是任意两个不是大头的节点间一定产生贡献，稍微改一下就行

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<vector>
 using namespace std;
 #define fi first
 #define se second
 #define mp make_pair
 #define pb push_back
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 struct E
 {
     int to,nxt,d;
 }e[];
 int f1[],ne;
 int n,m,K;
 int an[][][];
 bool fl1;
 void dfs(int u,int fa)
 {
     int i,j,k,v,t1,t2;
     an[u][][]=an[u][][]=;
     for(k=f1[u];k;k=e[k].nxt)
     {
         v=e[k].to;
         if(v!=fa)
         {
             dfs(v,u);
             for(i=K;i>=;i--)
             {
                 t1=t2=0x3f3f3f3f;
                 for(j=;j<=i;j++)
                 {
                     t1=min(t1,min(
                         an[v][j][]+an[u][i-j][]+e[k].d*fl1,
                         an[v][j][]+an[u][i-j][]));
                     t2=min(t2,min(
                         an[v][j][]+an[u][i-j][],
                         an[v][j][]+an[u][i-j][]+e[k].d));
                 }
                 an[u][i][]=t1;
                 an[u][i][]=t2;
             }
         }
     }
 }
 int main()
 {
     int i,a,b,c;
     memset(an,,sizeof(an));
     scanf("%d%d%d",&n,&m,&K);
     if(n-K<m-)
     {
         puts("-1");
         return ;
     }
     for(i=;i<n;i++)
     {
         scanf("%d%d%d",&a,&b,&c);
         e[++ne].to=b;e[ne].nxt=f1[a];f1[a]=ne;e[ne].d=c;
         e[++ne].to=a;e[ne].nxt=f1[b];f1[b]=ne;e[ne].d=c;
     }
     fl1=(m==);
     dfs(,);
     printf("%d",an[][K][]);
     return ;
 }