- DFS
- ๋ฐฑ์๋ ํ๋ฆฌ์จ๋ณด๋ฉ
- nestjs
- ๋ค์ต์คํธ๋ผ
- ๋นํธ๋ง์คํน
- Python
- ์ฌ๊ท
- C++
- ์๊ณ ๋ฆฌ์ฆ
- ๋์ ํ๋ก๊ทธ๋๋ฐ
- ์นด์นด์ค2021
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- BFS
- ์ด๋ถํ์
- ์น๋ฆฐ์ด
- ์ํฐ๋
- ๊ฐ์ฅ๊ฐ๊น์ด๊ณตํต์กฐ์
- ํธ๋ฆฌ
- ํ๋ก๊ทธ๋๋จธ์ค
- ํ๋ฆฌ์จ๋ณด๋ฉ
- ๋นํธ๋งต
- golang
- LCs
- js
- ์นด์นด์ค ์ฝํ
- ์์ฝ๋
- go
- ๋ฐฑ์ค
- DP
- Union-Find
- Today
- Total
Hello Ocean! ๐ผ
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ฑ๊ตฃ๊ธธ ๋ณธ๋ฌธ
๋ฌธ์ ์ค๋ช
๊ณ์๋๋ ํญ์ฐ๋ก ์ผ๋ถ ์ง์ญ์ด ๋ฌผ์ ์ ๊ฒผ์ต๋๋ค. ๋ฌผ์ ์ ๊ธฐ์ง ์์ ์ง์ญ์ ํตํด ํ๊ต๋ฅผ ๊ฐ๋ ค๊ณ ํฉ๋๋ค. ์ง์์ ํ๊ต๊น์ง ๊ฐ๋ ๊ธธ์ m x n ํฌ๊ธฐ์ ๊ฒฉ์๋ชจ์์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค.
์๋ ๊ทธ๋ฆผ์ m = 4, n = 3 ์ธ ๊ฒฝ์ฐ์ ๋๋ค.

๊ฐ์ฅ ์ผ์ชฝ ์, ์ฆ ์ง์ด ์๋ ๊ณณ์ ์ขํ๋ (1, 1)๋ก ๋ํ๋ด๊ณ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋, ์ฆ ํ๊ต๊ฐ ์๋ ๊ณณ์ ์ขํ๋ (m, n)์ผ๋ก ๋ํ๋ ๋๋ค.
๊ฒฉ์์ ํฌ๊ธฐ m, n๊ณผ ๋ฌผ์ด ์ ๊ธด ์ง์ญ์ ์ขํ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด puddles์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค๋ฅธ์ชฝ๊ณผ ์๋์ชฝ์ผ๋ก๋ง ์์ง์ฌ ์ง์์ ํ๊ต๊น์ง ๊ฐ ์ ์๋ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ๊ฒฉ์์ ํฌ๊ธฐ m, n์ 1 ์ด์ 100 ์ดํ์ธ ์์ฐ์์
๋๋ค.
- m๊ณผ n์ด ๋ชจ๋ 1์ธ ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๋ฌผ์ ์ ๊ธด ์ง์ญ์ 0๊ฐ ์ด์ 10๊ฐ ์ดํ์ ๋๋ค.
- ์ง๊ณผ ํ๊ต๊ฐ ๋ฌผ์ ์ ๊ธด ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
m | n | puddles | return |
4 | 3 | [[2, 2]] | 4 |

์ฝ๋
1. ์์์ ์์๋ถํฐ ํด๋น ์ขํ๊น์ง ๋๋ฌํ ์ ์๋ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ cache ๋ฐฐ์ด์ ์ ์ฅํ์ฌ ์ด์ฉ (DP)
2. ์ขํ๊ฐ 0์ด ์๋๋ผ 1๋ถํฐ ์์ํจ
- puddles์ ์ขํ๋ฅผ ์ด์ฉํ ๋ -1ํด์ผํจ.
3. cache์ ์ฑ์ธ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ก ์ค์ ํด์ผํจ
- ์ด ๋ถ๋ถ์ ๋นผ๊ณ ์ ๋ต์ ์ ์ถํ์ ๋, ์ ํ์ฑ ํ ์คํธ๋ ๋ชจ๋ ํต๊ณผํ์ง๋ง, ํจ์จ์ฑ ํ ์คํธ๋ฅผ ๋ชจ๋ ์คํจํ๋ค.
- %1000000007์ ์ถ๊ฐํ์ ํจ์จ์ฑ ํ ์คํธ๋ ๋ชจ๋ ํต๊ณผํ ์ ์์๋ค.
4. cache ๋ฐฐ์ด์์, ๊ฐ์ฅ์๋ฆฌ(์ผ์ชฝ, ์์ชฝ)๋ ๋ฌด์กฐ๊ฑด 1์ด ์๋๋ค.
- ์ฒ์์ ๊ฐ์ฅ์๋ฆฌ์ ๋ฌด์กฐ๊ฑด 1์ ๋ฃ์ด๋๊ณ ์์ํ๋๋ฐ, ์๋ ์ฌ์ง์ฒ๋ผ ์ค๊ฐ์ ์ ๋ฉ์ด๊ฐ ์๋ ๊ฒฝ์ฐ, ๊ทธ ๋ค์ ์นธ๋ค์ ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์ 0์ผ๋ก ์ค์ ํด์ฃผ์ด์ผ ํ๋ค.

#include <string>
#include <vector>
using namespace std;
int cache[101][101];
int solution(int M, int N, vector<vector<int>> puddles) {
int answer = 0;
int m, n;
fill(cache[0], cache[0] + 10201, 1);
for (int i = 0;i < puddles.size();i++) {
m = puddles[i][0];
n = puddles[i][1];
cache[m - 1][n - 1] = 0; // ์ขํ๊ฐ 1, 1๋ถํฐ ์์ํจ
}
for (int i = 0;i < M;i++) {
for (int j = 0;j < N;j++) {
if (cache[i][j] == 0 || i == 0 && j == 0)
continue;
if (i == 0) {
cache[i][j] = cache[i][j - 1];
continue;
}
if (j == 0) {
cache[i][j] = cache[i - 1][j];
continue;
}
cache[i][j] = (cache[i - 1][j] + cache[i][j - 1]) % 1000000007; // ๋ฌธ์ ์ ์กฐ๊ฑด
}
}
answer = cache[M - 1][N - 1];
return answer;
}
๋๋์
- ๋ฌธ์ ๋ฅผ ๊ผผ๊ผผํ ์ ์ฝ์
- ๋ฐฐ์ด ๊ฐ ์ฑ์ฐ๋ fill() ๋ฑ์ ํจ์ ์ฌ์ฉ๋ฒ ์ ๋ฆฌํ๊ธฐ
- vector ๋ด์ ์์์ ์ ๊ทผํ ๋ iter์ ์ฐ๋ ๋ฐฉ๋ฒ, ์ฅ์ ์ฐพ์๋ณด๊ธฐ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ํ๋ณดํค (0) | 2021.01.03 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค/C++] ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์ (0) | 2020.12.29 |
[ํ๋ก๊ทธ๋๋จธ์ค/์นด์นด์ค ์ฝํ ] ์คํ์ฑํ ๋ฐฉ (0) | 2020.11.22 |
[ํ๋ก๊ทธ๋๋จธ์ค] 2020 ์นด์นด์ค/๊ดํธ ๋ณํ (0) | 2020.10.12 |
[ํ๋ก๊ทธ๋๋จธ์ค] ๋ฌธ์์ด ์์ถ (0) | 2020.10.05 |