力扣题解之暴力动态规划

题目介绍

在开始解决这道题之前，我们不妨先将题目条件修改一点：将上、下、左、右四个方向之一移动改为下、右两个之一方向移动。

解决方案

修改条件之后的题目就是一道很经典的动态规划题目，使用动态规划的经典解决手段–填表法不难得出其状态转移方程为：

rowMax = Math.max(dp[i - 1][j], Math.abs(heights[i - 1][j] - heights[i][j]));
colMax = Math.max(dp[i][j - 1], Math.abs(heights[i][j - 1] - heights[i][j]));
dp[i][j] = Math.min(rowMax, colMax);

完整代码如下：

function minimumEffortPath(heights: number[][]): number {
    const rowLength = heights.length;
    const colLength = heights[0].length;
    const dp = new Array(rowLength).fill(0).map(x => new Array(colLength).fill(1000000));
    for (let i = 0; i < rowLength; i++) {
        for (let j = 0; j < colLength; j++) {
            if (i === 0 && j === 0) {
                continue;
            }
            let rowMax = i > 0 ? 0 : 1000000;
            if (i - 1 >= 0) {
                rowMax = Math.max(dp[i - 1][j], Math.abs(heights[i - 1][j] - heights[i][j]));
            }
            let colMax = j > 0 ? 0 : 1000000;
            if (j - 1 >= 0) {
                colMax = Math.max(dp[i][j - 1], Math.abs(heights[i][j - 1] - heights[i][j]));
            }
            dp[i][j] = Math.min(rowMax, colMax);
        }
    }
    // console.log(dp);
    return dp[rowLength - 1][colLength - 1];
};

暴力动规

动态规划虽然好用，但是原题目多了上、左两个选择方向，所以完全按照上述的遍历方式显然是不对的，新的解决思路：我们不妨再添加两个方向，并且每个方向都是独立的循环模块，并且在将四个方向的模块整合进一个“死循环”内，直到dp最优即可跳出最外层的循环。
原题代码：

function minimumEffortPath(heights: number[][]): number {
    const rowLength = heights.length;
    const colLength = heights[0].length;
    const dp = new Array(rowLength).fill(0).map(x => new Array(colLength).fill(1000000));
    dp[0][0] = 0;
    let isContinue = true;
    while (isContinue) {
        isContinue = false;
        for (let i = 0; i < rowLength; i++) {
            for (let j = 0; j < colLength; j++) {
                if (i - 1 >= 0) {
                    let x = Math.max(dp[i - 1][j], Math.abs(heights[i][j] - heights[i - 1][j]));
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
                if (j - 1 >= 0) {
                    let x = Math.max(dp[i][j - 1], Math.abs(heights[i][j] - heights[i][j - 1]));
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
            }
        }
        for (let i = rowLength - 1; i >= 0; i--) {
            for (let j = colLength - 1; j >= 0; j--) {
                if (i + 1 < rowLength) {
                    let x = Math.max(dp[i + 1][j], Math.abs(heights[i][j] - heights[i + 1][j]));
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
                if (j + 1 < colLength) {
                    let x = Math.max(dp[i][j + 1], Math.abs(heights[i][j] - heights[i][j + 1]));
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
            }
        }
    }
    return dp[rowLength - 1][colLength - 1];
};

扩展题

一个很神奇的现象是第一道题目是中等难度而这道题目却竟然是困难难度，其实这道题和上述那道题异曲同工并且其状态转移方程更为简单：将Math.abs()换成grid[i][j]即可。
完整代码如下：

function swimInWater(grid: number[][]): number {
    const length = grid.length;
    const dp = new Array(length).fill(0).map(x => new Array(length).fill(Number.MAX_SAFE_INTEGER));
    dp[0][0] = grid[0][0];
    let isContinue = true;
    while (isContinue) {
        isContinue = false;
        for (let i = 0; i < length; i++) {
            for (let j = 0; j < length; j++) {
                if (i - 1 >= 0) {
                    let x = Math.max(dp[i - 1][j], grid[i][j]);
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
                if (j - 1 >= 0) {
                    let x = Math.max(dp[i][j - 1], grid[i][j]);
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
            }
        }
        for (let i = length - 1; i >= 0; i--) {
            for (let j = length - 1; j >= 0; j--) {
                if (i + 1 < length) {
                    let x = Math.max(dp[i + 1][j], grid[i][j]);
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
                if (j + 1 < length) {
                    let x = Math.max(dp[i][j + 1], grid[i][j]);
                    if (x < dp[i][j]) {
                        dp[i][j] = x;
                        isContinue = true;
                    }
                }
            }
        }
    }
    return dp[length - 1][length - 1];
};

结语

其实这两道题目官方给出的题解是以图为出发点的解决方案，例如二分查找+（广度/深度）优先搜索、并查集以及Dijkstra 算法。而在这里我更加钟爱于动态规划罢了。