題目描述

一場可怕的地震後，人們用N個牲口棚(1≤N≤150，編號1…N)重建了農夫John的牧場。由於人們沒有時間建設多餘的道路，所以現在從一個牲口棚到另一個牲口棚的道路是惟一的。因此，牧場運輸系統可以被構建成一棵樹。John想要知道另一次地震會造成多嚴重的破壞。有些道路一旦被毀壞，就會使一棵含有P(1≤P≤N)個牲口棚的子樹和剩餘的牲口棚分離，John想知道這些道路的最小數目。
輸入輸出格式
輸入格式：
第1行：2個整數，N和P
第2…N行：每行2個整數I和J，表示節點I是節點J的父節點。
輸出格式：
單獨一行，包含一旦被破壞將分離出恰含P個節點的子樹的道路的最小數目。
輸入輸出樣例
輸入樣例#1
11 6
1 2
1 3
1 4
1 5
2 6
2 7
2 8
4 9
4 10
4 11
輸出樣例#1
2
說明
【樣例解釋】
如果道路1-4和1-5被破壞，含有節點（1，2，3，6，7，8）的子樹將被分離出來

題目分析

題意應該就不用說了吧，題目中已經講的很詳細了，實在不懂，自己就花花圖吧。
本題是一道樹形DP，我們令方程dp[i][j]表示為以i為跟節點的子樹恰好包括j個節點。
狀態轉移方程：

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=201;
struct arr{
    int nd,nx;
}bot[N*2];
int du[N],head[N],dp[N][N],vis[
 
N];
int n,k,res=INF,cnt;
void add(int u,int v){bot[++cnt].nd=v; bot[cnt].nx=head[u]; head[u]=cnt;}
inline int read(){
    int x=0,w=1;char ch;
    while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
    if(ch=='-') w=-1,ch=getchar();
    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<
 
1)+(ch-48),ch=getchar();
    return x*w;
}
void dfs(int u){
    dp[u][1]=du[u];vis[u]=1;
    for (int i=head[u];i;i=bot[i].nx){
        int v=bot[i].nd;
        if (!vis[v]){
            dfs(v);
            for (int j=k;j>=1;j--)
                for (int k=1;k<=j;k++)
                    dp[u][j]=min(dp[u][j],dp[u][j-k]+dp[v][k]-2);
    /*樹形揹包型別
    這裡之所以要減去2,是因為在一開始的時候我們將dp[u][1]初始值賦值為du[u]
	這裡表示的是隻有u這一個節點時，要把所有與它相連的邊都切掉
	而現在dp[u][j-k]+dp[v][k]都曾將u->v這條邊切除過，現在我們要將這條邊恢復
	將u和v連在一起，這時我們需要將之前多花費兩次切除給剪掉
    */
        }
    }
    res=min(res,dp[u][k]);
}
int main(){
  	n=read();k=read();
    memset(dp,0x3f,sizeof(dp));
    for (int i=1;i<n;i++) 
    {int u=read(),v=read();add(u,v); add(v,u);du[u]++;du[v]++;}
    dfs(1);
    printf("%d",res);
    return 0;
}

dp[u][j]=min(dp[u][j],dp[u][j-k]+dp[v][k]-2);
這裡之所以要減去2,是因為我們在求dp[u][j-k]和dp[v][k]時，
都曾將u到v這條邊切除過一次，
而且是肯定切除過，因為我們定義的dp[u][j]是指的以u為根的子樹，
恰好包括j個節點的子樹，
而u跟v本來就是父子關係，所以在這兒就是肯定切除的了。
/*這裡有兩重迴圈,第一重迴圈必須是從k到1,第二重可以是1到j或者j到1;
至於第一個為什麼是k到1,我們可以按照01揹包的想法來理解,
正是因為從1到k時我們會多次呼叫到dp[u][j],就相當於做完全揹包時我們會多次呼叫之前的值,
就因為可以無限取,而在這裡我們只能呼叫一次,具體我也講不清楚.
剛剛自己寫了下方程,好像會比較容易理解的,我在這裡寫出來吧.
先來說一下第一個迴圈k到1的情況:
dp[u][5]: min(dp[u][4]+dp[v][1]、dp[u][3]+dp[v][2]、dp[u][2]+dp[v][3]、dp[u][1]+dp[v][4])
dp[u][4]: min(dp[u][3]+dp[v][1]、dp[u][2]+dp[v][2]、dp[u][1]+dp[v][3])
dp[u][3]: min(dp[u][2]+dp[v][1]、dp[u][1]+dp[v][2])
dp[u][2]: min(dp[u][1]+dp[v][1])
在來看一下第一個迴圈1到k的情況
dp[u][2]: min(dp[u][1]+dp[v][1])
dp[u][3]: min(dp[u][2]+dp[v][1]、dp[u][1]+dp[v][2])
dp[u][4]: min(dp[u][3]+dp[v][1]、dp[u][2]+dp[v][2]、dp[u][1]+dp[v][3])
dp[u][5]: min(dp[u][4]+dp[v][1]、dp[u][3]+dp[v][2]、dp[u][2]+dp[v][3]、dp[u][1]+dp[v][4])
是不是發現了這個好對稱啊（QWQ），其實我們可以看出，上面那個更新後的dp[u][5] 、dp[u][4]、dp[u][3] 、dp[u][2]都不會在以後的更新中用到;而另一種情況則會用到之前更新的dp[u][3] 、dp[u][2]…
可能會有一個問題，第一種情況不也用到了很多次的dp[u][3] 、dp[u][2]，但我們可以看到一旦只要dp[u][3]等被更新後，他在下一次更新中就不會出現了。而我們可以這樣理解，這裡的一重迴圈的在更新前所有的dp[u][j]都是一個等級的，比如說現在是等級1，更新一次等級提高一次，並且只能服務於等級比他高的，去更新等級比他高的。所以講到到這大概能理解吧。（或許是我太蠢了，一個很簡單的東西要理解很久QWQ，還請大佬勿噴QWQ）

一個小思考，這道題是不是可以改編一下呢？變成這樣子：求恰好切出p個點大小的子樹的最小代價。（每條邊都有各自的邊權）
如果有大佬想出來，可以跟本蒟交流一波QWQ。歡迎評論！