【力扣】不同路径系列
Leetcode 0062 不同路径
题目描述：Leetcode 0062 不同路径
分析
-
本题的考点：动态规划。
-
状态表示
f[i][j]：从起点到达坐标点(i, j)的方案数。 -
状态转移：
f[i][j] = f[i-1][j] + f[i][j-1]。另外第一行和第一列上的坐标都只有一种到达的方案，因此第一行、第一列直接被赋值为1。
代码
- C++
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> f(m, vector<int>(n));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (!i || !j) f[i][j] = 1; // 第一行、第一列直接被赋值为1
else f[i][j] = f[i - 1][j] + f[i][j - 1];
return f[m - 1][n - 1];
}
};
- Java
class Solution {
public int uniquePaths(int m, int n) {
int[][] f = new int[m][n];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (i == 0 || j == 0) f[i][j] = 1;
else f[i][j] = f[i - 1][j] + f[i][j - 1];
return f[m - 1][n - 1];
}
}
- Python
# 组合数
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
f = [[0 for _ in range(n)] for _ in range(m)]
for i in range(m):
for j in range(n):
if i == 0 or j == 0:
f[i][j] = 1
else:
f[i][j] = f[i - 1][j] + f[i][j - 1]
return f[m - 1][n - 1]
时空复杂度分析
-
时间复杂度： O ( n × m ) O(n \times m) O(n×m)，
m、n为行数、列数。 -
空间复杂度： O ( n × m ) O(n \times m) O(n×m)。
Leetcode 0063 不同路径II
题目描述：Leetcode 0063 不同路径II
分析
-
本题的考点：动态规划。
-
状态表示
f[i][j]：从起点到达坐标点(i, j)的方案数。 -
状态转移：
f[i][j] = f[i-1][j] + f[i][j-1]。另外第一行和第一列上的坐标不一定有达到的方案，因此第一行、第一列不能直接被赋值为1。 -
和Leetcode 0062 不同路径区别是存在障碍物，如果
(i, j)存在障碍物的话，则直接跳过即可。
代码
- C++
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obs) {
int m = obs.size(), n = obs[0].size();
vector<vector<int>> f(m, vector<int>(n));
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (!obs[i][j]) {
if (!i && !j) f[i][j] = 1;
else {
if (i) f[i][j] += f[i - 1][j];
if (j) f[i][j] += f[i][j - 1];
}
}
return f[m - 1][n - 1];
}
};
- Java
class Solution {
public int uniquePathsWithObstacles(int[][] obs) {
int m = obs.length, n = obs[0].length;
int[][] f = new int[m][n];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
if (obs[i][j] == 0) {
if (i == 0 && j == 0) f[i][j] = 1;
else {
if (i != 0) f[i][j] += f[i - 1][j];
if (j != 0) f[i][j] += f[i][j - 1];
}
}
return f[m - 1][n - 1];
}
}
- Python
class Solution:
def uniquePathsWithObstacles(self, obs: List[List[int]]) -> int:
m = len(obs); n = len(obs[0])
f = [[0 for _ in range(n)] for _ in range(m)]
for i in range(m):
for j in range(n):
if obs[i][j] == 0:
if i == 0 and j == 0:
f[i][j] = 1
else:
if i > 0:
f[i][j] += f[i - 1][j]
if j > 0:
f[i][j] += f[i][j - 1]
return f[m - 1][n - 1]
时空复杂度分析
-
时间复杂度： O ( n × m ) O(n \times m) O(n×m)，
m、n为行数、列数。 -
空间复杂度： O ( n × m ) O(n \times m) O(n×m)。
Leetcode 0980 不同路径 III
分析
-
本题的考点：递归回溯。
-
遍历数组找到起点和终点，然后从起点开始遍历，如果遍历到了终点，判断所有可以通过的点是否遍历完毕，如果是的话，答案加一。
-
如何判断可以经过的点是否遍历完毕？可以使用一个变量
cnt记录当前还剩余多少个点需要遍历，当cnt==0时说明遍历完毕。
代码
- C++
class Solution {
public:
int n, m;
vector<vector<bool>> st;
pair<int, int> S, T; // 起点，终点
int ans;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int uniquePathsIII(vector<vector<int>>& grid) {
n = grid.size();
m = grid[0].size();
st = vector<vector<bool>>(n, vector<bool>(m, false));
ans = 0;
int cnt = n * m; // 初始表示多少个可以走的格子数目
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == 1) S = make_pair(i, j);
else if (grid[i][j] == 2) T = make_pair(i, j);
else if (grid[i][j] == -1) cnt--;
dfs(grid, S.first, S.second, cnt - 1);
return ans;
}
void dfs(vector<vector<int>> &grid, int x, int y, int cnt) {
if (!cnt && x == T.first && y == T.second) {
ans++;
return;
}
st[x][y] = true;
for (int i = 0; i < 4; i++) {
int a = x + dx[i], b = y + dy[i];
if (a >= 0 && a < n && b >= 0 && b < m && !st[a][b] && grid[a][b] != -1)
dfs(grid, a, b, cnt - 1);
}
st[x][y] = false;
}
};
- Java
class Solution {
private int[][] grid;
private int n, m;
private boolean[][] st;
private int start, end;
private final static int[][] dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 上右下左
public int uniquePathsIII(int[][] grid) {
this.grid = grid;
n = grid.length;
m = grid[0].length;
st = new boolean[n][m];
int cnt = n * m; // 初始表示多少个可以走的格子数目
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == 1) start = i * m + j;
else if (grid[i][j] == 2) end = i * m + j;
else if (grid[i][j] == -1) cnt--;
return dfs(start, cnt);
}
private int dfs(int u, int cnt) {
int x = u / m, y = u % m;
if (--cnt == 0 && u == end) {
st[x][y] = false;
return 1;
}
int res = 0;
st[x][y] = true;
for (int d = 0; d < 4; d++) {
int a = x + dirs[d][0], b = y + dirs[d][1];
if (a >= 0 && a < n && b >= 0 && b < m && grid[a][b] != -1 && !st[a][b])
res += dfs(a * m + b, cnt);
}
st[x][y] = false;
return res;
}
}
- Python
class Solution:
def __init__(self):
self.n, self.m = 0, 0
self.st = []
self.S, self.T = [0, 0], [0, 0]
self.ans = 0
self.dx, self.dy = [-1, 0, 1, 0], [0, 1, 0, -1]
def uniquePathsIII(self, grid: List[List[int]]) -> int:
self.n, self.m = len(grid), len(grid[0])
self.st = [[False for _ in range(self.m)] for _ in range(self.n)]
self.ans = 0
cnt = self.n * self.m
for i in range(self.n):
for j in range(self.m):
if grid[i][j] == 1:
self.S = [i, j]
elif grid[i][j] == 2:
self.T = [i, j]
elif grid[i][j] == -1:
cnt -= 1
self.dfs(grid, self.S[0], self.S[1], cnt - 1)
return self.ans
def dfs(self, grid, x, y, cnt):
if cnt == 0 and x == self.T[0] and y == self.T[1]:
self.ans += 1
return
self.st[x][y] = True
for i in range(4):
a, b = x + self.dx[i], y + self.dy[i]
if 0 <= a < self.n and 0 <= b < self.m and not self.st[a][b] and grid[a][b] != -1:
self.dfs(grid, a, b, cnt - 1)
self.st[x][y] = False
时空复杂度分析
-
时间复杂度： O ( 4 n × m ) O(4 ^ {n \times m}) O(4n×m)，
n、m为数组长、宽。 -
空间复杂度： O ( n × m ) O(n \times m) O(n×m)。
扫一扫
248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
