标签：matrix int 路径 问题 x2 樱桃 && y1 x1

最大路径和问题（摘樱桃问题）

作者：Grey

原文地址: 最大路径和问题（摘樱桃问题）

题目链接

LeetCode 741. 摘樱桃

主要思路

本题的难点在于尝试，如何模拟一来一回的情况，我们可以这样做，定义两个小人，两个人都从(0,0)位置出发，到右下角位置，每人同时选择不同的下一步，如果两个小人跳到了同一个位置，只计算一份。由于两个小人是同时走，而且每次只走一步，所以，两个小人一定是同时到达右下角的，两个小人一路收集的樱桃数量，就是一来一回收集的数量。

我们可以写出第一个尝试版本，定义递归函数

int p(int[][] matrix, int m, int n, int x1, int y1, int x2, int y2)

递归函数的含义表示，第一个小人从(x1,y1)开始到右下角，第二个小人从(x2,y2)开始到右下角，获取到的最大值是多少。所以p(matrix, m, n, 0, 0, 0, 0)就是我们需要的答案。

接下来考虑base case，即：两个小人都到达了右下角，由于题目已经说了，右下角的值一定不是-1，所以，可以获得一份樱桃数量。

        if (x1 == m - 1 && y1 == n - 1) {
            // 已经到了最右下角了
            // 隐含条件：另外一个点也一定到达右下角
            // 获得一份樱桃数
            return matrix[x1][y1];
        }

接下来就是普遍尝试，分别可以分成如下四种情况：

情况1：第一个小人往下，第二个小人往右。

情况2：第一个小人往下，第二个小人往下。

情况3：第一个小人往右，第二个小人往下。

情况4：第一个小人往右，第二个小人往右。

但是在走上述任何分支的时候，记得要满足两个条件

第一个条件，不能越界

第二个条件，下一个要走的位置不能是-1，因为题目说到，-1是不能走的位置。

        int next = -1;
        // 下，下
        if (x1 + 1 < m && x2 + 1 < m && matrix[x1 + 1][y1] != -1 && matrix[x2 + 1][y2] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2 + 1, y2), next);
        }
        // 下，右
        if (x1 + 1 < m && y2 + 1 < n && matrix[x1 + 1][y1] != -1 && matrix[x2][y2 + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2, y2 + 1), next);
        }
        // 右，下
        if (y1 + 1 < n && x2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2 + 1][y2] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2 + 1, y2), next);
        }
        // 右，右
        if (y1 + 1 < n && y2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2][y2 + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2, y2 + 1), next);
        }

经过上述四个分支，如果next的值还是-1，说明无路可走，返回-1

        if (next == -1) {
            return -1;
        }

如果next不等于-1，说明有可以走的路径，那么继续判断两个小人是否在同一位置，如果在同一个位置，则只收集一份樱桃，如果不在同一个位置，收集两个小人所在位置的樱桃之和。

        if (x1 == x2) {
            // 到达同一个位置，只取一个值
            return next + matrix[x1][y1];
        }
        return next + matrix[x1][y1] + matrix[x2][y2];

注：判断同一个位置，只需要一个维度上的坐标相等即可。

完整代码

    public static int cherryPickup1(int[][] matrix) {
        return Math.max(0, p(matrix, matrix.length, matrix[0].length, 0, 0, 0, 0));
    }

    // 定义两个小人，两个人都从(0,0)位置出发，到右下角位置，每人同时选择不同的下一步，如果两个小人跳到了同一个位置，只计算一份。
    public static int p(int[][] matrix, int m, int n, int x1, int y1, int x2, int y2) {
        if (x1 == m - 1 && y1 == n - 1) {
            // 已经到了最右下角了
            // 隐含条件：另外一个点也一定到达右下角
            // 获得一份樱桃数
            return matrix[x1][y1];
        }

        int next = -1;
        // 下，下
        if (x1 + 1 < m && x2 + 1 < m && matrix[x1 + 1][y1] != -1 && matrix[x2 + 1][y2] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2 + 1, y2), next);
        }
        // 下，右
        if (x1 + 1 < m && y2 + 1 < n && matrix[x1 + 1][y1] != -1 && matrix[x2][y2 + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2, y2 + 1), next);
        }
        // 右，下
        if (y1 + 1 < n && x2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2 + 1][y2] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2 + 1, y2), next);
        }
        // 右，右
        if (y1 + 1 < n && y2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2][y2 + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2, y2 + 1), next);
        }
        if (next == -1) {
            return -1;
        }
        if (x1 == x2) {
            // 到达同一个位置，只取一个值
            return next + matrix[x1][y1];
        }
        return next + matrix[x1][y1] + matrix[x2][y2];
    }

这个解法在 LeetCode 上直接超时。

在上述尝试的基础上，我们可以做进一步的优化，递归函数现在是四个可变参数，根据我们的设计，其实可以得到如下公式

x1 + y1 = x2 + y2

那么我们可以将递归函数省略一个参数y2，因为

y2 = x1 + y1 - x2

上述递归方法我们可以修改为

