LeetCode刷题day53

文章目录

• ​​62. 不同路径​​

• ​​题目描述​​
• ​​思路分析​​
• ​​参考代码​​

• ​​63. 不同路径 II​​

• ​​题目描述​​
• ​​思路分析​​
• ​​参考代码​​

• ​​343. 整数拆分​​

• ​​题目描述​​
• ​​思路分析​​
• ​​参考代码​​

• ​​96. 不同的二叉搜索树​​

• ​​题目描述​​
• ​​思路分析​​
• ​​参考代码​​

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

思路分析

方法一:深搜

机器人只能向下和向右走,所以按照Dfs的书写步骤来操作即可. 但是由于深搜的时间复杂度是

方法二:动态规划

机器人从(0 , 0) 位置出发，到(m - 1, n - 1)终点。

按照 动规五部曲 来分析：

• 确定dp数组以及下标的含义

​​dp[i][j]​​：表示从（0 ，0）出发，到(i, j) 有 dp[i][j] 条不同的路径。

• 确定递推公式

要求​​dp[i][j]​​​，只能有两个方向来推导出来，即​​dp[i - 1][j]​​​和 ​​dp[i][j - 1]​​。

此时在回顾一下 ​​dp[i - 1][j]​​表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，​​dp[i][j - 1]​​同理。

那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。

• dp数组的初始化

如何初始化呢，首先​​dp[i][0]​​​一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么​​dp[0​​][j]也同理。

• 定遍历顺序

这里要看一下递归公式​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​​，​​dp[i][j]​​都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

这样就可以保证推导​​dp[i][j]​​​的时候，​​dp[i - 1][j] 和 dp[i][j - 1]​​一定是有数值的。

• 举例推导dp数组

参考代码

方法一:深搜

//方法一:深搜..
int sum;//路的条数
int Next[2][2] = {{1,0},{0,1}} ;//定义方向数组
void dfs(int m,int n,int x,int y) {
  if(x==m && y==n) { //递归结束条件
    sum++;
    return;
  }
  for(int i = 0; i <2; i++) {
    //判断是否越界
    int nextX = x + Next[i][0];
    int nextY = y + Next[i][1];
    if(nextX>m || nextY > n) {//越界
      continue;
    }
    //继续dfs
    dfs(m,n,nextX,nextY);
    //不需要回溯,因为 每次这条路不行就走另外一条了,x,y还和之前一样.. 另外行进也是越来越靠近目标点的,也不用做标记啥的.
  }
}

int uniquePaths(int m, int n) {
  dfs(m,n,1,1) ;
  return sum;
}

//备注:大佬的dfs,呜呜呜,同样的深搜,人家可以写的如此短小精悍
int dfs(int i, int j, int m, int n) {
  if(i>m || j > n) {//越界了
    return 0;
  }
  if(i==m&&j==n) {//找到了另外一种方法
    return 1;
  }
  return dfs(i+1,j,m,n)  + dfs(i,j+1,m,n);
}

方法二:动态规划

