算法分析与设计作业--动态规划

自己学校的作业,删了觉得太可惜了,不如发出来

动态规划

动态规划就是一个优化版的暴力法, 优化了遍历的顺序和数量, 使得将一个问题降低到一个时间可观的复杂度以内

---

最长公共子序列

给定两个长度分别为 $N$ 和 $M$ 的字符串 $A$ 和 $B$，求既是 $A$ 的子序列又是 $B$ 的子序列的字符串长度最长是多少, 并输出该字串。

输入格式

第一行包含两个整数 $N$ 和 $M$。

第二行包含一个长度为 $N$ 的字符串，表示字符串 $A$。

第三行包含一个长度为 $M$ 的字符串，表示字符串 $B$。

字符串均由小写字母构成。

输出格式

第一行输出一个整数，表示最大长度。

第二行输出一个字符串，表示该字串

数据范围

$1\le N,M\le 1000$

输入样例：

4 5
acbd
abedc

输出样例：

3
abd

---

C++代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N], c[N];
int dp[N][N];

int main() {
    cin >> n >> m;                      // 读取两个序列的长度
    scanf("%s", a + 1);                 // 读取a的值
    scanf("%s", b + 1);                 // 读取b的值

    for (int i = 1; i <= n; i++) {      // dp求解
        for (int j = 1; j <= m; j++) {
            if (a[i] == b[j]) {
                dp[i][j] = max(dp[i - 1][j - 1] + 1, dp[i][j]);
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }
    cout << "最长的子序列的长度: " << dp[n][m] << endl;

    int len = 0;    // 子序列的长度
    for (int i = n, j = m; i >= 1 && j >= 1;) {
        if (a[i] == b[j]){
            c[len ++] = a[i];
            i --, j --;
        } else {
            if (dp[i - 1][j] > dp[i][j - 1])i --;
            else j --;
        }
    }
    reverse(c, c + len);
    cout << "子序列为: " << c << endl;
    return 0;
}

运行截图

---

算法分析

集合表示：$f[i][j]$ 表示 $a$ 的前 $i$ 个字母，和 $b$ 的前 $j$ 个字母的最长公共子序列长度

集合划分：以 $a[i],b[j]$ 是否包含在子序列当中为依据，因此可以分成四类：

1. $a[i]$ 不在，$b[j]$ 不在

   $f[i][j]=f[i-1][j-1]$

2. $a[i]$ 在, $b[j]$ 不在

   $f[i][j]=max(f[i][j],f[i][j-1])$

3. $a[i]$ 不在, $b[j]$ 在

   $f[i][j]=max(f[i][j],f[i-1][j])$

4. $a[i]$ 在, $b[j]$ 在

   $f[i][j]=max(f[i][j],f[i][j]+1)$

复杂度分析:

$a$ 串和 $b$ 串均会被遍历一次, 所以时间复杂度为 $O(N\ast M)=O(n^2)$ , $N$ 为 $a$ 的长度, $M$ 为 $b$ 的长度

---

01背包

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

第 $i$ 件物品的体积是 $v_i$，价值是 $w_i$。

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

输入格式

第一行两个整数，$N，V$，用空格隔开，分别表示物品数量和背包容积。

接下来有 $N$ 行，每行两个整数 $v_i,w_i$，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

$0<N,V\le 1000$
$0<v_i,w_i\le 1000$

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

---

C++代码

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 1010;

int n, m;       // n个物品, m的容量
int w[N], v[N]; // 第i个物品的价值和体积
int dp[N][N];   // 第i个物品, 体积为j的背包能装的最大的价值

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) scanf("%d%d", &v[i], &w[i]);

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            dp[i][j] = dp[i - 1][j];    // 不装
            if (j - v[i] >= 0)
                dp[i][j] = max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    cout << dp[n][m] << endl;
    return 0;
}

运行截图

---

算法分析

状态 $f[i][j]$ 定义：前 $i$ 个物品，背包容量 $j$ 下的最优解（最大价值）：

两个大状态:

1. 不将此物品放入背包中

   此时,当前的价值和上一个物品的价值一样

   $f[i][j]=f[i-1][j]$

2. 将此背包放入背包中

   1. 可以将此物品放入背包中

      当前的价值等于 i - 1个物品的 j - v[i] 的价值加上当前的价值

      $f[i][j]=f[i-1][j-v[i]]+w[i]$

   2. 不可以将此物品放入背包中

      直接跳过这个情况即可

复杂度分析

所有的背包容量和物品都要遍历一次, 所以时间复杂度为$O(N\ast V)=O(n^2)$, $N$为物品的个数, $V$为背包的容量

---

体积优化(滚动数组)

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 1010;

int n, m;       // n个物品, m的容量
int w[N], v[N]; // 第i个物品的价值和体积
int dp[N];   // 第i个物品, 体积为j的背包能装的最大的价值

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) scanf("%d%d", &v[i], &w[i]);

    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= v[i]; j--) {
            if (j - v[i] >= 0)
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[m] << endl;
    return 0;
}

优化思路:

可以看到:第 $i$ 个物品的所有的状态只依赖于第 $i-1$ 个物品的状态, 不依赖于再之前的状态,所以可以将那些状态抛弃

此时, 由于将状态方程dp由二维转换成一维的了, 所以也要对代码进行等价转换.

复杂度分析

空间复杂度由 $O(N\ast V)=O(n^2)$ 优化成了 $O(V)=O(n)$

可以看到优化前后的算法的时间复杂度和空间复杂度的变化还是很明显的:

1. 二维版

2. 优化版

---

额外补充

背包问题状态问题的总结

体积最多是 j

全部初始化成 $0$ , 算的时候, 要保证体积 v >= 0

体积恰好是 j

初始状态 f(0) = 0, 其余的全部初始化为正无穷, 同时保证体积 v >= 0

体积至少是j

初始状态 f(0) = 0, 其余的全部初始化为正无穷