证明：有依赖背包结点数优化后为O(n^2)

证明：有依赖背包结点数优化后为$O(n^2)$

siz[u]表示以u为根的树的结点数
深搜过程中，siz[u]表示根结点为u的树的根结点加上前i个子树的结点数。

1. 根结点为u的树取前i个子树的结点，取到的结点数量小于等于siz[u]
2. 根结点为v的子树取到的结点数量小于等于siz[v]

例：
洛谷 P2014 [CTSC1997] 选课 使用结点数优化

#include<bits/stdc++.h>
using namespace std;
#define N 305
int n, m, w[N], siz[N], dp[N][N];//dp[u][i][j]：结点u的前i个孩子，最多选择j门课能获得的最大学分 
vector<int> edge[N];
void dfs(int u)
{
	dp[u][1] = w[u];//选1门课，就只能选自己 
	siz[u] = 1;
	for(int v : edge[u])
	{
		dfs(v);
		siz[u] += siz[v];
		for(int j = min(m, siz[u]); j >= 1; --j)//在树中选j门课 
			for(int k = 0; k < j && k <= siz[v]; ++k)//在子树v中选了k门课 （因为还要选v，最多选j-1门） 
				dp[u][j] = max(dp[u][j], dp[u][j-k]+dp[v][k]); 
	}
}
int main()
{
	int f;
	cin >> n >> m;
	m++;//算上0号结点 
	for(int i = 1; i <= n; ++i)
	{
		cin >> f >> w[i];
		edge[f].push_back(i);
	}
	dfs(0);
	cout << dp[0][m];
	return 0;
}

假设m很大，不考虑j的影响，其核心代码可以视作：

void dfs(int u)
{
	dp[u][1] = w[u];//选1门课，就只能选自己 
	siz[u] = 1;
	for(int v : edge[u])
	{
		dfs(v);
		siz[u] += siz[v];
		for(int j = siz[u]; j >= 1; --j)
			for(int k = 0; <= siz[v]; ++k)
				dp[u][j] = max(dp[u][j], dp[u][j-k]+dp[v][k]); 
	}
}

设根结点为u的树的结点数量为n，
证明：上述代码的复杂度为$O(n^2)$
设结点u有k个子树1、2、3、…、k
每个子树的结点数分别为$a_1,a_2,...,a_k$，因此有$a_1+a_2+...+a_k=n-1$
该代码中，双重循环内层语句的运行次数近似为：$a_1\ast a_1+(a_1+a_2)\ast a_2+(a_1+a_2+a_3)\ast a_3+...+(a_1+...+a_k)\ast a_k$
使用数学归纳法：

1. 如果结点u的孩子都是叶子结点，则$a_1,a_2,...,a_k$都为1，那么语句运行次数为：$1+2+...+k=(1+k)\cdot k/2\le k^2$
2. 如果结点u的孩子不都是叶子结点，对于子树x的递归调用，语句运行次数$\le a_x^2$，因此总语句运行次数$\le a_1\ast a_1+(a_1+a_2)\ast a_2+(a_1+a_2+a_3)\ast a_3+...+(a_1+...+a_k)\ast a_k+a_1^2+a_2^2+...+a_k^2$
   将前面每项写开
   $a_1^2$
   $a_1\ast a_2+a_2^2$
   $a_1\ast a_3+a_2\ast a_3+a_3^2$
   …
   $a_1\ast a_k+...+a_k^2$
   相加得
   $a_1\ast {\sum }_{i=1}^k{a}_i+a_2\ast {\sum }_{i=2}^k{a}_i+a_3\ast {\sum }_{i=3}^k{a}_i+...+a_k\ast a_k<$
   $a_1\ast {\sum }_{i=1}^k{a}_i+a_2\ast {\sum }_{i=1}^k{a}_i+a_3\ast {\sum }_{i=1}^k{a}_i+...+a_k\ast {\sum }_{i=1}^k{a}_i=({\sum }_{i=1}^k{a}_i{)}^2=(a_1+a_2+...+a_k{)}^2=(n-1{)}^2<n^2$
   而$a_1^2+a_2^2+...+a_k^2<(a_1+a_2+...+a_k{)}^2=(n-1{)}^2<n^2$
   因此语句总运行次数$<2n^2$
   因此该算法的时间复杂度为$O(n^2)$