第五章动态规划(1)：数字三角形模型

路哞哞

已于 2023-04-14 17:44:09 修改

阅读量301

点赞数

分类专栏：算法笔记文章标签：动态规划算法贪心算法

于 2022-05-01 20:43:29 首次发布

本文链接：https://blog.csdn.net/qq_34696503/article/details/124529274

版权

算法笔记专栏收录该内容

28 篇文章 2 订阅

订阅专栏

1、数字三角形（基础模型）

ACWing 898

注：行列表示
在这里插入图片描述
集合

$f [i] [j]$ ：所有从起点 $(1, 1)$ ，走到 $(i, j)$ 的路径上的数值和的最大值。

集合划分：

来自左上的最大值： $f [i] [j] = f [i - 1] [j - 1] + a [i] [j]$
来自右上的最大值： $f [i] [j] = f [i - 1] [j] + a [i] [j]$

状态计算：
$f [i] [j] = ma x (f [i - 1] [j - 1], f [i - 1] [j]) + a [i] [j]$

注意： 矩阵 $f [N] [N]$ 的初始化，由于状态方程的计算中存在 $[i - 1, j - 1]$ ，故行要将多出来的第 $0$ 行初始化为 $- I NF$ ，列要将多出来的第 $0$ 列和第 $i + 1$ 列初始化为 $- I NF$ ，因为当取值从右上传过来的时候需要多出一列 $- I NF$ 。
在这里插入图片描述

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, w, f[N][N];

int main() {
    scanf("%d", &n);
    for (int i = 0; i <= n; i ++ )
        for (int j = 0; j <= i + 1; j ++ )
            f[i][j] = -INF;
    int res = -INF;
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ ) {
            scanf("%d", &w);
            if (i == 1 && j == 1) f[i][j] = w;
            else f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + w;
            if (i == n) res = max(res, f[n][j]);
        }
    printf("%d\n", res);
    return 0;
}

2、摘花生

ACWing 1015

注：算法题和传统数学题的坐标系是不一样的，下图是算法题中的坐标。
在这里插入图片描述
集合

f[i,j]：所有从起点(1, 1)，走到(i, j)的路径上的花生数量最大值

集合划分：
在这里插入图片描述

状态计算：

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

注意区分：

这个题的代码和上个题的代码中f[1][1]的初始化不同，因为上一个题中三角形的数据有可能是负数，所以最初f[i][j]中的所有数据要初始为-INF，然后将f[1][1]初始化为a[1][1]，如果过没有f[1][1] = a[1][1]的初始化，那么结果将是比-INF略大的数据。

而本题是所有花生的数量均为正数，所以f[i][j]初始化为0即可。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 110;

int n, m;
int w, f[N][N];

int main() {
    int T; scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++) {
                scanf("%d", &w);
                f[i][j] = max(f[i - 1][j], f[i][j - 1]) + w;
            }
        printf("%d\n", f[n][m]);
    }
    return 0;
}

3、最低通行费

ACWing 1018

由条件商人必须在 (2N−1) 个单位时间穿越出去且该图是一个正方形，故可以得出结论：商人在走路的过程中不可以走回头路！

几点注意：

这个题求的是最小值，所以要对边界做初始化；
对于f[1][1]的初始化，理由同第一题，边界上有INF都要注意初始化，如果不做特殊处理，因为它的值有两个方向决定，而这两个方向都带有INF（很重要这一点！）。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n;
int w, f[N][N];

int main() {
    scanf("%d", &n);
    for (int i = 0; i <= n; i++) f[i][0] = f[0][i] = INF;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++) {
            scanf("%d", &w);
            if (i == 1 && j == 1) f[i][j] = w;
            else f[i][j] = min(f[i - 1][j], f[i][j - 1]) + w;
        }
    printf("%d\n", f[n][n]);
    return 0;
}

4、方格取数

ACWing 1027

算法思路：与摘花生类似

同时走，走两次：

