【算法竞赛】背包问题

01背包：

问题描述：

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 Vi，价值是 Wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

问题分析：

为方便描述， 第i件物品的体积v， 价值w 分别记成 目标分量goal （简记gl）， 约束分量limit（简记lmt）； 容量V 记成 最大约束总量lmt_max

//问题描述
struct bag{
	int gl, lmt;        //目标分量goal， 约束分量limit 
}b[maxn];
int n, lmt_max        //物品数， 最大约束总量

大问题：f(n, lmt_max)

小问题：max{ f(n-1, lmt_max - k*lmt) }， k = 0, 1

定义dp[i][j]：考虑前 i 个物品， 约束值 不超过 j 的 最大目标函数值

转态转移方程：dp[i][j] = max{ dp[i-k][j - k*lmt] + k*gl }， k = 0 或 (k = 1 && j >= lmt)

                                  或= max{ dp[i-1][j], dp[i-1][j - lmt] + gl }

//O(n^2)
int dp[maxn][maxn];
int f(){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=lmt_max; j++){
			if(j >= b[i].lmt){
				dp[i][j] = max(dp[i-1][j], dp[i-1][j-b[i].lmt] + b[i].gl);
			}
			else dp[i][j] = dp[i-1][j];
		}
	}
	return dp[n][lmt_max];
}

滚动数组优化（空间复杂度优化）：

可以观察到每个状态都跟 上层的左边两个状态 有关（如图）

 如果把dp数组第一维压缩成“一点”（空间复杂度降1阶），新的状态应与左边的状态有关（如图）

此时应考虑一个问题：是从左往右递推， 还是从右往左？

如果从左往右递推， 假设左边的状态已通过该方式更新，那么新状态是通过该层的状态更新的， 与递推关系矛盾(因为每个状态都跟 (逻辑上的)上层的左边两个状态 有关)，其原因是在递推时(逻辑上的)上层的被覆盖了， 因此从左往右不可行

考虑从右往左递推， 每个新状态都是跟（逻辑上的）上层左边的状态有关， 递推的新状态与前面的新状态没有影响， 因此采用从右往左递推

//O(n^2)
int dp[1005];
int f(){
	for(int i=1; i<=n; i++){
		for(int j=lmt_max; j>=1; j--){
			if(j>=b[i].lmt)
				dp[j] = 
				max(dp[j], dp[j-b[i].lmt] + b[i].gl);
			else dp[j] = dp[j];        //可省略
		}
	}
	return dp[lmt_max];
}

完全背包：

问题描述：

有 N种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

问题分析：

01背包 在选择是否加入 物品i (可以理解为选择 0个 或者 一个 物品i)， 此状态是最优的

完全背包 与 01背包的主要区别就是， 在选择物品i时， 考虑加入k(=0..t)个物体i 时此状态是最优的

容易得出：

状态转移方程: dp[i][j] = max{ dp[i-1][j - k*lmt] }， k = 0..t && j >= t * lmt

//O(n^3)
int f(){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=lmt_max; j++){
			for(int k=0; k*b[i].lmt<=j; k++){
				dp[i][j] = 
				max(dp[i][j], dp[i-1][j-k*b[i].lmt] + k*b[i].gl);
			}
		}
	}
	return dp[n][lmt_max];
}

完全背包优化：

然而O(n^3)的复杂度过大， 对于 8e3 的数据是不可行的

dp[i][j] = max{ dp[i-1][j - k*lmt] + k*gl }， k = 0..t

dp[i][j - lmt] = max{ dp[i-1][j - lmt - k*lmt] + k*gl }, k = 0..t-1

                     = max{ dp[i-1][j - (k+1)*lmt] + k*gl }, k = 0..t-1

dp[i][j - lmt] + gl = max{ dp[i-1][j - (k+1)*lmt] + (k+1)*gl }, k = 0..t-1

                            = max{ dp[i-1][j - k*lmt] + k*gl }, k = 1..t

那么， dp[i][j] = max{ dp[i-1][j - k*lmt] + k*gl }， k = 0..t

                        = max{ dp[i-1][j],   [max{ dp[i-1][j - k*lmt] + k*gl }, k = 1..t] }

                        = max{ dp[i-1][j], dp[i][j-lmt] + gl }

可以观察到， 优化后完全背包的状态方程与 01背包的状态方程 仅有一个下标的不同， 而且复杂度降为了O(n^2)

//O(n^2)
int f(){
	for(int i=1; i<=n; i++){
		for(int j=1; j<=lmt_max; j++){
			if(j >= b[i].lmt)
				dp[i][j] = 
				max(dp[i-1][j], dp[i][j-b[i].lmt] + b[i].gl);
			else dp[i][j] = dp[i-1][j];
		}
	}
	return dp[n][lmt_max];
}

更新中...