数字三角形模型

琛_

已于 2022-01-25 09:58:47 修改

阅读量397

点赞数

分类专栏： AcWing算法提高课文章标签：动态规划算法 c++

于 2022-01-21 12:10:53 首次发布

本文链接：https://blog.csdn.net/qq_45896050/article/details/122610497

版权

AcWing算法提高课专栏收录该内容

18 篇文章 1 订阅

订阅专栏

数字三角形模型

摘花生
最低通行费
方格取数
传纸条

摘花生

Hello Kitty想摘点花生送给她喜欢的米老鼠。

她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。

地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。

Hello Kitty只能向东或向南走，不能向西或向北走。

问Hello Kitty最多能够摘到多少颗花生。

输入格式
第一行是一个整数T，代表一共有多少组数据。

接下来是T组数据。

每组数据的第一行是两个整数，分别代表花生苗的行数R和列数 C。

每组数据的接下来R行数据，从北向南依次描述每行花生苗的情况。每行数据有C个整数，按从西向东的顺序描述了该行每株花生苗上的花生数目M。

输出格式
对每组输入数据，输出一行，内容为Hello Kitty能摘到得最多的花生颗数。

数据范围
1 ≤ T ≤ 100,
1 ≤ R,C ≤ 100,
0 ≤ M ≤ 1000

输入样例：

输出样例：

8
16

1. 状态表示
集合：定义f[i][j]为从(1, 1)到达(i, j)的所有方案
属性：最大值

2. 状态转移
(i, j)从(i-1, j)即上方过来
(i, j)从(i, j-1)即左方过来

3. 空间压缩
f[i][j]只需要用到这一层和上一层的f元素，所以可以压缩成滚动数组。在此之上，还可以直接压缩成一维数组。

算法1：空间复杂度O(n²)

#include <iostream>
using namespace std;
const int N = 110;
int n;
int f[N][N];
int main()
{
    cin >> n;
    while (n -- ) {
        int a, b;
        cin >> a >> b;
        for (int i = 1; i <= a; i ++ ) 
            for (int j = 1; j <= b; j ++ ) {
                cin >> f[i][j]; 
                f[i][j] += max(f[i - 1][j], f[i][j - 1]);
            }
        cout << f[a][b] << endl;
    }
	return 0;
}

算法2：滚动数组，空间复杂度O(n)

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

const int N = 105;
int a[2][N], f[2][N], q, n, m;

int main()
{
    cin >> q;
    while(q--){
        cin >> n >> m;

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                cin >> a[i&1][j];
                f[i&1][j] = max(f[i&1][j-1], f[(i-1)&1][j]) + a[i&1][j];
            }
        }
        cout << f[n&1][m] << endl;

        memset(f, 0, sizeof f);
    }
}

算法3：空间复杂度O(n)

#include <iostream>
#include <cstring>
using namespace std;
const int N = 110;
int n;
int g[N][N], f[N];
int main()
{
    cin >> n;
    while (n -- ) {
        int a, b;
        cin >> a >> b;
        for (int i = 1; i <= a; i ++ ) 
            for (int j = 1; j <= b; j ++ ) {
                cin >> g[i][j]; 
                f[j] = max(f[j], f[j - 1]) + g[i][j];
            }
        cout << f[b] << endl;
        memset(f, 0, sizeof f);
    }
	return 0;
}

最低通行费

一个商人穿过一个 N×N 的正方形的网格，去参加一个非常重要的商务活动。

他要从网格的左上角进，右下角出。

每穿越中间 1 个小方格，都要花费 1 个单位时间。

商人必须在 (2N−1) 个单位时间穿越出去。

而在经过中间的每个小方格时，都需要缴纳一定的费用。

这个商人期望在规定时间内用最少费用穿越出去。

请问至少需要多少费用？

注意：不能对角穿越各个小方格（即，只能向上下左右四个方向移动且不能离开网格）。

输入格式
第一行是一个整数，表示正方形的宽度 N。

后面 N 行，每行 N 个不大于 100 的正整数，为网格上每个小方格的费用。

输出格式
输出一个整数，表示至少需要的费用。

数据范围
1 ≤ N ≤ 100

输入样例：

5
1  4  6  8  10
2  5  7  15 17
6  8  9  18 20
10 11 12 19 21
20 23 25 29 33

输出样例：

样例解释
样例中，最小值为 109=1+2+5+7+9+12+19+21+33。
在这里插入图片描述

#include <iostream>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f3f;
int n;
int a[N][N];
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i ++ ) 
		for (int j = 1; j <= n; j ++ )
			cin >> a[i][j];
	for (int i = 0; i <= n; i ++ ) a[0][i] = a[i][0] = INF;
	for (int i = 1; i <= n; i ++ ) 
		for (int j = 1; j <= n; j ++ ) {
			if (i == 1 && j == 1) continue;
			a[i][j] += min(a[i - 1][j], a[i][j - 1]);
		}
	cout << a[n][n];		
	return 0;	
}

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110, INF = 1e9;
int n;
int w[N][N];
int f[N][N];
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            scanf("%d", &w[i][j]);
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == 1 && j == 1) f[i][j] = w[i][j];    // 特判左上角
            else {
                f[i][j] = INF;
                // 只有不在第一行的时候，才可以从上面过来
                if (i > 1) f[i][j] = min(f[i][j], f[i - 1][j] + w[i][j]);   
                // 只有不在第一列的时候，才可以从左边过来
                if (j > 1) f[i][j] = min(f[i][j], f[i][j - 1] + w[i][j]);   
            }
    printf("%d\n", f[n][n]);
    return 0;
}

方格取数

