๋ฑ๊ตฃ๊ธธ
๋ฌธ์
๋ฌธ์ ์ค๋ช
๊ณ์๋๋ ํญ์ฐ๋ก ์ผ๋ถ ์ง์ญ์ด ๋ฌผ์ ์ ๊ฒผ์ต๋๋ค. ๋ฌผ์ ์ ๊ธฐ์ง ์์ ์ง์ญ์ ํตํด ํ๊ต๋ฅผ ๊ฐ๋ ค๊ณ ํฉ๋๋ค. ์ง์์ ํ๊ต๊น์ง ๊ฐ๋ ๊ธธ์ 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๊ฐ ์ดํ์ ๋๋ค.
- ์ง๊ณผ ํ๊ต๊ฐ ๋ฌผ์ ์ ๊ธด ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
์ฝ๋
#include <string>
#include <vector>
using namespace std;
bool isPuddles(int y, int x, vector<vector<int>> & pud){
for(int i=0; i<pud.size(); i++){ // 10
if(pud[i][0]==x+1 && pud[i][1]==y+1)
return true;
}
return false;
}
int solution(int m, int n, vector<vector<int>> puddles) {
long long answer = 0;
vector<vector<long long>> map(n, vector<long long>(m));
for(int i=0; i<n; i++){ // 10^4
for(int j=0; j<m; j++){
if(i==0 && j==0){
map[i][j] = 1;
continue;
}
if(isPuddles(i, j, puddles)) { // ์
๋ฉ์ด๊ฐ ์์ผ๋ฉด 0
map[i][j] = 0;
continue;
}
if(i>=1){ // ์ ํ๋ ์์ชฝ ๊ตฌ๊ฐ์ด ์์ผ๋ฉด
map[i][j]+=map[i-1][j]; // ์์์ ์จ ์ ๋ํ๊ธฐ
map[i][j]%=1000000007;
}
if(j>=1){ // ์ ํ๋ ์ผ์ชฝ ๊ตฌ๊ฐ์ด ์์ผ๋ฉด
map[i][j]+=map[i][j-1]; // ์ผ์ชฝ์์ ์จ ์ ๋ํ๊ธฐ
map[i][j]%=1000000007;
}
}
}
answer = map[n-1][m-1];
if(answer>=1000000007)
answer %= 1000000007;
return answer;
}
ํ์ด
DP๋ผ๊ธฐ์๋ ๋๋ฌด ๋จ์ํ, ๊ทธ๋ฅ ๋ฐฐ์ด์ ์ด์ฉํ ๋ง์ ๋ฌธ์ ์๋ค. ์ด๋ฆด ๋๋ถํฐ ํด์ค๋ ์ต๋จ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฒ์ ์ด์ฉํ๋ฉด ์ฝ๊ฒ ํ ์ ์๋ค.
์ต๋จ๊ฒฝ๋ก๋ผ๋ ์ฌ์ค์ ์ค๋๊ณ ๋, ์ค๋ฅธ์ชฝ๊ณผ ์๋๋ก ์ ํ์ ๊ฑธ์ด๋ฌ์ ํ ๊ฐ์ง ๋ฐฉ์์ผ๋ก๋ง ํ ์ ์๊ฒ ํด์ฃผ์๋ค.
๋ฐฉ์์ (1,1)์์ 1์ ์ ์ฅํ๋ฉด์ ์์ํ ๋ค, ์ ๋ฉ์ด์๋ 0์ ์ ๋ฉ์ด๊ฐ ์๋ ๊ณณ์๋ ํด๋น ์ขํ์ ์ผ์ชฝ๊ณผ ์์ชฝ์ ์๋ฅผ ๋ํด์ ๊ธฐ์ฌํด์ฃผ๋ ๊ฒ์ด๋ค.
๊ทธ๋ฆผ์ฒ๋ผ ์์น ๋ ๊ณณ์ ์ซ์๋ ์ผ์ชฝ๊ณผ ์์ ๊ธฐ์ฌ๋ ์๋ฅผ ๋ํด์ค ์์ด๋ค.
์ ๋ฉ์ด๋ฅผ 0์ผ๋ก ์ฒ๋ฆฌํ์ผ๋ฏ๋ก ์ ๋ฉ์ด๋ฅผ ํตํด์ ๊ฐ๋ ๊ฒฝ๋ก๋ ์ธ์ด์ง์ง ์๋๋ค.
์ฑ์ ๊ฒฐ๊ณผ
n์ด 10^4์ธ๋ฐ, O(n)์ผ๋ก ํ์ด์ ์๊ฐ์ ์ ๊ฒ ๋์๋ค.
์ฃผ์์ฌํญ
์ฝ๋ ์ค๊ฐ์ ๋ค์๊ณผ ๊ฐ์ ์์ด ์๋๋ฐ,
map[i][j]%=1000000007;
์๊ฐ ๋๋ฌด ์ปค์ ธ์ long long ํ์ผ๋ก ๋ด๊ธด ํ๋ ๋ชจ์์ธ์ง, answer์์ ๋๋จธ์ง๋ฅผ ๊ตฌํด์ฃผ๋ ๊ฒ๋ง์ผ๋ก๋ ํจ์จ์ฑ ํ ์คํธ์์ ๊ณ์ ์คํจ๊ฐ ๋์๋ค.
๊ทธ๋์ ์ฝ๋ ์ค๊ฐ์ ์์ ๋๋จธ์ง ์ฐ์ฐ์ ๋ฃ์ด๋ฒ๋ฆฌ๋๊น ๊ทธ์ ์์ผ ํ๋ ธ๋ค... ใ ใท
ํจ์จ์ฑ์์๋ง ์ค๋ฅ๋ ๋๋ ์๋ฃํ์ ํฌ๊ธฐ๋ฅผ ๊ณ ๋ คํ์.
Comment