f[i1, j1, i2, j2]：表示所有从(1, 1)、(1, 1)分别走到(i1, j1)、(i2, j2)的路径的最大值；
如何处理 ”同一个格子不能被重复选择” ？
- 什么时候它们会走到同一个格子呢？满足条件：i1 + j1 = i2 + j2并且它们的步数相同的时候才会走到相同的格子，这里我们使用k来到表它们的步数；
状态优化（从四维降为三维）：f[k, i1, i2]表示所有从(1, 1)、(1, 1)分别走到(i1, k - i1)、(i2, k - i2)的路径的最大值，其中k = i1 + j1 = i2 + j2；
集合划分（每条路径都是看最后一次怎么走）：
- 第一类：第一条路径最后一次往下走，第二条路径最后一次往下走；
- 第二类：第一条路径最后一次往下走，第二条路径最后一次往右走；
- 第三类：第一条路径最后一次往右走，第二条路径最后一次往下走；
- 第四类：第一条路径最后一次往右走，第二条路径最后一次往右走；
- 如图：
状态计算：
- 第一类：
  - 第一条路径：(1, 1) -> (i1 - 1, j1) -> (i1, j1)
  - 第二条路径：(1, 1) -> (i2 - 1, j2) -> (i2, j2)
  - 对于两条路径前面一部分(1, 1) -> (i1 - 1, j1) 和 (1, 1) -> (i2 - 1, j2) 的最大值即为max(f(k - 1, i1 - 1, i2 - 1))
  - 对于后面一部分，要分情况考虑：
    - 当两个结点重合的时候，i1 = i2, j1 = j2，就是它们之前上一个点走到的是同一个点，就只需要加上w(i1, j1)；
    - 当两个结点不重合的时候，就需要加上：w(i1, j1) + w(i2, j2)；
- 其他三类的最大值同理，最后结果为每一类的最大值再取一个最大值。

注意：这个题不能分开走的原因

这样不能得到最大值。因为第一遍的最优解可能有非常多种方案，你并不能确定采用哪一种。第二遍的最大值依赖于第一遍选择哪种方案，而所有第一遍取最大值的方案数量可能是指数级别的。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 15;

int n;
int w[N][N], f[N * 2][N][N];

int main() {
    cin >> n;
    int a, b, c;
    while (cin >> a >> b >> c, a || b || c) w[a][b] = c;
    for (int k = 2; k <= n + n; k++)
        for (int i1 = 1; i1 <= n; i1++)
            for (int i2 = 1; i2 <= n; i2++) {
                int j1 = k - i1, j2 = k - i2;
                if (j1 >= 1 && j1 <= n && j2 >= 1 && j2 <= n) {
                    int t = w[i1][j1];
                    if (i1 != i2) t += w[i2][j2];
                    int &x = f[k][i1][i2];
                    x = max(x, f[k - 1][i1 - 1][i2 - 1] + t);
                    x = max(x, f[k - 1][i1 - 1][i2] + t);
                    x = max(x, f[k - 1][i1][i2 - 1] + t);
                    x = max(x, f[k - 1][i1][i2] + t);
                }
            }
    cout << f[n + n][n][n];
    return 0;
}

更简洁的写法

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 15;

int n;
int w[N][N], f[N * 2][N][N];

int main() {
    scanf("%d", &n);
    int a, b, c;
    while (scanf("%d%d%d", &a, &b, &c), a || b || c) w[a][b] = c;
    for (int k = 2; k <= n + n; k++)
        for (int i1 = 1; i1 <= n; i1++)
            for (int i2 = 1; i2 <= n; i2++) {
                int j1 = k - i1, j2 = k - i2;
                if (j1 < 1 || j1 > n || j2 < 1 || j2 > n) continue;
                int t = w[i1][j1];
                if (j1 != j2) t += w[i2][j2];
                for (int a = 0; a <= 1; a++)
                    for (int b = 0; b <= 1; b++)
                        f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - a][i2 - b] + t);
            }
    printf("%d\n", f[n + n][n][n]);
    return 0;
}

5、传纸条

ACwing 275

注：从右下角回传可以等价为从左上角同时传两次

集合

f[k,x1,x2]：所有第一条线路从[1,1]走到[x1,k-x1]，第二条线路从[1,1]走到[x2,k-x2]的路线组合的最大值，其中k = x1 + y1 = x2 + y2，k代表步数。

集合划分

按两条路线最后一步走的方向来划分：

在这里插入图片描述

状态计算

第一类

第一条路线：[1, 1] → [x1, k-1-x1] → [x1, k-x1]；
第二条路线：[1, 1] → [x2, k-1-x2] → [x2, k-x2]；
两条路线前k-1步计算简单：max(f[k-1,x1,x2])；
最后一步：如果两条路线在这一步走到的点重合，就相加一次，否则加两次。

第二类

第一条路线：[1, 1] → [x1, k-1-x1] → [x1, k-x1]；
第二条路线：[1, 1] → [x2-1, k-x2] → [x2, k-x2]；
两条路线前k-1步计算简单：max(f[k-1,x1,x2-1])；
最后一步：如果两条路线在这一步走到的点重合，就相加一次，否则加两次。

其余两个状态分析类似。

注意

这个题和上一题的区别在于：如果重合就表示有一条路不让走了，但是上一题无此约束；
矩阵中所有值非负，所以矩阵可以初始化为0；
对于x1的取值，因为有1 <= x1 <= n且1 <= k-x1 <= m，所以有max(1, k-m) <= x1 <= max(k-1, n)，x2的范围同理;
不允许走同一个点的体现：除了起点和终点之外，只有i != j时，才能去更新其它状态，这样就保证了不走同一个格子。关于这个证明看链接。

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