//方法二:动归
int uniquePaths(int m, int n) {
  vector<vector<int>> dp(m,vector<int>(n,0));
  //dp[0][j]和dp[i][0]初始化为1,因为路径只有一条
  for(int i = 0; i < m; i++){
    dp[i][0] = 1;
  }
  for(int j = 0; j < n;j++){
    dp[0][j] = 1;
  }
  //根据状态转移方程dp[i][j]  = dp[i-1][j] + dp[i][j-1],推出dp[m-1][n-1] 
  for(int i = 1; i < m;i++) {
    for(int 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

思路分析

这道题相对于​​62.不同路径 (opens new window)​​就是有了障碍。这有障碍了，应该怎么算呢？

动规五部曲：

• 确定dp数组以及下标的含义

​​dp[i][j]​​​：表示从（0 ，0）出发，到(i, j) 有​​dp[i][j]​​条不同的路径。

• 确定递推公式

递推公式和 62.不同路径 一样，​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​。

但这里需要注意一点，因为有了障碍，(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）。

• dp数组如何初始化

因为从(0, 0)的位置到(i, 0)的路径只有一条，所以​​dp[i][0]​​​一定为1，​​dp[0][j]​​也同理。

但如果(i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的​​dp[i][0]​​应该还是初始值0。

如图：

• 确定遍历顺序

从递归公式​​dp[i][j] = dp[i - 1][j] + dp[i][j - 1]​​中可以看出，一定是从左到右一层一层遍历，这样保证推导​​dp[i][j]​​​的时候，​​dp[i - 1][j] 和 dp[i][j - 1]​​一定是有数值。

• 举例推导dp数组

拿示例1来举例如题：

对应的dp 如图：

参考代码

#include<bits/stdc++.h>
using namespace std;

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
  int m = obstacleGrid.size();
  int n = obstacleGrid[0].size();
  vector<vector<int>> dp(m,vector<int>(n,0));
  //dp初始化 第一行和第一列初始化为1,但是障碍物之后初始化为0
  for(int i = 0; i < m; i++) {
    if(!obstacleGrid[i][0]) {
      dp[i][0] = 1;
    } else {
      break;//如果此处是障碍物,后序dp[i][0]为0
    }
  }

  for(int j = 0; j < n; j++) {
    if(obstacleGrid[i][j]==0) {
      dp[0][j] = 1;
    } else {
      break;//如果此处是障碍物,后序dp[i][0]为0
    }
  }
  //推导dp
  for(int i = 1; i < m; i++) {
    for(int j = 1; j < n; j++) {
      if(obstacleGrid[0][j]) { //如果是障碍物,则跳过.
        continue;
      }
      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]。

• 确定递推公式

可以想 ​​dp[i]​​最大乘积是怎么得到的呢？

其实可以从1遍历j，然后有两种渠道得到dp[i].

一个是​​j * (i - j)​​直接相乘。

一个是​​j * dp[i - j]​​，相当于是拆分(i - j)，对这个拆分不理解的话，可以回想dp数组的定义。

那有同学问了，j怎么就不拆分呢？

j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了。

所以递推公式：​​dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));​​

那么在取最大值的时候，为什么还要比较dp[i]呢？

因为在递推公式推导的过程中，每次计算dp[i]，要取最大值。

• dp的初始化

dp[0] dp[1]应该初始化多少呢？

有的题解里会给出dp[0] = 1，dp[1] = 1的初始化，但解释比较牵强，主要还是因为这么初始化可以把题目过了。

严格从dp[i]的定义来说，dp[0] dp[1] 就不应该初始化，也就是没有意义的数值。而且题目中 ​​n >=2​​

这里我只初始化dp[2] = 1，从dp[i]的定义来说，拆分数字2，得到的最大乘积是1，这个没有任何异议！

• 确定遍历顺序

确定遍历顺序，先来看看递归公式：​​dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));​​

dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。

枚举j的时候，是从1开始的。i是从3开始，这样dp[i - j]就是dp[2]正好可以通过我们初始化的数值求出来。

另外 ​​i-j > 1 => j < i - 1​​ ,这个可以作为j的循环条件

• 举例推导dp数组

当n为10 的时候，dp数组里的数值，如下：

参考代码

#include<bits/stdc++.h>
using namespace std;
/*
    1.DP定义：将整数i进行拆分后乘积最大值为dp[i]
    2.状态转移方程：
        2.1 设一个j为i拆分后的一个数 则另外一个数为(i-j)
        2.2 (i-j)可以直接与j进行相乘 也可以进行拆分后与i进行相乘
        2.3 dp[i] = max(j*(i-j),j*dp[i-j])
    3.初始化base case：
         0和1进行拆分是无意义的 由n的范围[2,58]也可知
        因此dp[0]/dp[1]是无意义的 同时也不需要进行赋值 在后面的程序中也不应该用到dp[0]/dp[1]
        故初始化dp[2]=1.
    4.遍历顺序：见下文
*/
int integerBreak(int n) {
    vector<int> dp(n+1,0);
    dp[2] = 1;
    //遍历从3到n 填充这些数对应的dp值
    //目标结果：dp[n]
    for(int i = 3; i <= n; i++) {
        // 由于dp[2]及其之后才有意义,所以 i-j >1  即j<i-1
        for(int j = 1; j < i - 1; j++) {
            dp[i] = max(dp[i],max(j*(i-j),j*dp[i-j]));//因为求的是最大值,所以max中也需要dp[i] 
        }
    }
    //n拆分后的数集的最大乘积 即dp[n]
    return dp[n];
}

96. 不同的二叉搜索树

​​题目描述​​

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

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

思路分析

我们先观察下有没有什么规律，如图：

来看看n为3的时候，有哪几种情况。

• 当1为头结点的时候，其右子树有两个节点，看这两个节点的布局，是不是和 n 为2的时候两棵树的布局是一样的啊！（我们求的是树的数量,所以不用关心其具体数值的差异）
• 当3为头结点的时候，其左子树有两个节点，看这两个节点的布局，是不是和n为2的时候两棵树的布局也是一样的啊！
• 当2为头结点的时候，其左右子树都只有一个节点，布局是不是和n为1的时候只有一棵树的布局也是一样的啊！

发现到这里，其实我们就找到了重叠子问题了，其实也就是发现可以通过dp[1] 和 dp[2] 来推导出来dp[3]的某种方式。

思考到这里，这道题目就有眉目了。

dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

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

有2个元素的搜索树数量就是dp[2]。

有1个元素的搜索树数量就是dp[1]。

有0个元素的搜索树数量就是dp[0]。

所以​​dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]​​

如图所示：

此时我们已经找到递推关系了，那么可以用**动规五部曲**再系统分析一遍。

• 确定dp数组（dp table）以及下标的含义

dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。

以下分析如果想不清楚，就来回想一下dp[i]的定义

• 确定递推公式

在上面的分析中，其实已经看出其递推关系， dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] (j相当于是头结点的元素，从1遍历到i为止。)

所以递推公式：​​dp[i] += dp[j - 1] * dp[i - j];​​ j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量

• dp数组如何初始化

初始化，只需要初始化dp[0]就可以了，推导的基础，都是dp[0]。

那么dp[0]应该是多少呢？

从定义上来讲，空节点也是一棵二叉树，也是一棵二叉搜索树，这是可以说得通的。

从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。

所以初始化dp[0] = 1

• 确定遍历顺序

首先一定是遍历节点数，从递归公式：​​dp[i] += dp[j - 1] * dp[i - j]​​可以看出，节点数为i的状态是依靠 i之前节点数的状态。

那么遍历i里面每一个数作为头结点的状态，用j来遍历。

• 举例推导dp数组

n为5时候的dp数组状态如图：

参考代码

#include<bits/stdc++.h>
using namespace std;

int numTrees(int n) {
  vector<int> dp(n+1,0) ;
  dp[0] = 1;
  for(int i = 1;i <= n;i++){
//    cout<<"dp["<<i<<"]: ";
    for(int j = 1; j <= i;j++){
      dp[i] += dp[j-1] * dp[i-j];//状态转移方程  
//      cout<<dp[j-1] * dp[i-j]<<" ";
    }
    cout<<endl;
  }
  return dp[n];
}

​