leetcode：62. 不同路径、63. 不同路径 II、343. 整数拆分、96. 不同的二叉搜索树（JavaScript）

62. 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

思路

首先应该确定dp[i]的含义：代表到达第 [i,j] 的位置有 dp[i][j]种方法。

确定递推公式: 因为到 [i,j] 位置可以从 [i-1, j] 位置向下走一步，也可以从 [i, j-1] 位置向右走一步，所以到到 [i,j] 位置的方法就是到 [i-1, j] 位置和第 [i, j-1] 位置的方法总和，即递推公式为：

dp[i][j] = dp[i - 1][j] + dp[i][j - 1];

初始化：因为当 i = 0，时，只能从位置 [0, j-1] 到达位置 [0, j] ；当j = 0，时，只能从位置 [i-1, 0] 到达位置 [i, 0] ；所以dp[0,j] = 1, dp[i,0] = 1。

for (let i = 0; i < m; i++) {
    dp[i][0] = 1;
}
for (let j = 0; j < n; j++) {
    dp[0][j] = 1;
}

确定循环顺序：到达当前位置的不同方法由到达左边和上边的方法的到，且行和列等于0时的方法已经初始化了，所以应该从1开始，从左至右，从上至下遍历。

确定返回值：因为题目求到达右下角有几种方法，所以返回 dp[m - 1][n - 1] 就好了。

一种写法

var uniquePaths = function(m, n) {
    const dp = new Array(m).fill().map(() => new Array(n));
    // 初始化
    for (let i = 0; i < m; i++) {
        dp[i][0] = 1;
    }
    for (let i = 0; i < n; i++) {
        dp[0][i] = 1;
    }
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[m - 1][n - 1];
};

另一种写法

因为达当前位置的不同方法由到达左边和上边的方法得到，与当前位置原来的值没关系，所以可以在创建数组的时候就初始化。

var uniquePaths = function(m, n) {
    const dp = new Array(m).fill().map(() => new Array(n).fill(1));
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[m - 1][n - 1];
};

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

思路

这里dp数组的含义和递推公式与不同路径1是一样的，不同地方在于初始化和遍历的时候需要做一个判断。

