[动态规划] 数字三角形模型

动态规划

数字三角形模型

摘花生

acwing1017

思路

y氏dp分析法

1. 状态表示

   一般情况下，二维的坐标图可以使用二维的状态来表示，f[i][j] 表示从 (1, 1) 走到 (i, j) 所有路线，取值是所有路线获得花生数量的最大值

2. 状态计算

   划分集合，划分依据一般可以选“最后”，考虑最后一步是怎么转移到当前状态，然后写出转移方程

3. 边界问题

   通过分析转移拓扑序，我们可以发现转移过程中会出现 f[i][0] 或 f[0][j]，但由于我们所求的是最大值，全部赋值为0即可，不用考虑边界问题

c++

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

using namespace std;

const int N = 110;

int n, m;
int f[N][N], w[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[i][j]);
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++)
                f[i][j] = max(f[i-1][j], f[i][j-1]) + w[i][j];
        printf("%d\n", f[n][m]);
    }
    return 0;
}

时间复杂度

$O(n^2)$

最低通行费

acwing1018

思路

性质：题目中说商人所花费时间不超过 $(2\ast N-1)$ , 而每穿越一个格子都需要花费1个单位时间长度，从左上角到右下角的最小长度为 $(2\ast N-1)$ ，因此可以得到商人一定只会向右或向下走，不会走回头路

采用y氏分析法，和上题类似，只不过属性选择最小值

注意边界问题

本题问的是最小值，而根据我们的状态定义，状态只能从左上角开始转移，即 f[0][1] 和 f[1][0] 我们需要保证这两个初始值为0，而其他值均为INF, 或者只将第0行或第0列除掉上述两个起始点后均设置为INF

c++

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

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n;
int f[N][N], w[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 = 0; i <= n; i ++) f[i][0] = f[0][i] = INF;
    f[0][1] = f[1][0] = 0;
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= n; j ++)
            f[i][j] = min(f[i-1][j], f[i][j-1]) + w[i][j];
    printf("%d\n", f[n][n]);
    return 0;
}

时间复杂度

$O(n^2)$

方格取数

acwing1027, NOIP 2000

思路

1. 状态表示

   f[k][i1][i2] 表示从 (i1, j1) 走到 (i2, j2) 的路线最大值

   k = i1 + j1 = i2 + j2 使用 k 来去掉一维，也就是代表两条路线的长度

   我们会遇到一个问题，如果两条路径有交叉点，则该交叉点上的权值只能加1次

   因此需要判断是否重合，我们已经假设两条路径长度为 $k$ , 因此当 $i_1=i_2$ 时 $j_1=j_2$， 两点会重合

2. 状态计算

   还是考虑当前状态上一个状态的所有集合以及转移过来的方式

   分析发现共有四种，如上图所示

3. 边界问题，由于该题所求为最大值，初始值均赋值为0即可

c++

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

using namespace std;

const int N = 12;

int f[N*2][N][N];
int w[N][N];
int 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 <= 2 * 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 &x = f[k][i1][i2];
                    int t = w[i1][j1];
                    if(i1 != i2) t += w[i2][j2];
                    
                    x = max(x, f[k-1][i1][i2] + t);
                    x = max(x, f[k-1][i1][i2-1] + t);
                    x = max(x, f[k-1][i1-1][i2] + t);
                    x = max(x, f[k-1][i1-1][i2-1] + t);
                }
            }
    printf("%d\n", f[n*2][n][n]);
    return 0;
}

传纸条

NOIP2008, acwing275

思路

和上题思路类似，唯一区别，就是除了起点和终点外不允许两条路线有交叉

c++

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

using namespace std;

const int N = 55;

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

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 ++)
            {
                if(k > 1 && k < n + m && i1 == i2) continue;
                int j1 = k - i1, j2 = k - i2;
                if(j1 >= 1 && j1 <= m && j2 >= 1 && j2 <= m)
                {
                    int &x = f[k][i1][i2], t = w[i1][j1] + w[i2][j2];
                    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);
                }
            }
            
    printf("%d\n", f[n+m][n][n]);
    return 0;
}