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 .
Input
: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
Output
: 2
Explanation
: There is one obstacle in the middle of the 3x3 grid above.
There are two ways to reach the bottom-right corner:
1. Right -> Right -> Down -> Down
2. Down -> Down -> Right -> Right
Input
: obstacleGrid = [[0,1],[0,0]]
Output
: 1
m == obstacleGrid.length
n == obstacleGrid[i].length
1 <= m, n <= 100
obstacleGrid[i][j] is 0 or 1.
์ด ๋ฌธ์ ๋ ์ด์ ํ์๋ Unique Paths ๋ฌธ์ ์ ํฌ๊ฒ ๋ค๋ฅด์ง ์๋ค.
๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ์ฅ์ ๋ฌผ์ด ์ถ๊ฐ๋์๋ค๋ ๊ฒ์ด๋ค.
์ฅ์ ๋ฌผ์ ํผํด๊ฐ๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ค.
๊ฒฝ๋ก์ ์๋ฅผ ํ์ํด๋๊ฐ๋ ๊ณผ์ ์ ๊ธฐ์กด์ ์ ํ์๊ณผ ๋์ผํ๋ฐ,
grid[m][n] = grid[m-1][n] + grid[m][n-1]
์ฅ์ ๋ฌผ์ 0์ผ๋ก ํ์๋ง ํด์ฃผ๋ฉด ๋๋ค.
์ฌ๊ธฐ์ ์ฃผ์ํด์ผ ํ ์ ์, ์ฅ์ ๋ฌผ์ ์์น์ด๋ค.
์ฅ์ ๋ฌผ์ด ์ถ๋ฐ์ง [0, 0]์ ์๋ ๊ฒฝ์ฐ์ 0๋ฒ์งธ ํ ๋๋ 0๋ฒ์งธ ์ด์ ์๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค.
// ์ถ๋ฐ์ง ์์น์ ์ฅ์ ๋ฌผ์ด ์๋ ๊ฒฝ์ฐ
if (obstacleGrid[0][0] == 1) {
return 0;
}
obstacleGrid[0][0] = 1;
// 0์ด ์ด๊ธฐํ
for (int i = 1; i < m; i++) {
// ์ฅ์ ๋ฌผ์ 0์ผ๋ก ์ ์ฅ
if (obstacleGrid[i][0] == 1) {
obstacleGrid[i][0] = 0;
}
else {
obstacleGrid[i][0] = obstacleGrid[i-1][0];
}
}
// 0ํ ์ด๊ธฐํ
for (int i = 1; i < n; i++) {
if (obstacleGrid[0][i] == 1) {
obstacleGrid[0][i] = 0;
}
else {
obstacleGrid[0][i] = obstacleGrid[0][i-1];
}
}
๊ทธ๋ฆฌ๋ ์ด๊ธฐํ๋ 0ํ๊ณผ 0์ด์ ๋ชจ๋ 1์ ์ ์ฅํ๋ ๊ฒ์ธ๋ฐ,
์ถ๋ฐ์ง์ ์ฅ์ ๋ฌผ์ด ์์นํด ์๋ ๊ฒฝ์ฐ๋ ๋ฌด์กฐ๊ฑด ์ต์ข
๋ฐํ ๊ฐ์ด 0์ด๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ฒ๋ฆฌํด ์ค๋ค.
๊ทธ๋ฆฌ๊ณ , 0์ด๊ณผ 0ํ์ ์ด๊ธฐํํ ๋ ์ฅ์ ๋ฌผ์ 0์ผ๋ก ์ ์ฅํด์ฃผ๊ณ , ์ฅ์ ๋ฌผ์ด ์๋๋ผ๋ฉด, ์ด์ ๊ฐ์ ๊ทธ๋๋ก ์ ์ฅํจ์ผ๋ก์จ, ์ฅ์ ๋ฌผ์ ์์น๋ฅผ ๊ณ ๋ คํด ์ด๊ธฐํ๋ฅผ ํด ์ฃผ์ด์ผ ํ๋ค.
// ๊ฒฝ๋ก ์ ํ์
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) {
obstacleGrid[i][j] = 0; // ์ฅ์ ๋ฌผ ํ์
}
else {
// ๊ฒฝ๋ก ์ ์
๋ฐ์ดํธ
obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1];
}
}
}
์ด์ ๊ฒฝ๋ก์ ์๋ฅผ [1,1]์ขํ๋ถํฐ ๊ธฐ์กด์ ์ ํ์์ ์ด์ฉํด ๊ตฌํด๋๊ฐ๋ฉด ๋๋ค.
๋จ, ์ฅ์ ๋ฌผ์ ๋ฐ๊ฒฌ ์ ํด๋น ์์ ๊ฐ์ 0์ ์ ์ฅํ๋ค.
public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
int m = obstacleGrid.length; // ์ธ๋ก ๊ธธ์ด
int n = obstacleGrid[0].length; // ๊ฐ๋ก ๊ธธ์ด
// ์ถ๋ฐ์ง ์์น์ ์ฅ์ ๋ฌผ์ด ์๋ ๊ฒฝ์ฐ
if (obstacleGrid[0][0] == 1) {
return 0;
}
obstacleGrid[0][0] = 1;
// 0์ด ์ด๊ธฐํ
for (int i = 1; i < m; i++) {
// ์ฅ์ ๋ฌผ์ 0์ผ๋ก ์ ์ฅ
if (obstacleGrid[i][0] == 1) {
obstacleGrid[i][0] = 0;
}
else {
obstacleGrid[i][0] = obstacleGrid[i-1][0];
}
}
// 0ํ ์ด๊ธฐํ
for (int i = 1; i < n; i++) {
if (obstacleGrid[0][i] == 1) {
obstacleGrid[0][i] = 0;
}
else {
obstacleGrid[0][i] = obstacleGrid[0][i-1];
}
}
// ๊ฒฝ๋ก ์ ํ์
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) {
obstacleGrid[i][j] = 0; // ์ฅ์ ๋ฌผ ํ์
}
else {
// ๊ฒฝ๋ก ์ ์
๋ฐ์ดํธ
obstacleGrid[i][j] = obstacleGrid[i-1][j] + obstacleGrid[i][j-1];
}
}
}
return obstacleGrid[m-1][n-1];
}
ํญํด 99 ์ข ๋ฃ..! ๊ณ ์ํ์ด์์ค๐๐