算法学习笔记（动态规划——01背包）

先来聊聊动态规划，动态规划是分治法的一种体现，把一个问题分解成若干个子集，通过当前状态，经过操作得到下一个状态，最后得到最优问题解的一种方法。

步骤：

1. 设定状态，保存状态
2. 根据状态设定转移方程
3. 确定边界

其中的01背包解决的是关于选择的动态规划问题，$0$ 和 $1$ 代表的是选与不选。

以这道经典01背包例题采药展开讲解：

采药 - StarryCoding | 踏出编程第一步

题目描述

辰辰是个很有潜能、天资聪颖的孩子，他的梦想是称为世界上最伟大的医师。

为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。

医师把他带到个到处都是草药的山洞里对他说：

“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。

我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入描述

输入的第一行有两个整数 $T(1\le T\le 1000)$ 和 $M(1\le M\le 100)$ , $T$ 代表总共能够用来采药的时间，$M$ 代表山洞里的草药的数目。

接下来的M行每行包括两个在 $1$ 到 $100$ 之间（包括 $1$ 和 $100$ ）的整数，分别表示采摘某株草药的时间和这株草药的价值。

输出描述

可能有多组测试数据，对于每组数据：

输出只包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。

先思考暴力的做法，就是把所有组合都枚举出来，从中选择最优解，这个解法有一个很明显的问题：复杂度支撑不了我们在短时间内求解。

有没有什么办法能优化呢？有些同学会想到贪心，贪心的想法其实没错，显然我要提高采药时间的利用率，那我们直接选取性价比最高的采药来采即可。也就是说，优先采价值与时间之比较大的草药。但是这个解法真的可行吗？其实是有一点问题的，由于我们只能采一整株草药，我们的时间中可能会有剩余部分，不足以支持我们采更多的草药，这些剩余部分就会降低我们的利用率。

最后还是需要每株草药都考虑进去嘛。到底如何枚举才能使我们又快又准确的知道答案呢？这就是我们今天要研究的：动态规划——01背包。

大家知道，我们做动态规划都需要先确定状态和状态转移方程。在这个问题中，我们可以规定这样一个二维的状态数组 $dp[N][M]$ ，其中 $dp[i][j]$ 代表的是我们在对第 $i$ 个草药进行选择的时候，在 $j$ 时间内，可以取得的最大价值。接下来我们可以根据这个状态设计出状态转移方程：$dp[i][j]=max(dp[i-1][j],dp[i-1][j-t_i]+v_i)$ 。

因为我们取第 $i$ 个草药时，如果能取，则需要占用 $t_i$ 的时间，所以通过对 $dp[i][j]$（不取这个草药）与往前推移 $t_i$ 时间中的价值（也就是前 $i$ 个草药中取这个草药前能取到的最大价值）再加上这个草药的价值进行比较来抉择出最优选择方案。

接下来只需要抉择完所有草药之后，输出 $dp[M][T]$ （在对第 $M$ 个草药进行选择的时候，在 $T$ 时间内，可以取得的最大价值）就可以得到答案了。

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll p = 1e9 + 7;

ll T, M;

ll dp[105][1010];

ll t[105], v[106];

void solve()
{
    for(int i = 1; i <= M; ++i) cin >> t[i] >> v[i];

    for(int i = 1; i <= M; ++i) 
    {
        for(int j = 0; j <= T; ++j)
        {
            if(j >= t[i]) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - t[i]] + v[i]);
            else dp[i][j] = dp[i - 1][j];
        }
    }
    cout << dp[M][T] << '\n';
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    while(cin >> T << M)
    {
        if(T == 0 && M == 0) break;
        solve();
    }

    return 0;
}

不急，还没结束。

我们可以发现的是，在外面转移状态的时候，最新的状态只与取上一个草药时的状态有关，那我们是否可以将数组的第二维优化到 $2$ 。也就是将状态数组优化成 $dp[T][2]$ 。

这涉及到滚动数组的概念：

从上面的数组转移到下面，再从下面的数组转移到上面，循环往复。也就是 $dp[T][1]$ 从 $dp[T][0]$ 转移过来， 新的 $dp[T][0]$ 又从刚刚得到的 $dp[T][1]$ 中转移过来。

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll p = 1e9 + 7;
//滚动数组优化

ll T, M;

ll dp[2][1010];

ll t[105], v[106];

void solve()
{
    for(int i = 0; i <= T; ++i) dp[0][i] = 0;

    for(int i = 1; i <= M; ++i) cin >> t[i] >> v[i];

    for(int i = 1; i <= M; ++i) 
    {
        int x = i & 1;
        for(int j = 0; j <= T; ++j)
        {
            if(j >= t[i]) dp[x][j] = max(dp[x ^ 1][j], dp[x ^ 1][j - t[i]] + v[i]);
            else dp[x][j] = dp[x ^ 1][j];
        }
    }
    cout << dp[M & 1][T] << '\n';
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    while(cin >> T << M)
    {
        if(T == 0 && M == 0) break;
        solve();
    }

    return 0;
}

最后，能不能不要这第二维，直接用一维的数组去表示呢。当然是可以的。因为我们在进行状态转移的时候，是由前面的原状态得到后面的新状态。在二维中就是由左上角的某个数字转移过来得到右下角的某个数字。而这个原状态，就是在经历过上一次转移之后的状态数组中有的。为了不影响后续的转移，直接从后往前转移就可以省略掉这第二维。

转移方程变成了：$dp[j]=max(dp[j],dp[j-t_i]+v_i)$

#include<bits/stdc++.h>
using namespace std;
const int N = 1009;

int dp[N];
int T, M;

void solve()
{
    for(int i = 1; i <= M; ++i)
    {
        int t, v; cin >> t >> v;
        for(int j = T; j >= t; --j)
        {
            dp[j] = max(dp[j], dp[j - t] + v);
        }
    }
    cout << dp[T] << '\n';
   	memset(dp, 0, sizeof(int) * (T + 1));
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    while(cin >> T >> M)
    {
     	if(!T && !M) break;
        solve();
    }
    return 0;
}

实际应用：动态规划中取或不取的背包问题（01背包问题）

更详细内容可以看看starrycoding中的算法基础课，联系笔者可以获得八折优惠（真妹卖课，只是这课真的很好，推荐给大家）。

后续内容持续更新中~