luogu P1272 重建道路

嘟嘟嘟

这好像是一种树上背包。

我们令dp[i][j] 表示在 i 所在的子树中（包括节点 i）分离出一个大小为 j 的子树最少需割多少条边。

那么转移方程就是

　　dp[u][j] = min(dp[u][j], dp[u][j - k] + dp[v][k] - 1) (v是u的一个儿子)

理解起来就是在u所在子树中切 j 个节点，等于在u中切 j - k 个节点加上在v所在子树中切 k 个节点所需要切的边数之和。又因为切出来的这两部分要合并得到一个节点数为 j 的，所以要减1.

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<cctype>
 #include<vector>
 #include<stack>
 #include<queue>
 using namespace std;
 #define enter puts("")
 #define space putchar(' ')
 #define Mem(a, x) memset(a, x, sizeof(a))
 #define rg register
 typedef long long ll;
 typedef double db;
 const int INF = 0x3f3f3f3f;
 const db eps = 1e-;
 const int maxn = ;
 inline ll read()
 {
     ll ans = ;
     char ch = getchar(), last = ' ';
     while(!isdigit(ch)) {last = ch; ch = getchar();}
     while(isdigit(ch)) {ans = ans *  + ch - ''; ch = getchar();}
     if(last == '-') ans = -ans;
     return ans;
 }
 inline void write(ll x)
 {
     if(x < ) x = -x, putchar('-');
     if(x >= ) write(x / );
     putchar(x %  + '');
 }

 int n, p;
 vector<int> v[maxn];
 int du[maxn], siz[maxn];
 int dp[maxn][maxn];

 void dfs(int now)
 {
     siz[now] = ;
     for(int i = ; i < (int)v[now].size(); ++i)
     {
         dfs(v[now][i]);
         siz[now] += siz[v[now][i]];
         for(int j = siz[now]; j >= ; --j)
             for(int k = ; k < j; ++k)
                 dp[now][j] = min(dp[now][j], dp[now][j - k] + dp[v[now][i]][k] - );
     }
 }

 int main()
 {
     n = read(); p = read();
     for(int i = ; i < n; ++i)
     {
         int x = read(), y = read();
         v[x].push_back(y);
         du[x]++;
     }
     for(int i = ; i <= n; ++i)
         for(int j = ; j <= n; ++j) dp[i][j] = INF;
     for(int i = ; i <= n; ++i) dp[i][] = du[i];
     dfs();
     int ans = dp[][p];        //本来就是根节点
     for(int i = ; i <= n; ++i) ans = min(ans, dp[i][p] + );        //还要切除和父亲连的一条边
     write(ans); enter;
     return ;
 }