dp学习笔记(洛谷P1048 [NOIP2005 普及组] 采药)

采药

题目

记忆化搜索

重复性剪枝就是重复的状态不再搜索。
那么记忆化搜索就是重复性剪枝+最优性剪枝。

#include
#include
#include
#include
#include
#define ll long long
using namespace std;
const int N=1e5+10;
const int M=2023;
const int inf=0x3f3f3f3f;
ll t,m,tim[N],a[N],ans;
ll vis[200][2000];
void dfs(ll step,ll sysj,ll sum)//现在采到第step个 剩余时间为sysj 价值为sum
{
	if(vis[step][sysj]>=sum)return;如果在同一种况下,当前的价值比较小return 
	vis[step][sysj]=sum; //记录当前状态的价值
	if(step==m+1)
	{
		ans=max(ans,sum);
		return;
	}
	if(sysj-tim[step]>=0)
	{
		dfs(step+1,sysj-tim[step],sum+a[step]);
	}
	dfs(step+1,sysj,sum);
}
int main()
{
	memset(vis,-1,sizeof vis);
	scanf("%lld%lld",&t,&m);
	for(int i=1;i<=m;i++)scanf("%lld%lld",&tim[i],&a[i]);
	dfs(1,t,0);
	printf("%lld\n",ans);
}

此题记忆化是可以AC的。

线性dp

dp五要素

这个是老师教的

1. 状态（能够表示清楚当前情况的数据）：如果想不到，思考一下这道题的搜索你会如何实现，$dfs(x,y,z,ans)$ ，那么一般情况就是 $dp[x][y][z]=ans;$
2. 状态转移方程：其实就是搜索中的第二步（能做的事情），从能做的事情会变化到的下一个状态中，按照需求选择一个最优的结果
3. 初始化（起点）：其实就是搜索的出口
4. 答案
5. 依赖关系（求解顺序）：一般普通的线性动态规划要么从小到大要么从大到小

采药的五要素（1）

五要素可以通过记忆化得出。

1. 状态：$dp[i][j]$代表前i个草药，花费时间为j的最大价值
2. 状态转移方程

if (j - t[i] >= 0)
{
	dp[i][j]=max(dp[i-1][j],dp[i-1][j-t[i]]+p[i]);
} 
else
{
	dp[i][j]=dp[i-1][j];	
}

3. 初始化：全部初始化为-1，只有dp[0][0]为0（0个草药，时间为0，价值自然为0）
4. 答案：$max(dp[n][i])$(因为花费的时间不是确定的，所以要枚举一下)
5. 求解顺序：从小到大

动态规划五要素（2）

1. 状态：$dp[i][j]$ 表示前 i 个草药，花费时间最多为 j 的最大价值
2. 状态转移方程

if (j - t[i] >= 0)
{
	dp[i][j]=max(dp[i-1][j],dp[i-1][j-t[i]]+p[i]);
} 
else
{
	dp[i][j]=dp[i-1][j];	
}

3. 初始化：全部初始化为 $0$
4. 答案： $dp[n][T]$（此时不用枚举时间，因为状态的定义是花费时间最多为T）
5. 求解顺序：从小到大

滚动数组

当数据范围够大的时候，空间可能会爆掉。所以有了滚动数组。
滚动数组性价比很高的，因为简单。
对于上述的五要素(2)，我们发现每次的dp[i]只需要i-1那一层。所以i-1前面的就废掉了，存着浪费空间。

我们发现，我们那两个数组轮流用就好了。（如图）
比如：
1用的是1数组
2用的是2数组，此时2可以去1数组里面取数
3用的是1数组，就把原本的1给覆盖掉了。此时3可以去2数组里面取数。
4 5 6以此类推。

可以发现:奇数用1，偶数用2。

写法(麻烦)

五要素(上述的第二种):

1. 状态：$dp[i][j]$ 表示前 i 个草药，花费时间最多为 j 的最大价值
2. 状态转移方程

if (j - t[i] >= 0)
{
	dp[i][j]=max(dp[i-1][j],dp[i-1][j-t[i]]+p[i]);
} 
else
{
	dp[i][j]=dp[i-1][j];	
}

3. 初始化：全部初始化为 $0$
4. 答案： $dp[n][T]$（此时不用枚举时间，因为状态的定义是花费时间最多为T）
5. 求解顺序：从小到大

我们用一个flag，来控制0，1，实际上就是控制1，2

#include 
using namespace std;
int T, n, ans;
int t[1010], p[1010];
int dp[4][1010];
int flag; //1 或者 2
int main()
{
	scanf("%d%d", &T, &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d%d", &t[i], &p[i]);	
	}
	for (int i = 1; i <= n; ++i)
	{
		flag^=1;//0变1 1变0
		for (int j = 1; j <=T; ++j)
		{
			if (j - t[i] >= 0)
			{
				dp[flag+1][j] = max(dp[(flag^1)+1][j], dp[(flag^1)+1][j- t[i]] + p[i]);
				//dp[(flag^1)+1]就是1 变 2，2变1，用另一组数组。
			} 
			else
			{
				dp[flag+1][j] = dp[(flag^1)+1][j];	
			}
		}
	}
	printf("%d\n", dp[n%2+1][T]);
	return 0;
}

写法(简便)

dp要素同上。

#include 
using namespace std;
int T, n, ans;
int t[1010], p[1010];
int dp[2][1010];
int main(){
	scanf("%d%d", &T, &n);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d%d", &t[i], &p[i]);	
	}
	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= T; ++j)
		{
			if (j - t[i] >= 0)
			{
				dp[i%2][j] = max(dp[(i-1)%2][j], dp[(i-1)%2][j- t[i]] + p[i]);
			} 
			else
			{
				dp[i%2][j] = dp[(i-1)%2][j];	
			}
		}
	}
	printf("%d", dp[n%2][T]);
	return 0;
}

滚动数组直接用0，1了。

滚共数组总结

如果 $dp$ 方程形似：$dp[i]=max/min(dp[i-1])$ 那么我的 $dp$ 数组可以在两行内使用
如果 $dp$ 方程形似：$dp[i]=max/min(dp[i-1],dp[i-2])$ 那么我的 $dp$ 数组可以在三行内使用
只要 $dp$ 方程满足，$dp[i]$ 只会使用固定的前几列，那么我们就可以使用滚动数组进行空间优化

1. 确认动态规划方程可以滚动，确认滚动在几行内
2. 将所有的 dp 第一维全部 % 滚动行数即可
3. 滚动数组只滚动最外层的一维