AcWing 1015. 摘花生

\(AcWing\) \(1015\). 摘花生

一、题目描述

\(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\)

输入样例：

2
2 2
1 1
3 4
2 3
2 3 4
1 6 5

输出样例：

8
16

二、\(DP\)分析

状态表示
\(f[i][j]\): 小猫可在出现的每个位置\((x,y)\), 策略：面向答案编程，
从\((1,1)\)走到\((x,y)\)有多条路线，我们设\(f(x,y)\)为所有路线中 花生数量之和 最大值

状态转移

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

填充顺序
观察状态转移方程，发现：
① 由于是一个二维状态表示，所以可以理解为是一个二维表，需要对二维表进行数据填充。
② 第\(i\)行依赖第\(i-1\)行，第\(j\)列，依赖\(j-1\)列，所以，考虑从上到下，从左到右，就是先处理\(i,j\)中小的，再处理大的，可以形成递推依赖。

初始值
观察状态转移方程，知道\(f[1][1]=w[1][1]\)

答案
最终我们要计算的是在东南角时可以获取到的最多花生数，即\(f[n][m]\)。

三、二维\(DP\)写法

#include <bits/stdc++.h>

using namespace std;
const int N = 110;
int w[N][N];
int f[N][N];
int n, m;
int main() {
    int T;
    cin >> T;
    while (T--) {
        memset(f, 0, sizeof f);
        cin >> n >> m;

        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                cin >> w[i][j];

        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                // 递推的出发点，采用特判的办法手动维护，其它的靠关系式递推完成
                // 之所以这样对起点进行初始化，是因为只有这样才能保障逻辑自洽
                if (i == 1 && j == 1)
                    f[i][j] = w[i][j];
                else
                    f[i][j] = max(f[i - 1][j], f[i][j - 1]) + w[i][j];

        printf("%d\n", f[n][m]);
    }
    return 0;
}

四、一维\(DP\)写法

从二维降一维时，发现每个数据，只依赖于它上一行的同列数据，和同一行的左侧数据，也就是可以概括为依赖于 左+上。而采用一维进行记录状态时，\(f[i-1]\)表示的是\(f[i]\)的左侧供给数据，\(f[i]\)描述的是上一行的同列供给数据，两者\(PK\)就可以覆盖掉当前值。

#include <bits/stdc++.h>

using namespace std;
const int N = 110;
int w[N][N];
int f[N];
int n, m;
int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        memset(f, 0, sizeof f);
        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++)
                if (i == 1 && j == 1) // 递推的出发点，采用特判的办法手动维护，其它的靠关系式递推完成
                    f[j] = w[i][j];
                else
                    f[j] = max(f[j], f[j - 1]) + w[i][j];

        printf("%d\n", f[m]);
    }
    return 0;
}

五、深搜写法

#include <bits/stdc++.h>

using namespace std;
//通过了 2/10个数据
const int N = 110;
int w[N][N];
int n, m;
int dfs(int x, int y) {
    if (x == n && y == m) return w[n][m];
    if (x > n || y > m) return 0;
    return max(dfs(x + 1, y), dfs(x, y + 1)) + w[x][y];
}
int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                cin >> w[i][j];
        printf("%d \n", dfs(1, 1));
    }
    return 0;
}

不使用记忆化的深搜是不可以原谅的，速度太慢！究其原因应该是存在大量重复计算，比如\(dfs(3,5)\)，每次都计算一遍，性能要是好了就怪了，也就是说，我们如果想要使用\(dfs\),就一定要思考使用数组完成记忆化，否则就别用。

六、深搜+记忆化

#include <bits/stdc++.h>

using namespace std;
const int N = 110;
int w[N][N];
int n, m;
int f[N][N];
int dfs(int x, int y) {
    if (f[x][y]) return f[x][y];
    if (x == n && y == m) return w[n][m];
    if (x > n || y > m) return 0;
    f[x + 1][y] = dfs(x + 1, y);
    f[x][y + 1] = dfs(x, y + 1);

    return f[x][y] = max(f[x + 1][y], f[x][y + 1]) + w[x][y];
}
int main() {
    int T;
    cin >> T;
    while (T--) {
        memset(f, 0, sizeof f);
        cin >> n >> m;
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                cin >> w[i][j];
        printf("%d \n", dfs(1, 1));
    }
    return 0;
}

七、理解与感悟

1、递推关系式(状态转移方程)

在一般的局面下 ，比如现在处在\((i,j)\)这个位置上时，思考如何给这个位置确定最佳的花生数量,显然是从左侧花生数量和上侧花生数量取一个\(max\)，再加上当前位置的花生数量即可完成填充：

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

2、递推起点和终点

有了递推式，才会思考哪里是递推起点和终点。西北角进入矩阵，东南角出去，很明显本题的起点是\((1,1)\)，终点是\((n,m)\)

• 起点\(f[1][1]\)：此处是入口，无法从其它位置转移而来，本身花生数就是最大数量，即\(f[1][1]=w[1][1]\)

• 终点\(f[n][m]\)：此处是出口，是答案，是结果，它的值需要走状态转移方程来确定

3、递推顺序

有了递推关系式和起点的基础，我们的目标就是通过递推计算，获取到\(f[n][m]\)的值，使用 瞪眼大法 (观察法),我们知道当前状态计算需要 上一行的同列数据 与 同行的前列数据，也就是在计算当前状态之前，务必保证它的上一行同列数据和同行前列数据完成填充工作，而双重循环，从上到下，从左到右 的枚举顺序，恰好可以满足这个要求！理解这一点非常重要，后面我们继续学习的动态规划问题，大家将会看到多维状态下，多层循环的枚举次序，其实 本质上都是为了填表。

4、与搜索的区别

• 动态规划\(f[i,j]\)含义：从起点走到\((i,j)\)，可以取得的最大价值,随地随地都知道当前的值。

• 搜索\(dfs(i,j)\)含义：从\((i,j)\)出发，到终点时可以获得的最大价值,现在的值需要以后的值确定才能知道。