关于滚动数组的笔记（第一篇博客）

背景

最近在学习动态规划==真是个麻烦的小机灵鬼

做到的一道小小的题
P1048 采药

做法

（1）直接DP（一堆离题的废话）

这道题很显然就是一道01背包问题但是它的确是我做的第一道DP题

所以首先设计状态和写出状态转移方程
这俩货是真的难搞

---

一开始我设计的是记f(x)为采了前x种药材的最大价值，但是，采了药之后会消耗一定的时间，这样就导致了未来再采药时会受到采了第x株药的影响。

例如总时间是10，有消耗时间和价值分别为（6，6），（7.8），（4，3）的三种药材，如果用上面的设计状态，那么f（1）就会等于6（暂时不管时间），这样按理说f（2）应该等于第一和第二种药材的价值之和，也即是f（2）= 13。

很显然这是错的因为这里没有考虑到f（1）所消耗的时间对f（2）的影响，所以很明显这种设计状态并不满足无后效性原则。

“未来与过去无关”，这就是无后效性。

怎么办呢

“如果有元素导致了违背无后效性，那么就将它考虑进设计状态——rxz”

所以后来改成了f（n，k），表示在拥有的时间为k的时候，装入前n件药品的剩余时间的最大值。瞬间就看着很正确了吧！

---

接着就是状态转移方程，在这里很容易得到，如果不选第n个药品，那就转移成f（n-1，k），如果选，则转移成f（n-1，k-v[ n ]，然后在里面选一个最大值即可。
即

f（n，k）=max（f（n-1，k），f（n-1，k-v[ n ]））

（其中n表示前n个物品，k表示所拥有的时间）

然后利用这个式子打出表格模拟一下刚刚的数据，每一个格子表示在能装入前n个物品时（行），拥有的时间为k时（列），药品最大价值。

n\k	1	2	3	4	5	6	7	8	9	10
1	0	0	0	0	0	6	6	6	6	6
2	0	0	0	0	0	6	8	8	8	8
3	0	3	3	3	3	6	8	9	11	11

这个就是模拟出来的结果，最后答案是11

---

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 10005;
int t[N],val[N];
int dp[N][N];//dp[i][k]表示在时间为k的情况下采前n株药材的最大价值

int main() {
	int T,M;
	cin>> T>> M;
	for (int i = 1; i <= M; i++) {
		cin>> t[i]>> val[i];
	}
	for (int i = 1; i <= M; i++) {
		for (int k = 1; k <= T; k++) {//这里的k从T到1和从1到T都是可以的 
			if (k >= t[i])
				dp[i][k] = max(dp[i-1][k-t[i]]+val[i],dp[i-1][k]);
			else if (k < t[i])
				dp[i][k] = dp[i-1][k]; 
			cout << dp[i][k]<<" ";
		}
		cout << endl;
	}
	cout << dp[M][T];
	return 0;
}

重点！滚动数组

由状态转移方程可以发现，每次要计算某一格的价值，只与上一行的某格有关（意思就是不与上两行或三行，下一行或两行有关），所以每计算完一行，上一行的数据就没用了！！！
所以我们可以联想到，能否只用一维的数组，将其中的数据通过某种手段处♂理完之后，再覆盖回原来的数组，实现空间复杂度的降低呢？答案是肯定的。

方法即主角——滚动数组，它只是一种实现方式，而非真实存在滚动数组这一数据结构，因其数组不断一行一行的更新，所以才叫滚动数组。

那么问题来了，要怎么实现呢

说难不难，但细节之多也不能谓之简单，代码直接附上。。。

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 10005;
int t[N],val[N];
int dp[N];//dp[k]表示在时间为k的情况下采前n株药材的最大价值

int main() {
	int T,M;
	cin>> T>> M;
	for (int i = 1; i <= M; i++) {
		cin>> t[i]>> val[i];
	}
	for (int i = 1; i <= M; i++) {
		for (int k = T; k >= 1 ; k--) {
			if (k - t[i] >= 0)
				dp[k] = max(dp[k-t[i]]+val[i],dp[k]);
			else if (k < t[i])
				dp[k] = dp[k]; 
			cout << dp[k]<<" ";
		}
		cout << endl;
	}
	cout << dp[T];
	return 0;
}

关键是在k的那个循环里，这里的k从1和从1到T都是不可以的！！！因为要是直接从小到大的话会导致原来保存下来的数组出现偏差，即非最优解覆盖原来的最优解覆盖了上一层的最优解之后，之后本应利用上一层的最优解，的新容量最优解使用了更大的数据

直接把错误结果附上

0 0 0 0 0 6 6 6 6 6

0 0 0 0 0 6 8 8 8 8

0 3 3 6 6 9 9 12 12

很显然第一，二行暂且没有问题，但是在第三行的第四列开始就出现了错误，原因很简单，就是利用了错误的数据进行计算，f（n，k）=max（f（n-1，k），f（n-1，k-v[ n ]）），f（3，4）应该等于max（f（2，4），f（2，2）+ 3）=3，在滚动数组中则会使用f（2）的值来计算，但是使用滚动数组的话，在计算f（3，2）的时候已经将它需要使用的元素修改成了3，所以导致了这场悲剧的发生。。。

那么为什么倒过来就是正确的呢，表格附上。。。

n\k	10	9	8	7	6	5	4	3	2	1
1	6	6	6	6	6	0	0	0	0	0
2	8	8	8	8	6	0	0	0	0	0
3	11	11	9	8	6	3	3	3	3	0

重点是最后一行数据（n=3的时候）的来源，

第一个元素，k=10的时候，f（3，10）应该等于max（f（2，8）+ 3，f（2，10））也就是处理前一维数组中的第一个（k=10）元素的值8或第三个元素（k=8）的值8加上第三件药品的价值3的最大值，显然是后者，11。

第二个元素，k=9的时候，f（3，9）为max（f（2，7）+3，f（2，9）），即一维数组中第二个元素的值8或第四个元素的值8加上3的最大值，显然也是11。

第三个元素，k=8的时候，f（3，8）是max（f（2，6）+3，f（2，8）），即一维数组中第三个元素的值8或第五个元素的值6加上3的最大值，显然是9。

不难发现，在第三行中，每次计算k号元素的值时，我们所利用到的，仅仅只是一维数组中第原来的第k号元素和第k-2号元素，每次修改的是k号元素的值，并不会影响到后面，简单来说，第一个元素是最强资本家，他从后面的小资本家榨取利益，这并不会影响后面的小资本家向小小资本家榨取利益。

而如果是从小到大，那么就是小资本家企图榨取大资本家的利益，结果到了后面，反而让大资本家全部再榨取回去了==

结尾

第一次写blog，第一次做DP，莫名其妙就写了这么多了，希望以后自己会过头来看的时候能认认真真的看！！！自己该有的模拟自己好好模拟！！！