// 省略y2参数
    public static int p(int[][] matrix, int m, int n, int x1, int y1, int x2) {
        if (x1 == m - 1 && y1 == n - 1) {
            // 已经到了最右下角了
            // 隐含条件：另外一个点也一定到达右下角
            // 获得一份樱桃数
            return matrix[x1][y1];
        }

        int next = -1;
        // 下，下
        if (x1 + 1 < m && x2 + 1 < m && matrix[x1 + 1][y1] != -1 && matrix[x2 + 1][getY2(x1, y1, x2)] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2 + 1), next);
        }
        // 下，右
        if (x1 + 1 < m && getY2(x1, y1, x2) + 1 < n && matrix[x1 + 1][y1] != -1 && matrix[x2][getY2(x1, y1, x2) + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2), next);
        }
        // 右，下
        if (y1 + 1 < n && x2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2 + 1][getY2(x1, y1, x2)] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2 + 1), next);
        }
        // 右，右
        if (y1 + 1 < n && getY2(x1, y1, x2) + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2][getY2(x1, y1, x2) + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2), next);
        }
        if (next == -1) {
            return -1;
        }
        if (x1 == x2) {
            // 到达同一个位置，只取一个值
            return next + matrix[x1][y1];
        }
        return next + matrix[x1][y1] + matrix[x2][getY2(x1, y1, x2)];
    }
    public static int getY2(int x1, int y1, int x2) {
        return x1 + y1 - x2;
    }

我们可以做进一步的优化，由于三个可变参数的范围分别是[0...m-1]，[0...n-1]，[0...m-1]，那么我们可以设置三维dp，将所有递归结果缓存起来

int[][][] dp = new int[m][n][m];

三维dp的所有位置初始值设置为Integer.MIN_VALUE，在递归方法中，将这个三维表作为缓存带入参数中，每次递归过程中，先从dp表中拿值，如果值不为Integer.MIN_VALUE，说明这个过程算过，直接取值即可。

    public static int p(int[][] matrix, int m, int n, int x1, int y1, int x2, int[][][] dp) {
        if (dp[x1][y1][x2] != Integer.MIN_VALUE) {
            // 说明这个过程曾经算过，直接从缓存中取值即可
            return dp[x1][y1][x2];
        }
    }

然后在每次递归过程中，将答案存入缓存，完整代码如下

    // 动态规划
    // 三维表
    public static int cherryPickup(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][][] dp = new int[m][n][m];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < m; k++) {
                    // 初始值设置为Integer.MIN_VALUE，只要不等于Integer.MIN_VALUE，就说明递归过程已经算过了
                    dp[i][j][k] = Integer.MIN_VALUE;
                }
            }
        }
        return Math.max(0, p(matrix, m, n, 0, 0, 0, dp));
    }

    // 定义两个小人，两个人都从(0,0)位置出发，到右下角位置，每人同时选择不同的下一步，如果两个小人跳到了同一个位置，只计算一份。
    public static int p(int[][] matrix, int m, int n, int x1, int y1, int x2, int[][][] dp) {
        if (dp[x1][y1][x2] != Integer.MIN_VALUE) {
            // 说明这个过程曾经算过，直接从缓存中取值即可
            return dp[x1][y1][x2];
        }
        if (x1 == m - 1 && y1 == n - 1) {
            // 已经到了最右下角了
            // 隐含条件：另外一个点也一定到达右下角
            // 获得一份樱桃数
            dp[x1][y1][x2] = matrix[x1][y1];
            return matrix[x1][y1];
        }

        int next = -1;
        // 下，下
        if (x1 + 1 < m && x2 + 1 < m && matrix[x1 + 1][y1] != -1 && matrix[x2 + 1][getY2(x1, y1, x2)] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2 + 1, dp), next);
        }
        // 下，右
        if (x1 + 1 < m && getY2(x1, y1, x2) + 1 < n && matrix[x1 + 1][y1] != -1 && matrix[x2][getY2(x1, y1, x2) + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1 + 1, y1, x2, dp), next);
        }
        // 右，下
        if (y1 + 1 < n && x2 + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2 + 1][getY2(x1, y1, x2)] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2 + 1, dp), next);
        }
        // 右，右
        if (y1 + 1 < n && getY2(x1, y1, x2) + 1 < m && matrix[x1][y1 + 1] != -1 && matrix[x2][getY2(x1, y1, x2) + 1] != -1) {
            next = Math.max(p(matrix, m, n, x1, y1 + 1, x2, dp), next);
        }
        if (next == -1) {
            dp[x1][y1][x2] = -1;
            return -1;
        }
        if (x1 == x2) {
            // 到达同一个位置，只取一个值
            // 将答案存入缓存
            dp[x1][y1][x2] = next + matrix[x1][y1];
            return dp[x1][y1][x2];
        }
        // 将答案存入缓存
        dp[x1][y1][x2] = next + matrix[x1][y1] + matrix[x2][getY2(x1, y1, x2)];
        return dp[x1][y1][x2];
    }

    public static int getY2(int x1, int y1, int x2) {
        return x1 + y1 - x2;
    }

时间复杂度O(m*n*m)，LeetCode 中直接AC。

更多

算法和数据结构笔记

标签：matrix,int,路径,问题,x2,樱桃,&&,y1,x1
来源： https://www.cnblogs.com/greyzeng/p/16415455.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。