leetcode刷题（130）——最大得分的路径数目

给你一个正方形字符数组 board ，你从数组最右下方的字符 ‘S’ 出发。

你的目标是到达数组最左上角的字符 ‘E’ ，数组剩余的部分为数字字符 1, 2, …, 9 或者障碍 ‘X’。在每一步移动中，你可以向上、向左或者左上方移动，可以移动的前提是到达的格子没有障碍。

一条路径的 「得分」 定义为：路径上所有数字的和。

请你返回一个列表，包含两个整数：第一个整数是 「得分」 的最大值，第二个整数是得到最大得分的方案数，请把结果对 10^9 + 7 取余。

如果没有任何路径可以到达终点，请返回 [0, 0] 。

示例 1：

输入：board = ["E23","2X2","12S"]
输出：[7,1]
1
2

示例 2：

输入：board = ["E12","1X1","21S"]
输出：[4,2]
1
2

示例 3：

输入：board = ["E11","XXX","11S"]
输出：[0,0]
1
2

提示：

2 <= board.length == board[i].length <= 100

动态规划

本题是一道综合类的题目，不仅仅要求我们求「最大得分」，还需要统计得到最大得分的「方案数」。

显然，两个问题都属于无后效性问题，可以使用 DP 进行求解。

按理说，我们需要使用「二维数组」来存储我们的动规值。

但是维度的增加会让我们的「出错概率」和「Debug 难度」增加。

因此，通常我们会有能合并维度就合并维度的原则。

这里我们将 (x,y)使用一个下标 idx进行替代。

前面两节我们都在使用 动态规划通用解法 中的技巧解法，那么本节就回顾一下最开始学习的经验解法吧。

最大得分问题
结合「最后一步」猜测状态定义：f(idx) 为从「起点」到下标为 idx的最大得分。

那么 f(0)就是最终答案。

结合题意，对于某个位置可以由「下方」、「右方」和「右下方」三个位置转移而来。

因此我们可以得出状态转移方程为：

f[(x,y)]=max(f[(x+1,y)],f[(x,y+1)],f[(x+1,y+1)])+board[(x,y)]
f[(x,y)]=max(f[(x+1,y)],f[(x,y+1)],f[(x+1,y+1)])+board[(x,y)]

当然，只有合法范围内的格子才会参与转移，同时存在「障碍物」的格子的动规值为 INF（负数）。

最大得分方案数问题
同理，使用一个 g[] 数组来存储我们的方案数。

由于某个位置可以由「下方」、「右方」和「右下方」三个位置转移而来。

同时 f[(x,y)] 是由三个位置的最大值转移过来，那么相应的 g[(x,y)] 应该取到最大得分的转移位置的方案数。

需要注意，最大值不一定是由一个位置得出。

如果有多个位置同时能取到最大得分，那么方案数应该是多个位置的方案数之和。

举个🌰，如果可到达 (x,y) 的三个位置（ (x+1,y)，(x,y+1)，(x+1,y+1) ）的最大得分为 3，4，5，到达三个位置的方案数为 1，2，2。

那么可得：

但如果三个位置的最大得分为 3，5，5，到达三个位置的方案数为 1，2，2 的话。

由于同时取得最大值的位置有两个，那么方案数也应该是两个位置方案数之和。

即有：

以上就是我们两个 DP 问题的主要逻辑分析。

还有一些其他的编码细节，我也已经写到了注释当中。

代码：

class Solution {
    int INF = Integer.MIN_VALUE;
    int mod = (int)1e9+7;
    int n;
    public int[] pathsWithMaxScore(List board) {
        n = board.size();

        // 将 board 转存成二维数组
        char[][] cs = new char[n][n];
        for (int i = 0; i < n; i++) {
            cs[i] = board.get(i).toCharArray();
        }

        // f(i) 代表从右下角到位置 i 的最大得分
        int[] f = new int[n * n]; 
        // f(i) 代表从右下角到位置 i 并取到最大得分的方案数量
        int[] g = new int[n * n]; 
        for (int i = n - 1; i >= 0; i--) {
            for (int j = n - 1; j >= 0; j--) {
                int idx = getIdx(i, j);

                // 一个初始化的状态，如果是在最后一格（起点）：
                // g[idx] = 1 : 代表到达起点的路径只有一条，这样我们就有了一个「有效值」可以滚动下去
                // f[idx] = 0 : 代表在起点得分为 0
                if (i == n - 1 && j == n - 1) {
                    g[idx] = 1;
                    continue;
                }

                // 如果该位置是「障碍点」，那么对应状态为：
                // g[idx] = 0   : 「障碍点」不可访问，路径为 0
                // f[idx] = INF : 「障碍点」不可访问，得分为无效值
                if (cs[i][j] == 'X') {
                    f[idx] = INF;
                    continue;
                }

                // 如果是第一个格子（终点），这时候位置得分为 0
                int val = (i == 0 && j == 0) ? 0 : cs[i][j] - '0';

                // u 代表当前位置的「最大得分」；t 代表取得最大得分的「方案数」
                int u = INF, t = 0;

                // 如果「下方格子」合法，尝试从「下方格子」进行转移
                if (i + 1 < n) {    
                    int cur = f[getIdx(i + 1, j)] + val;
                    int cnt =  g[getIdx(i + 1, j)];
                    int[] res = update(cur, cnt, u, t);
                    u = res[0]; t = res[1];
                }

                // 如果「右边格子」合法，尝试从「右边格子」进行转移
                if (j + 1 < n) {
                    int cur = f[getIdx(i, j + 1)] + val;
                    int cnt = g[getIdx(i, j + 1)];
                    int[] res = update(cur, cnt, u, t);
                    u = res[0]; t = res[1];
                }

                // 如果「右下角格子」合法，尝试从「右下角格子」进行转移
                if (i + 1 < n && j + 1 < n) {
                    int cur = f[getIdx(i + 1, j + 1)] + val;
                    int cnt = g[getIdx(i + 1, j + 1)];
                    int[] res = update(cur, cnt, u, t);
                    u = res[0]; t = res[1];
                }

                // 更新 dp 值
                f[idx] = u < 0 ? INF : u;
                g[idx] = t;
            }
        }

        // 构造答案
        int[] ans = new int[2];
        // 如果终点不可达（动规值为 INF）时，写入 0
        ans[0] = f[getIdx(0, 0)] == INF ? 0 : f[getIdx(0, 0)];
        // 如果终点不可达（动规值为 INF）时，写入 0
        ans[1] = f[getIdx(0, 0)] == INF ? 0 : g[getIdx(0, 0)];
        return ans;
    }

    // 更新 dp 值
    int[] update(int cur, int cnt, int u, int t) {
        // 起始答案为 [u, t] : u 为「最大得分」，t 为最大得分的「方案数」
        int[] ans = new int[]{u, t};

        // 如果当前值大于 u，更新「最大得分」和「方案数」
        if (cur > u) {
            ans[0] = cur;
            ans[1] = cnt;

        // 如果当前值等于 u，增加「方案数」
        } else if (cur == u && cur != INF) {
            ans[1] += cnt;
        }
        
        ans[1] %= mod;
        return ans;
    }
    
    // 二维坐标 (x,y) 与 idx 的相互转换
    int getIdx(int x, int y) {
        return x * n + y;
    }
    int[] parseIdx(int idx) {
        return new int[]{idx / n, idx % n};
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110