设有 N×N 的方格图，我们在其中的某些方格中填入正整数，而其它的方格中则放入数字0。如下图所示：

某人从图中的左上角 A 出发，可以向下行走，也可以向右行走，直到到达右下角的 B 点。

在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。

此人从 A 点到 B 点共走了两次，试找出两条这样的路径，使得取得的数字和为最大。

输入格式
第一行为一个整数N，表示 N×N 的方格图。

接下来的每行有三个整数，第一个为行号数，第二个为列号数，第三个为在该行、该列上所放的数。

行和列编号从 1 开始。

一行“0 0 0”表示结束。

输出格式
输出一个整数，表示两条路径上取得的最大的和。

数据范围
N ≤ 10

输入样例：

输出样例：

为什么不能分开走

分开两次走（贪心）：第一次走到(n, n)求出最大值并记录路径令路径上点收益为0后再走一次。

第一次走为局部最优并且也对第二次走造成了影响，第二次走是在第一次影响下所能走的局部最优，不具备“无后效性”，因此分开两次走并不是全局最优解

算法分析

1、f[i1,j1,i2,j2]表示所有从(1,1),(1,1)分别走到(i1,j1),(i2,j2)的路径的最大值

2、由于走两次可以看成是两条路径同时走，因此k表示两条路线当前走到的各自的横纵坐标之和k == i1+j1== i2 + j2

我们就可以把路径长度，作为DP的阶段

每个阶段中，我们同时把两条路径扩展一步，即路径长度加 1 ，来进入下一个阶段

而路径长度加1后，无非就是向下走一格或是向右走一格，对应横纵坐标的变换

根据k,x1,y1,x2,y2的关系，我们可以获得如下等式

x1+y1=x2+y2=k

获得上述等式以后，我们就可以通过三个维度来描述状态了，分别是k,x1,x2
于是，状态的初值为f[2][1][1]，目标状态为f[2 * n][n][n]

则对于如何判断两次路线走进了同一个方格里，由于x1+y1=x2+y2始终相等，则可以通过x1==x2来判断了

当x1≠x2，当前两条路线走到的格子不是同一个，则w=w(x1,k−x1)+w(x2,k−w2)
当x1=x2，当前两条路线走到了同一个格子中，则w=w(x1,k−x1)

而状态转移，基本参照数字三角形的模型即可，具体的贴出闫氏DP分析法图
在这里插入图片描述

#include <iostream>
using namespace std;
const int N = 20;
int n;
int w[N][N];
int 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 * 2; 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 * 2][n][n];
	return 0;	
}

传纸条

小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。

一次素质拓展活动中，班上同学安排坐成一个 m 行 n 列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。

幸运的是，他们可以通过传纸条来进行交流。

纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标 (1,1)，小轩坐在矩阵的右下角，坐标 (m,n)。

从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。

在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。

班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙，反之亦然。

还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用 0 表示），可以用一个 0∼100 的自然数来表示，数越大表示越好心。

小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度之和最大。

现在，请你帮助小渊和小轩找到这样的两条路径。

输入格式
第一行有 2 个用空格隔开的整数 m 和 n，表示学生矩阵有 m 行 n 列。

接下来的 m 行是一个 m×n 的矩阵，矩阵中第 i 行 j 列的整数表示坐在第 i 行 j 列的学生的好心程度，每行的 n 个整数之间用空格隔开。

输出格式
输出一个整数，表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。

数据范围
1 ≤ n,m ≤ 50

输入样例：

输出样例：

需要多考虑，没有完全掌握

(线性DP) O(n³)
首先考虑路径有交集该如何处理。
可以发现交集中的格子一定在每条路径的相同步数处。因此可以让两个人同时从起点出发，每次同时走一步，这样路径中相交的格子一定在同一步内。

状态表示：f[k, i, j] 表示两个人同时走了k步，第一个人在 (i, k - i) 处，第二个人在 (j, k - j)处的所有走法的最大分值。

状态计算：按照最后一步两个人的走法分成四种情况：

两个人同时向右走，最大分值是 f[k - 1, i, j] + score(k, i, j)；
第一个人向右走，第二个人向下走，最大分值是 f[k - 1, i, j - 1] + score(k, i, j)；
第一个人向下走，第二个人向右走，最大分值是 f[k - 1, i - 1, j] + score(k, i, j)；
两个人同时向下走，最大分值是 f[k - 1, i - 1, j - 1] + score(k, i, j)；

注意两个人不能走到相同格子，即i和j不能相等。

时间复杂度
一共有 O(n³) 个状态，每个状态需要 O(1) 的计算量，因此总时间复杂度是 O(n³)。

严格证明

#include <iostream>
using namespace std;
const int N = 55;
int n, m;
int w[N][N];
int f[N * 2][N][N];
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ )
			cin >> w[i][j];
	for (int k = 2; k <= n + m; k ++ )
		// i和j代表两条路径的横坐标
		// 纵坐标：k - i和k - j要在1到m的范围内
		for (int i = max(1, k - m); i <= n && i < k; i ++ )
			for (int j = max(1, k - m); j <= n && j < k; j ++ )
				for (int a = 0; a <= 1; a ++ )
					for (int b = 0; b <= 1; b ++ ) 
					{
						int t = w[i][k - i];
						// 除了起点和终点之外，只有i != j时，才能去更新其它状态
						// 这样就保证了不走同一个格子
						if (i != j || k == 2 || k == n + m) 
						{
							t += w[j][k - j];
							f[k][i][j] = max(f[k][i][j], f[k - 1][i - a][j - b] + t);
						}	
					}
	cout << f[n + m][n][n];
	return 0;	 
}