SW์ค์ฌ๋ํ ์ฌ์ ๋จ์์ CodeTree์ ํจ๊ป ์ค์ํ ์ฝ๋ฉํ ์คํธ ๋๋น ์บ ํ์ ์ฐธ์ฌํ์ฌ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ์์ต๋๋ค.
ํ๋ก๊ทธ๋จ์ ์์์๊ฐ ๋ฟ๋ง ์๋๋ผ, ์ปดํจํฐ์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ ๋์ด ์์ผ๋ฏ๋ก ๊ณต๊ฐ๋ณต์ก๋๋ ์ค์ํฉ๋๋ค.
๊ณต๊ฐ๋ณต์ก๋๋ ์๊ฐ๋ณต์ก๋์ ๋์ผํ๊ฒ ์ ๊ทผ์ ํ๊ธฐ๋ฒ์ ์ฌ์ฉํฉ๋๋ค.
function example(n)
set arr = [n][n]
for i = 0 ... i < n
for j = 0 ... j < n
arr[i][j] = 1
๊ณต๊ฐ๋ณต์ก๋ = '์ด ์ฝ๋๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ผ๋ง๋ ์ฐจ์งํ๊ณ ์์๊น?'
์ ์ฝ๋์์ set arr = [n][n] ์ด์ธ์ ๋ค๋ฅธ ์ฝ๋๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์งํ๊ณ ์์ง ์๊ธฐ ๋๋ฌธ์,
๊ณต๊ฐ๋ณต์ก๋๋ ์ ๋๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ณต๊ฐ๋ณต์ก๋๋ ์ ํ์ํ ๊น์?
๋ฌธ์ ์์ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ด 80MB๋ผ๋ ์์ผ๋ก ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค.
๋ณดํต ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณ์ฐํ๋ ๊ฒฝ์ฐ์๋ C++์ ๊ธฐ์ค์ผ๋ก ์๊ฐํฉ๋๋ค.
(C++ ๊ธฐ์ค) int = 4 byte, char = 1 byte, double = 8 byte
๋ฐ๋ผ์, int๋ก 2์ฒ๋ง์ด ๋๋ต 80MB๋ผ๋ ๊ฒ์ ์ด์ฉํ์ฌ ๋ค์๊ณผ ๊ฐ์ด ์ฝ๊ฒ ๊ณ์ฐ์ด ๊ฐ๋ฅํฉ๋๋ค.
int a[2์ฒ๋ง] : 80MB
int a[2๋ฐฑ๋ง] : 80 / 10 = 8MB
char a[2์ฒ๋ง] : 80 / 4 = 20MB
double a[2์ฒ๋ง] : 80 * 2 = 160MB
๋ฐ๋ผ์ ์ฌ์ฉํ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ฐ๋ผ ๋๋ต ์ด๋ ์ ๋์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋์ง๋ฅผ ๊ณ์ฐํ ์ ์์ต๋๋ค.
๊ณต๊ฐ๋ณต์ก๋๋ฅผ ์ถ๋ก ํ ๋ ์ค์ํ ์ ์, ๊ฐ์ด ์์ฑ๋์๋ค๊ฐ ์์ด์ง ์ ์๋ค๋ ์ ์ ์์ต๋๋ค.
๋ง์ฝ์ ํจ์ ๋ด ์ ์ํ ๊ฐ์ด ํจ์๊ฐ ์ข ๋ฃ๋์ด ์ฌ๋ผ์ก๋ค๋ฉด
๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฐจ์ง ํ๊ณ ์๋ ๊ฐ๋ค์ด ๊ฐ์ฅ ๋ง์ ๋, ๊ทธ ์์ ์์์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๊ณ์ฐ์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
function solution(n)
set list = [n][n] // (1)
for i = 0 ... i < n
list[i][i] = n
for i = 0 ... i < n
set tmp = [n-1][n-1] // (2)
for j = 0 ... j < n-1
tmp[j][0] = list[0][j]
์ ์ฝ๋์์๋ ๋ฐฐ์ด ์ ์ธ์ ํ๋ ๋ ๋ถ๋ถ๋ง ๊ณต๊ฐ๋ณต์ก๋์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
(1)๊ณผ (2)์์ ์ ์ธ๋๋ ๋ฐฐ์ด์ด ๋์์ ์กด์ฌํ ๋, ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ฅ ๋ง์ด ์ฐจ์งํ๊ฒ ๋๋ฉฐ ๊ทธ ์ต๋๊ฐ์ด ์ด ์ฝ๋์ ๊ณต๊ฐ๋ณต์ก๋์ด๋ฏ๋ก,
(N^2) + (N^2) = 2(N^2) => O(N^2)
์๊ฐ๋ณต์ก๋์ ๋์ผํ๊ฒ ์์๊ฐ ๋ฐ ๋ฎ์ ์ฐจ์๋ค์ ๋ฌด์๋ฉ๋๋ค.
์ถ์ฒ ์ฝ๋ํธ๋ฆฌ
'๐ ์๊ณ ๋ฆฌ์ฆ > Code Tree' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ฝ๋ํธ๋ฆฌ] HashMap ์ฐ์ต๋ฌธ์ (0) | 2023.02.09 |
---|---|
[์ฝ๋ํธ๋ฆฌ] Hash Map (0) | 2023.02.07 |
[์ฝ๋ํธ๋ฆฌ] ๋ฐ๋ณต๋ฌธ์ ์๊ฐ๋ณต์ก๋(2) (0) | 2023.02.06 |
[์ฝ๋ํธ๋ฆฌ] ๋ฐ๋ณต๋ฌธ์ ์๊ฐ๋ณต์ก๋(1) (0) | 2023.02.06 |
[์ฝ๋ํธ๋ฆฌ] ์๊ฐ๋ณต์ก๋์ ์ ์ (0) | 2023.02.06 |