[23.02.27] Daily Coding 25 - tiling

- tiling
์ธ๋ก ๊ธธ์ด 2, ๊ฐ๋ก ๊ธธ์ด n์ธ 2 x n ๋ณด๋๊ฐ ์์ต๋๋ค. 2 x 1 ํฌ๊ธฐ์ ํ์ผ์ ๊ฐ์ง๊ณ ์ด ๋ณด๋๋ฅผ ์ฑ์ฐ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ฆฌํดํด์ผ ํฉ๋๋ค.
์ด๋ฐ ๊ฒฝ์ฐ์ ์ ๋ฌธ์ ๋ ์ผ๋จ ์์ ์๋ฅผ ์์ ๊ณ์ฐํด์ ๊ท์น์ ์ฐพ์๊ฐ๋ ๊ฒ์ด ๋น ๋ฅด๋ค.



๋ชจ์๋๊ณ ๋ณด๋ ๊ท์น์ฑ์ด ๋ณด์ธ๋ค
n=1 -> 1
n=2 -> 2
n=3 -> 3
n=4 -> 5
n=5 -> 8
...



์ธ๋ก์ ๊ธธ์ด๋ ๊ณ ์ ๋ ์ฑ๋ก ๊ฐ๋ก์ ๊ธธ์ด๋ง ๋์ด๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์,
์ชผ๊ฐ์ด์ ์๊ฐํ๋ฉด ํธ๋ฆฌํ๋ค.
๊ฒฐ๊ตญ ํ ์นธ์ ์ฐจ์งํ๋ 2x1์ ์ ์ธํ ๋๋จธ์ง ๋ชจ์์ด ๋ฐ๋ก ์ (n-1)๊ณผ ๊ฐ๊ณ , ๋ ์นธ์ ์ฐจ์งํ๋ ์ต์ 2x2๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ชจ์์ด (n-2)์ ๊ฐ๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์ฆ ํผ๋ณด๋์น์ ์์ ์ ์ฌํ ์์ด์ด ๋๋ ๊ฒ.
๋จ์ํ ์ฌ๊ท๋ก ๋ํ๋ด์ด ๋ณด๋ฉด
let tiling = function (n) {
if (n <= 2) return n;
return tiling(n - 2) + tiling(n - 1);
};
์ด๋ ๊ฒ ๋๋, ์ด๋ฌ๋ฉด ์ ๋ฒ ํผ๋ณด๋์น์์ ๋ฐฐ์ด ๊ฒ์ฒ๋ผ ๋ชจ๋ ํ์ผ์ ๋ค ์ํํ๊ธฐ ๋๋ฌธ์ ์๊ฐ ์ด๊ณผ๊ฐ ๋์จ๋ค.(ํผ๋ณด๋์น,์๊ฐ๋ณต์ก๋ ์ค์ด๊ธฐ ์ฐธ๊ณ )
๋ด๊ฐ ์ด ๋ต
let tiling = function (n) {
let arr = [0,1,2];
const boxTiling = (n) => {
if(arr[n]) return arr[n];
return arr[n] = boxTiling(n-1) + boxTiling(n-2);
}
return boxTiling(n);
};
๋ ํผ๋ฐ์ค์๋ ์กฐ๊ธ ์ฐจ์ด๊ฐ ์์๋ค.
๋๋ ์ด๋ฏธ ํด๊ฒฐํ ๋ฌธ์ ๋ฅผ ํธ๋ ์์ด์๋ ๊ฑธ๊น..
๋ ํผ๋ฐ์ค 1 (memoization)
let tiling = function (n) {
// ์ธ๋ฑ์ค๋ฅผ ์ง๊ด์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ์ํด
// ์ ๋ถ๋ถ์ ์๋ฏธ์๋ ๋ฐ์ดํฐ(dummy)๋ก ์ฑ์ด๋ค.
const memo = [0, 1, 2];
// ์ฌ๊ท๋ฅผ ์ํ ๋ณด์กฐ ํจ์(auxiliary function)์ ์ ์ธ)
const aux = (size) => {
// ์ด๋ฏธ ํด๊ฒฐํ ๋ฌธ์ ๋ ํ์ง ์๋๋ค.
if (memo[size] !== undefined) return memo[size];
if (size <= 2) return memo[n];
memo[size] = aux(size - 1) + aux(size - 2);
return memo[size];
};
return aux(n);
};
๋ ํผ๋ฐ์ค 2 (tabulation)
let tiling = function (n) {
const memo = [0, 1, 2];
if (n <= 2) return memo[n];
for (let size = 3; size <= n; size++) {
memo[size] = memo[size - 1] + memo[size - 2];
}
return memo[n];
};
๋ ํผ๋ฐ์ค 3 (slicing window)
let tiling = function (n) {
let fst = 1,
snd = 2;
if (n <= 2) return n;
for (let size = 3; size <= n; size++) {
// ์์ ๋ ์๋ฅผ ๋ํด ๋ค์ ์๋ฅผ ๊ตฌํ ์ ์๋ค.
const next = fst + snd;
// ๋ค์ ๋ฌธ์ ๋ก ๋์ด๊ฐ๊ธฐ ์ํด ํ์ํ 2๊ฐ์ ๋ฐ์ดํฐ์ ์์๋ฅผ ์ ๋ฆฌํ๋ค.
fst = snd;
snd = next;
}
return snd;
};
https://school.programmers.co.kr/learn/courses/30/lessons/12900
ํ์ง๋ง!
์ด ์ธ ๊ฐ์ง ๋ชจ๋ ์๊ฐ ๋ณต์ก๋๋ O(N) ์ธ๋ฐ...
๊ฐ์ ๋ฌธ์ ๋ฅผ ํ๋ก๊ทธ๋๋จธ์ค์ ์ด ๋ ํผ๋ฐ์ค๋ก ์
๋ ฅํ์ ๋
๊ทธ๋ฅ ์ ๋ถ ์คํจ๊ฐ ๋ฌ๋ค ^^7 ๋ต์ด๋ผ๋ ๋ง๊ฒ ํด์ค๋ผ

๊ฒฝ์ฐ์ ์๊ฐ ๋ง์ ์ง ์ ์์ผ๋ฏ๋ก, ๊ฒฝ์ฐ์ ์๋ฅผ 1,000,000,007์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ returnํด๋ฌ๋ผ๊ณ ํ์ฌ ๊ทธ๋ ๊ฒ ํด๋...
memo์ ํจ์๊ฐ์ ์ ์ฅํ ๋ ๋๋จธ์ง ์ฐ์ฐ(%1000000007)์ ์ํํด์ฃผ์ด๋.. ๋ช ๊ฐ์ง ๋ถ๋ถ์์ ํ๋ฝํ๋ค. ใ ใ

ํจ์จ์ฑ์ด 30์ ์ค 5์ ์.. ใ
programmers ํ์ด
function solution(n) {
const memo = [0, 1, 2];
for (let size = 3; size <= n; size++) {
memo[size] = (memo[size - 1] + memo[size - 2]) % 1000000007;
}
return memo[n];
}
์ฐ์ฌ๊ณก์ ๋์ ์์ฑํ ํ์ด...