53 lines
2.1 KiB
C++
53 lines
2.1 KiB
C++
#include <vector>
|
|
#include <cstdio>
|
|
#include <algorithm>
|
|
|
|
/**
|
|
* 63. Unique Paths II
|
|
* You are given an m x n integer array grid. There is a robot initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m-1][n-1]). The robot can only move either down or right at any point in time.
|
|
* An obstacle and space are marked as 1 or 0 respectively in grid. A path that the robot takes cannot include any square that is an obstacle.
|
|
* Return the number of possible unique paths that the robot can take to reach the bottom-right corner.
|
|
* The testcases are generated so that the answer will be less than or equal to 2 * 109.
|
|
*/
|
|
|
|
class Solution {
|
|
public:
|
|
static int uniquePathsWithObstacles(const std::vector<std::vector<int>>& obstacleGrid) {
|
|
const int m = obstacleGrid.size(), n = obstacleGrid.front().size(), k = std::min(m, n);
|
|
auto* dp = new unsigned[n * m]{static_cast<unsigned int>(obstacleGrid[0][0] ^ 1)};
|
|
|
|
for (int i = 1; i < k; ++i) {
|
|
dp[i * n] = obstacleGrid[i][0] ? 0 : dp[(i - 1) * n]; // X axis
|
|
dp[i] = obstacleGrid[0][i] ? 0 : dp[i - 1]; // Y axis
|
|
for (int j = 1; j < i; ++j) {
|
|
dp[i * n + j] = obstacleGrid[i][j] ? 0 : (dp[i * n + j - 1] + dp[(i - 1) * n + j]);
|
|
dp[i + n * j] = obstacleGrid[j][i] ? 0 : (dp[i - 1 + n * j] + dp[i + n * (j - 1)]);
|
|
}
|
|
dp[i * n + i] = obstacleGrid[i][i] ? 0 : (dp[i - 1 + i * n] + dp[(i - 1) * n + i]);
|
|
}
|
|
|
|
if (m > n) {
|
|
for (int i = k; i < m; ++i) {
|
|
dp[i * n] = obstacleGrid[i][0] ? 0 : dp[(i - 1) * n]; // X axis
|
|
for (int j = 1; j < n; ++j)
|
|
dp[i * n + j] = obstacleGrid[i][j] ? 0 : (dp[i * n + j - 1] + dp[(i - 1) * n + j]);
|
|
}
|
|
} else if (n > m) {
|
|
for (int i = k; i < n; ++i) {
|
|
dp[i] = obstacleGrid[0][i] ? 0 : dp[i - 1]; // Y axis
|
|
for (int j = 1; j < m; ++j)
|
|
dp[i + n * j] = obstacleGrid[j][i] ? 0 : (dp[i - 1 + n * j] + dp[i + n * (j - 1)]);
|
|
}
|
|
}
|
|
|
|
auto ret = dp[m * n - 1];
|
|
delete[] dp;
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
std::printf("%d\n", Solution::uniquePathsWithObstacles({{0,1,0,0,0},{1,0,0,0,0},{0,0,0,0,0},{0,0,0,0,0}}));
|
|
return 0;
|
|
}
|