初始化：因为当 i = 0，时，只能从位置 [0, j-1] 到达位置 [0, j] ；当j = 0，时，只能从位置 [i-1, 0] 到达位置 [i, 0] ；并且上诉两种情况中若中间有障碍物，那么后边的位置都无法到达，所以在创建数组的时候可以将所有元素都初始化为0,然后在单独初始化上诉两种情况dp[0,j] = 1, dp[i,0] = 1`。

for (let i = 0; i < m && obstacleGrid[i][0] != 1; i++) {
    dp[i][0] = 1;
}
for (let i = 0; i < n && obstacleGrid[0][i] != 1; i++) {
    dp[0][i] = 1;
}

确定循环顺序：到达当前位置的不同方法由到达左边和上边的方法的到，且行和列等于0时的方法已经初始化了，所以应该从1开始，从左至右，从上至下遍历，并且在遍历过程中若当前位置是障碍物那么当前位置无法到达，方法就为0。

var uniquePathsWithObstacles = function(obstacleGrid) {
    let m = obstacleGrid.length;
    let n = obstacleGrid[0].length;
    const dp = new Array(m).fill().map(() => new Array(n).fill(0));
    // 初始化
    for (let i = 0; i < m && obstacleGrid[i][0] != 1; i++) {
        dp[i][0] = 1;
    }
    for (let i = 0; i < n && obstacleGrid[0][i] != 1; i++) {
        dp[0][i] = 1;
    }
    // 遍历
    for (let i = 1; i < m; i++) {
        for (let j = 1; j < n; j++) {
            // 判断当前位置只有没有障碍物时才进行方法的统计
            if (obstacleGrid[i][j] != 1)
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
        }
    }
    return dp[m - 1][n - 1];
};

343. 整数拆分

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

dp思路

首先应该确定dp[i]的含义：代表 整数 i 拆分后的最大乘积为dp[i]。

确定递推公式：其实可以从1遍历 j，然后有两种渠道得到 dp[i]：一个是 j * (i - j) 直接相乘。一个是 j * dp[i - j]，相当于是拆分 (i - j)，对这个拆分不理解的话，可以回想dp数组的定义。可以这么理解 j * (i - j) 是单纯的把整数拆分为两个数相乘，而 j * dp[i - j] 是拆分成两个以及两个以上的个数相乘。 dp[i - j] * dp[j] 也是默认将一个数强制拆成4份以及4份以上了。

dp[i] = Math.max(dp[i], dp[i-j] * j, (i-j) * j);

初始化：严格从dp[i]的定义来说，dp[0] dp[1] 是没有意义的数值，所以只用初始化 dp[2] = 1, dp[3]级以后的值可以在遍历中得到不用初始化 。

dp[2] = 1;

确定循环顺序：dp[i] 由 dp[i - j]得到，所以遍历i一定是从左向右，先有dp[i - j]再有dp[i]。枚举j的时候，是从1开始的。i是从3开始，这样就可以由我们初始化的数值求出来其他的值。

确定返回值：因为题目求拆分整数n的最大乘积，所以根据dp数组的含义返回 dp[n] 就好了。

var integerBreak = function(n) {
    const dp = Array(n + 1).fill(0);
	// 初始化
    dp[2] = 1;
    for (let i = 3; i <= n; i++) {
        for (let j = 1; j < i; j++) {
            dp[i] = Math.max(dp[i], dp[i-j] * j, (i-j) * j);
        }
    }
    return dp[n];
};

非dp思路

我们先列几个数找找规律（这里只是举例不保证积最大）：
4=2+2、5=3+2、6=3+3、7=3+2+2、8=2+2+2+2、9=3+3+3、10=2+2+2+2+2 …

观察可以得如下规律：

1. 拆分的自然数不会超过3，因为4可以化为2+2，5可以化为3+2>5，所以所有的数都可以拆为只 有3和2的数；
2. 因为都可以拆除3和2，所有为了使乘积大，应该先尽可能拆除3，而后拆除2，分成1无贡献；

考虑所有的n除以3的情况：

• 可以被3整除，那么就将他全部拆为3，如:9=3+3+3；
• 被3除余1，那么可以拆为形如3+3+……+3+4，即3+3+……+3+2+2，如10=3+3+2+2；
• 被3除余2，那么可以拆为形如3+3+……+3+2，如11=3+3+3+2；

var integerBreak = function(n) {
    if (n <= 3) return n - 1;
    // 统计最多能分成多少个3
    let num = Math.floor(n / 3);
    // 得到余数
    let y = n % 3;
    // 统计乘积
    let ji = 1;
    // 如果余数为1，则将余数赋值为4，3的数量减1
    if (y === 1){
        num--;
        y = 4;
    } else if (y === 0) {// 如果余数为0，则要将与数变为1,否则最后一步会使整个乘积变为0
        y = 1;
    }
    // 循环求积
    while(num--) {
        ji *= 3;
    }
    // 最后乘以余数
    ji *= y;
    return ji;
};

96. 不同的二叉搜索树

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

思路

首先应该确定dp[i]的含义：代表 i 个节点组成的互不相同的搜索树为dp[i]。

确定递推公式：分析一下n为3的几种情况。

当1为头结点的时候，其右子树有两个节点，和 n 为2的时候两棵树的布局一样有两种！注意：我们就是求不同树的数量，不用管子树的数值， 当3为头结点的时候，其左子树有两个节点，和n为2的时候两棵树的布局也是一样的！当2为头结点的时候，其左右子树都只有一个节点，和n为1的时候只有一棵树的布局也是一样的！所以dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量

for (let j = 1; j <= i; j++) {
    dp[i] += dp[j - 1] * dp[i - j];
}

初始化：严格从dp[i]的定义来说，空节点也是一棵二叉树，所以

 dp[0] = 1;

确定循环顺序：dp[i] 由 i 之前的树的不同搜索树的种类得到，所以应该从左向右遍历。

确定返回值：因为题目求 n 个节点的不同二叉搜索树的个数，所以根据dp数组的含义返回 dp[n] 就好了。

var numTrees = function(n) {
    const dp = new Array(n + 1).fill(0);
    // 初始化
    dp[0] = 1;
    for (let i = 1; i <= n; i++) {
        for (let j = 1; j <= i; j++) {
            dp[i] += dp[j - 1] * dp[i - j];
        }
    }
    return dp[n];
};