不同路径
一个机器人位于一个 m x n
网格的左上角 (起始点在下图中标记为 “Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。
问总共有多少条不同的路径?
示例 1:
输入:m = 3, n = 7
输出:28
示例 2:
输入:m = 3, n = 2
输出:3
解释:
从左上角开始,总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下
提示:
1 <= m, n <= 100
- 题目数据保证答案小于等于
2 * 109
深搜
这道题目,刚一看最直观的想法就是用图论里的深搜,来枚举出来有多少种路径。
注意题目中说机器人每次只能向下或者向右移动一步,那么其实机器人走过的路径可以抽象为一棵二叉树,而叶子节点就是终点!
此时问题就可以转化为求二叉树叶子节点的个数:
![62.不同路径](https://img-blog.csdnimg.cn/img_convert/acb172d9f16f34d275471f1947c05a8b.png)
class Solution {
public int uniquePaths(int m, int n) {
return dfs(1,1,m,n);
}
public int dfs(int i,int j,int m,int n){
if(i > m || j > n) return 0;//越界
if(i == m && j == n) return 1;//找到终点(m,n)
return dfs(i+ 1,j,m,n) + dfs(i,j+1,m,n);//递归
}
}
提交了代码就会发现超时了!
来分析一下时间复杂度,这个深搜的算法,其实就是要遍历整个二叉树。
树的深度其实就是m+n-1(深度按从1开始计算);
二叉树的节点个数就是 2^(m + n - 1) - 1;深搜代码的时间复杂度为O(2^(m + n - 1) - 1),可以看出,这是指数级别的时间复杂度,是非常大的。
动态规划
1.二维dp数组
机器人从(0 , 0) 位置出发,到(m - 1, n - 1)终点。
按照动规五部曲来分析:
- 确定dp数组(dp table)以及下标的含义
dp[i][j]
:表示从(0 ,0)出发,到(i, j) 有dp[i][j]
条不同的路径。
2.确定递推公式
想要求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]
只有这两个方向过来。
3.dp数组的初始化
如何初始化呢,首先dp[i][0]
一定都是1,因为从(0, 0)的位置到(i, 0)的路径只有一条,那么dp[0][j]
也同理。
所以初始化代码为:
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;
4.确定遍历顺序
dp[i][j]
都是从其上方和左方推导而来,那么从左到右一层一层遍历就可以了。保证推导dp[i][j]
的时候,dp[i - 1][j]
和 dp[i][j - 1]
一定是有数值的
5.举例推导dp数组
如图所示:
![62.不同路径1](https://img-blog.csdnimg.cn/img_convert/c4a96f94d13f2fe065c062076990330b.png)
class Solution {
public int uniquePaths(int m, int n) {
int[][] vector = new int[m][n];
//初始化二维数组
for(int i = 0; i < m; i++){//第一列
vector[i][0] = 1;
}
for(int j = 0; j < n; j++){//第一行
vector[0][j] = 1;
}
for(int i = 1; i < m; i++){//遍历
for(int j = 1;j < n;j++){
vector[i][j] = vector[i - 1][j] + vector[i][j-1];//递推公式
}
}
return vector[m-1][n-1];
}
}
- 时间复杂度:O(m × n)
- 空间复杂度:O(m × n)
2.滚动数组
用一个一维数组(可以理解是滚动数组)来进行优化空间复杂度。
class Solution {
public int uniquePaths(int m, int n) {
int[] dp = new int[n];//根据列数 新建一维数组
//初始化第一行
for(int i = 0; i < n; i++){
dp[i] = 1;
}
//遍历
for(int i = 1;i < m; i ++){//行遍历,实现滚动效果
for(int j = 1;j < n; j++){// 列遍历进行更新一维数组
dp[j] = dp[j-1] + dp[j];//下一行时: dp[j] 代表上方,dp[j-1]代表左方
}
}
return dp[n-1];
}
}
数论方法
![62.不同路径](https://img-blog.csdnimg.cn/img_convert/6b01f1c9891a2f1f712bb1e12432f36a.png)
从起点(左上角)到终点(右下角),行方向需要m-1
步,列方向需要n-1
步,总共需要m+n-1
步。
那么有几种走法呢? 可以转化为,给你m + n - 2
个不同的数,随便取m - 1
个数,有几种取法。
排列是与次序相关的,而组合是与次序无关的。如:有10个参赛选手(A、B、C、D、E、F、G、H、I、J),选取3名发奖牌(奖牌相同),分析总共有多少种情况。因为排列有先后,所以A、B、C和A、C、B是不同的排列情况,但是这两种在组合中被认为是相同。也就是说将排列中因为排序不同,但是实际选手组合相同的情况去除,即是组合的情况。因为排序导致的不同是C(3,3)。那么C(n,r)=P(n,r)/P(r,r)=P(n,r)/r!。
![img](https://i-blog.csdnimg.cn/blog_migrate/641acc720c2c96cdb08f56e3b0151b73.png)
class Solution {
public:
int uniquePaths(int m, int n) {
int numerator = 1, denominator = 1;
int count = m - 1;//分子项数
int t = m + n - 2;
while (count--) numerator *= (t--); // 计算分子,此时分子就会溢出
for (int i = 1; i <= m - 1; i++) denominator *= i; // 计算分母
return numerator / denominator;
}
};
//求组合的时候,要防止两个int相乘溢出! 所以不能把算式的分子都算出来,分母都算出来再做除法。
总结
维护的是一个二维DP数组。可以用滚动数组进行降维。回顾深度遍历,二叉树的深度与节点个数间的关系:满二叉树节点数2^h - 1
;