using namespace std;

const int N = 55;

int n, m;
int w[N][N], f[N * 2][N][N];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            scanf("%d", &w[i][j]);
    for (int k = 2; k <= n + m; k++)
        for (int x1 = max(1, k - m); x1 <= min(k - 1, n); x1++)
            for (int x2 = max(1, k - m); x2 <= min(k - 1, n); x2++) {
                int t = w[x1][k - x1];
                if (x2 != x1) t += w[x2][k - x2];
                for (int a = 0; a <= 1; a++)
                    for (int b = 0; b <= 1; b++)
                        f[k][x1][x2] = max(f[k][x1][x2], f[k - 1][x1 - a][x2 - b] + t);
            }
    printf("%d\n", f[n + m][n][n]);
    return 0;
}

下面是使用上一个题的写法，一样能过。

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 55;

int n, m;
int w[N][N], f[N * 2][N][N];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            scanf("%d", &w[i][j]);
    for (int k = 2; k <= n + m; k++)
        for (int i1 = 1; i1 <= n; i1++)
            for (int i2 = 1; i2 <= n; i2++) {
                int j1 = k - i1, j2 = k - i2;
                if (j1 < 1 || j1 > m || j2 < 1 || j2 > m) continue;
                int t = w[i1][j1];
                if (j1 != j2) t += w[i2][j2];
                for (int a = 0; a <= 1; a++)
                    for (int b = 0; b <= 1; b++)
                        f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - a][i2 - b] + t);
            }
    printf("%d\n", f[n + m][n][n]);
    return 0;
}

6、检查是否有合法括号字符串路径

LeetCode 2267

对于一个括号序列，从左往右遍历每个字符，同时维护变量 $n o w$ （初始值为 $0$ ）。遇到左括号时， $now\ +=\, 1$ ，遇到右括号时， $now\ -=\, 1$ 。如果过程中 $n o w$ 始终非负，且最后 $n o w$ 变成 $0$ ，则是合法序列。

对于本题，需要将 $n o w$ 放进 $d p$ 状态里面，记 $f [i] [j] [k]$ 表示是否存在以格子 $(i, j)$ 结尾，且 $n o w$ 值为 $k$ 的括号序列。由于只能往右或者往下走，存在如下状态转移方程：
$\leftarrow \begin{cases} f(i-1, j, k - c) \ \ \ if(i>0) \ {从上面转移过来}\\ f(i, j - 1, k - c) \ \ \ if(j > 0) \ {从左边转移过来} \\ \end{cases}$
其中，若 $\ '('$ ，则 $c = 1$ ，否则 $c = - 1$ ，并且 $k = [0, n + m)$ （因为过程中 $n o w$ 不能为负，且最长路径只有 $n + m - 1$ 这么长），初始值 $f [0] [0] [1] = t r u e$ 。时间复杂度为 $O (nm (n + m))$ 。

class Solution {
public:
    bool hasValidPath(vector<vector<char>> &grid) {
        if (grid[0][0] == ')') return false;
        int n = grid.size(), m = grid[0].size();
        vector<vector<vector<bool>>> f;
        for (int i = 0; i < n; i++) {
            f.push_back(vector<vector<bool>>());
            for (int j = 0; j < m; j++) f.back().push_back(vector<bool>(n + m));
        }
        f[0][0][1] = true;
        for (int i = 0; i < n; i++)
            for (int j = 0; j < m; j++)
                if (i || j) {
                    int t = grid[i][j] == '(' ? 1 : -1;
                    for (int k = 0; k < n + m; k++) {
                        int kk = k - t;
                        if (kk < 0 || kk >= n + m) continue;
                        if (i) f[i][j][k] = f[i][j][k] || f[i - 1][j][kk];
                        if (j) f[i][j][k] = f[i][j][k] || f[i][j - 1][kk];
                    }
                }
        return f[n - 1][m - 1][0];
    }
};

路哞哞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第五章动态规划(1)：数字三角形模型

因为第一遍的最优解可能有非常多种方案，你并不能确定采用哪一种。第二遍的最大值依赖于第一遍选择哪种方案，而所有第一遍取最大值的方案数量可能是指数级别的。算法题和传统数学题的坐标系是不一样的，下图是算法题中的坐标。的初始化不同，因为上一个题中三角形的数据有可能是负数，所以最初。，故可以得出结论：商人在走路的过程中不可以走回头路！的初始化，由于状态方程的计算中存在。下面是使用上一个题的写法，一样能过。的路径上的数值和的最大值。这个题的代码和上个题的代码中。的路径上的花生数量最大值。的路线组合的最大值，其中。
复制链接

扫一扫