采药
记忆化搜索
重复性剪枝就是重复的状态不再搜索。
那么记忆化搜索就是重复性剪枝+最优性剪枝。
#include<bits/stdc++.h>
#include<queue>
#include<set>
#include<stack>
#include<cstring>
#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五要素
这个是老师教的
- 状态(能够表示清楚当前情况的数据):如果想不到,思考一下这道题的搜索你会如何实现, d f s ( x , y , z , a n s ) dfs(x,y,z,ans) dfs(x,y,z,ans) ,那么一般情况就是 d p [ x ] [ y ] [ z ] = a n s ; dp[x][y][z] = ans; dp[x][y][z]=ans;
- 状态转移方程:其实就是搜索中的第二步(能做的事情),从能做的事情会变化到的下一个状态中,按照需求选择一个最优的结果
- 初始化(起点):其实就是搜索的出口
- 答案
- 依赖关系(求解顺序):一般普通的线性动态规划要么从小到大要么从大到小
采药的五要素(1)
五要素可以通过记忆化得出。
- 状态: d p [ i ] [ j ] dp[i][j] dp[i][j]代表前i个草药,花费时间为j的最大价值
- 状态转移方程
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];
}
- 初始化:全部初始化为-1,只有dp[0][0]为0(0个草药,时间为0,价值自然为0)
- 答案: m a x ( d p [ n ] [ i ] ) max(dp[n][i]) max(dp[n][i])(因为花费的时间不是确定的,所以要枚举一下)
- 求解顺序:从小到大
动态规划五要素(2)
- 状态: d p [ i ] [ j ] dp[i][j] dp[i][j] 表示前 i 个草药,花费时间最多为 j 的最大价值
- 状态转移方程
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];
}
- 初始化:全部初始化为 0 0 0
- 答案: d p [ n ] [ T ] dp[n][T] dp[n][T](此时不用枚举时间,因为状态的定义是花费时间最多为T)
- 求解顺序:从小到大
滚动数组
当数据范围够大的时候,空间可能会爆掉。所以有了滚动数组。
滚动数组性价比很高的,因为简单。
对于上述的五要素(2),我们发现每次的dp[i]只需要i-1那一层。所以i-1前面的就废掉了,存着浪费空间。
我们发现,我们那两个数组轮流用就好了。(如图)
比如:
1用的是1数组
2用的是2数组,此时2可以去1数组里面取数
3用的是1数组,就把原本的1给覆盖掉了。此时3可以去2数组里面取数。
4 5 6以此类推。
可以发现:奇数用1,偶数用2。
写法(麻烦)
五要素(上述的第二种):
- 状态: d p [ i ] [ j ] dp[i][j] dp[i][j] 表示前 i 个草药,花费时间最多为 j 的最大价值
- 状态转移方程
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];
}
- 初始化:全部初始化为 0 0 0
- 答案: d p [ n ] [ T ] dp[n][T] dp[n][T](此时不用枚举时间,因为状态的定义是花费时间最多为T)
- 求解顺序:从小到大
我们用一个flag,来控制0,1,实际上就是控制1,2
#include <bits/stdc++.h>
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 <bits/stdc++.h>
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了。
滚共数组总结
如果
d
p
dp
dp 方程形似:
d
p
[
i
]
=
m
a
x
/
m
i
n
(
d
p
[
i
−
1
]
)
dp[i] = max/min(dp[i-1])
dp[i]=max/min(dp[i−1]) 那么我的
d
p
dp
dp 数组可以在两行内使用
如果
d
p
dp
dp 方程形似:
d
p
[
i
]
=
m
a
x
/
m
i
n
(
d
p
[
i
−
1
]
,
d
p
[
i
−
2
]
)
dp[i] = max/min(dp[i-1],dp[i-2])
dp[i]=max/min(dp[i−1],dp[i−2]) 那么我的
d
p
dp
dp 数组可以在三行内使用
只要
d
p
dp
dp 方程满足,
d
p
[
i
]
dp[i]
dp[i] 只会使用固定的前几列,那么我们就可以使用滚动数组进行空间优化
- 确认动态规划方程可以滚动,确认滚动在几行内
- 将所有的 dp 第一维全部 % 滚动行数即可
- 滚动数组只滚动最外层的一维