不同路径
62. 不同路径 - 力扣(LeetCode) (leetcode-cn.com)
- 状态转移方程:到达
(x, y)
的路径数等于到达(x - 1, y)
和(x, y - 1)
路径数之和 - dp定义:从
(0, 0)
到(x, y)
有dp(x, y)
条路径
写法一:
class Solution {
public int uniquePaths(int m, int n) {
int[][] dp = new int[m][n];
//注意该题初始化
for(int i = 0; i < m; i++){
dp[i][0] = 1;
}
for(int i = 0; i < n; i++){
dp[0][i] = 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];
}
}
写法二:
public int uniquePaths(int m, int n) {
return dp(m - 1, n - 1);
}
int dp(int x, int y) {
if (x == 0 && y == 0) {
return 1;
}
if (x < 0 || y < 0) {
return 0;
}
return dp(x - 1, y) + dp(x, y - 1);
}
不同路径||
63. 不同路径 II - 力扣(LeetCode) (leetcode-cn.com)
- 此题和上一题相比只是多了一个“障碍”条件,状态转移方程不变,只是注意要在遇到障碍时候
dp[i][j]
保持0
写法一:
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length, n = obstacleGrid[0].length;
int[][] dp = new int[m][n];
//注意该题初始化
//初始化的部分,很容易忽略了障碍之后应该都是0的情况
for(int i = 0; i < m; i++){
//一旦遇到障碍,后续都无法到达了
if(obstacleGrid[i][0] == 1){
break;
}
dp[i][0] = 1;
}
for(int i = 0; i < n; i++){
//一旦遇到障碍,后续都无法到达了
if(obstacleGrid[0][i] == 1){
break;
}
dp[0][i] = 1;
}
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
//遇到障碍dp[i][j]保持0
if(obstacleGrid[i][j] == 1){
continue;
}
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
}
写法二:自顶向下递归
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
memo = new int[m][n];//备忘录
return dp(obstacleGrid, m - 1, n - 1);
}
// 备忘录
int[][] memo;
// 定义:从 grid[0][0] 出发到达 grid[i][j] 的路径条数为 dp(grid, i, j)
int dp(int[][] grid, int i, int j) {
int m = grid.length, n = grid[0].length;
// base case
if (i < 0 || i >= m || j < 0 || j >= n
|| grid[i][j] == 1) {
// 数组越界或者遇到阻碍
return 0;
}
if (i == 0 && j == 0) {
// 起点到起点的路径条数就是 1
return 1;
}
if (memo[i][j] > 0) {
// 避免冗余计算
return memo[i][j];
}
// 状态转移方程:
// 到达 grid[i][j] 的路径条数等于
// 到达 grid[i-1][j] 的路径条数加上到达 grid[i][j-1] 的路径条数
int left = dp(grid, i, j - 1);
int upper = dp(grid, i - 1, j);
int res = left + upper;
// 存储备忘录
memo[i][j] = res;
return res;
}
}
写法三:自底向上迭代
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
// 数组索引偏移一位,dp[0][..] dp[..][0] 代表 obstacleGrid 之外
// 定义:到达 obstacleGrid[i][j] 的路径条数为 dp[i-1][j-1]
int[][] dp = new int[m + 1][n + 1];
// base case:如果没有障碍物,起点到起点的路径条数就是 1
dp[1][1] = obstacleGrid[0][0] == 1 ? 0 : 1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (i == 1 && j == 1) {
// 跳过 base case
continue;
}
if (obstacleGrid[i - 1][j - 1] == 1) {
// 跳过障碍物的格子
continue;
}
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
// 返回到达 obstacleGrid[m-1][n-1] 的路径数量
return dp[m][n];
}
}
写法四:优化二维dp数组为一维dp数组
class Solution {
public int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length;
int n = obstacleGrid[0].length;
// 根据二维 dp 数组优化为一维 dp 数组
int[] dp = new int[n + 1];
dp[1] = obstacleGrid[0][0] == 1 ? 0 : 1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (i == 1 && j == 1) {
// 跳过 base case
continue;
}
if (obstacleGrid[i - 1][j - 1] == 1) {
// 跳过障碍物的格子
dp[j] = 0;
continue;
}
dp[j] = dp[j] + dp[j - 1];
}
}
// 返回到达 obstacleGrid[m-1][n-1] 的路径数量
return dp[n];
}
}
迷路的机器人
面试题 08.02. 迷路的机器人 - 力扣(LeetCode) (leetcode-cn.com)
回溯+路径记录:
class Solution {
boolean[][] visited;
List<List<Integer>> pathList;
public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length, n = obstacleGrid[0].length;
visited = new boolean[m][n];
pathList = new ArrayList<>();
dfs(0, 0, obstacleGrid);
return pathList;
}
//参数:横纵坐标
private boolean dfs(int row, int col, int[][] obstacleGrid){
int m = obstacleGrid.length, n = obstacleGrid[0].length;
//异常情况:行坐标超出范围 || 列坐标超出范围 || 格子里面是障碍物 || 已经访问过这个格子
if(row >= m || col >= n || obstacleGrid[row][col] == 1 || visited[row][col]){
return false;
}
//不是以上情况,说明这份格子值得探索,所以做出选择
pathList.add(Arrays.asList(row, col));
//将格子标记为已经历
visited[row][col] = true;
//已经到达最后一个格子:
if(row == m - 1 && col == n - 1){
return true;
}
//选择后没到最后一个格子:
//如果右边格子或者下边格子是true的话,返回true。
//先尝试向下,再尝试向右:
//神奇的或运算
//这里有一点需要注意,因为||的性质,前者为true的时候,就先不执行右格了。
//只有下格之后的路径难以为继的时候,才会来这里继续执行右格
if(dfs(row + 1, col, obstacleGrid) || dfs(row, col + 1, obstacleGrid)){
return true;
}
//如果已经到了末路,即当前格子没有障碍,
//但右、下格子都是障碍的话,但还没有到达最后的格子,
//穷途末路,到了死胡同,就要撤销选择,回头是岸
//此时删掉数组pathList的最后一个元素。并返回false
pathList.remove(pathList.size() - 1);
return false;
}
}
注意这道题有一个坑,孩子已经跳进去一回了!!!!就是回溯的时候visited不用设置回false,实际上,这道题的约束条件:机器人只能向右或向下走,产生了最为关键的影响。以下解释摘自leetcode题解区域。
链接:https://leetcode-cn.com/problems/robot-in-a-grid-lcci/solution/cong-wu-hou-xiao-xing-yuan-lai-nong-dong-spqj/
-
不管我之前是怎么到达
(row, col)
这个坐标的,我在选择要走到别的格子的时候,只能向下或向右,和之前怎么走到(row, col)
是无关的。那么可以推出:如果我曾经经过(row, col)
这个坐标,并且继续往下走得很深,但是最终失败了,那么当我再次从别的格子走到(row, col)
时,也就没有必要继续往下搜了,因为它接下来还是只能往下或往右走,并且最终一定会失败,那么也就没有必要接着走到(row, col)
,所以也没有必要在回溯的时候,把visited[row][col]
设为false
了。 -
这里牵扯到了动态规划里面的一个基本原理:无后效性。
-
简单点说,就是我T时间到达了某个状态,在对后面要到达什么的状态进行决策的时候,和T时间之前的决策没有关系,也可以说,T时间之前的决策,对T时间之后的决策,不会产生任何影响。
-
所以如果这个题目的条件改为每个格子的上下左右都可以走,就不满足无后效性了。
可以这样分析,假设我现在在
(row, col)
这个位置,并且是从上面的格子(row - 1, col)
过来的,那么我从(row, col)
接着走,就只能往下、左、右这三个方向,其他方向也是同理,有以下关系:(row - 1, col) - > (row, col)
,上边过来, 接下来的决策方向:下、左、右(row, col - 1) - > (row, col)
,左边过来, 接下来的决策方向:上、下、右(row + 1, col) - > (row, col)
,下边过来, 接下来的决策方向:上、左、右(row, col + 1) - > (row, col)
,右边过来, 接下来的决策方向:上、下、左
从列表中我们可以看到,
(row, col)
前的决策不同的话,(row, col)
后的决策也是不同的,也就是说,(row, col)
前的决策,会影响(row, col)
后的决策,所以也就不满足无效性这个性质。 -
本题满足无后效性,当然能通过动态规划来求解,如果换了条件(上下左右)就只能用回溯来做了,动态规划想都不要想了!!!
动态规划版本:
- dp定义:
dp[i][j]
表示能否到达(i, j)
- 路径转移:
obstacleGrid[i][j] = 1
:d[i][j] = false
obstacleGrid[i][j] = 0
:dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
,这里用或运算表示
class Solution {
public List<List<Integer>> pathWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length, n = obstacleGrid[0].length;
List<List<Integer>> pathList = new ArrayList<>();
//dp[i][j]表示能否到达i, j
boolean[][] dp = new boolean[m][n];
if(obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1){
return pathList;
}
//初始化:原点、首行、首列
dp[0][0] = true;
for(int i = 1; i < m; i++){
dp[i][0] = (obstacleGrid[i][0] == 0) && dp[i - 1][0];
}
for(int i = 1; i < n; i++){
dp[0][i] = (obstacleGrid[0][i] == 0) && dp[0][i - 1];
}
//计算
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = (obstacleGrid[i][j] == 0) && (dp[i - 1][j] || dp[i][j - 1]);
}
}
//终点不可达:返回空数组
if(dp[m - 1][n - 1] == false){
return pathList;
}
//终点可达,倒序计算
int i = m - 1, j = n - 1;
while(i > 0 || j > 0){
pathList.add(Arrays.asList(i, j));
if(i > 0 && dp[i - 1][j]){
i--;
}else{
j--;
}
}
//插入起点
pathList.add(Arrays.asList(0, 0));
Collections.reverse(pathList);
return pathList;
}
}
机器人的运动范围
剑指 Offer 13. 机器人的运动范围 - 力扣(LeetCode) (leetcode-cn.com)
class Solution {
public int movingCount(int m, int n, int k) {
boolean[][] visited = new boolean[m][n];
return dfs(0, 0, m, n, k, visited);
}
private int dfs(int i, int j, int m, int n, int k, boolean visited[][]) {
if (i < 0 || i >= m || j < 0 || j >= n || (i/10 + i%10 + j/10 + j%10) > k || visited[i][j]) {
return 0;
}
visited[i][j] = true;
return dfs(i + 1, j, m, n, k, visited) + dfs(i - 1, j, m, n, k, visited) +
dfs(i, j + 1, m, n, k, visited) + dfs(i, j - 1, m, n, k, visited) + 1;
}
}
优化:
- 这道题由于是从原点开始移动的,所以可以简化成向下、向右移动;
- 顺便这里把多于两位数的数位之和的计算补充一下。
class Solution {
public int movingCount(int m, int n, int k) {
boolean[][] visited = new boolean[m][n];
return dfs(0, 0, m, n, k, visited);
}
public int dfs(int i, int j, int m, int n, int k, boolean[][] visited) {
if(i >= m || j >= n || k < getSum(i) + getSum(j) || visited[i][j]) {
return 0;
}
visited[i][j] = true;
return 1 + dfs(i + 1, j, m, n, k, visited) + dfs(i, j + 1, m, n, k, visited);
}
private int getSum(int a) {
int sum = a % 10;
int tmp = a / 10;
while(tmp > 0) {
sum += tmp % 10;
tmp /= 10;
}
return sum;
}
}
知识小点:Arrays.asList()
Arrays.asList() 详解 - 简书 (jianshu.com)
今日推歌
-----《海平面的星》
你给的爱是
飘忽海平面上的星星
再美丽 也是种倒影
谁脚步轻盈
编织若有似无的爱情
你离开 我的心却永远
无法风平浪静