ํฉ๊ฒฉ์ ๋ฐ๋ผ๊ณ ์์ํ๋ค๊ธฐ ๋ณด๋ค๋ ๋๊ธฐ์
์ ์ฝ๋ฉ ํ
์คํธ๋ฅผ ๊ฒฝํํด๋ณด๊ณ ์ถ์ด์ ์์ํ๋ค. ํฐ ์๋ฏธ๋ ์๊ณ ํ๋ฉด์ ๊ทธ๋ฆฌ๊ณ ํ๊ณ ๋์ ์๊ฐํ ๋ถ๋ถ์ ๊ฐ๋จํ๊ฒ ๊ธ๋ก ์ฎ๊ฒจ ์ ๊ณ ์ ํ๋ค. ๐ ์ํ ํ๊ฒฝ โก๏ธ ํ๋ก๊ทธ๋๋จธ์ค๋ฅผ ํตํด ์ํ์ ์์ํ๋ค. 10์ ์ํ์ด์๋๋ฐ 9์์ ์
์ฅํด์ ํ
์คํธ๋ฅผ ๊ถ์ฅํ๊ธธ๋ 9์ 10๋ถ์ฏค๋ถํฐ ๋ค์ด์์ ์ํ ์ฃผ์์ฌํญ์ ๋ค์ ํ ๋ฒ ์ฝ์ด๋ณด๊ณ , ์นด๋ฉ๋ผ ์ค์ ์ ํ๋ค. 10๋ถ ์ ๋ถํฐ ๊ณต์ง์ฌํญ์ ํตํด ์ฃผ๋ณ ํ๊ฒฝ๊ณผ ๋น ์ข
์ด๋ฅผ ํ์ธํ๋ ๊ณผ์ ์ ๊ฑฐ์ณค๋ค. โก๏ธ ํ๋ก๊ทธ๋๋จธ์ค ์์์ ์ฐ๊ฒฐ๋๋ ์๋ฐ ๊ณต์ ๋ ํผ๋ฐ์ค์ A4 ์ฉ์ง ํ์ฅ, ๋ณผํ์ ๊ฐ์ง๊ณ ์ฐธ๊ฐํ ์ ์์๋ค. โ๏ธ ํ์ด ์์ โก๏ธ ์ผ๋จ ๋ฌธ์ 1๋ฒ๋ถํฐ 4๋ฒ๊น์ง๋ฅผ ์ญ ์ฝ์ด๋ณด๋ฉด์ ๋จธ๋ฆฟ์์ ํ์ด๊ฐ ์ด๋์ ๋ ๊ทธ๋ ค์ง๋ ๋ฌธ์ ๋ถํฐ ํ์ด๋๊ฐ๊ธฐ ์์ํ๋ค. ํ์ดํ ์์๋ 3๋ฒ ->..
Coding Test ๐

๐ ํ๋ก๊ทธ๋๋จธ์ค / Graph / Level 3 / ์์ ๐ ๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ๐ซ ์ ํ ์ฌํญ ์ ์์ ์๋ 1๋ช
์ด์ 100๋ช
์ดํ์
๋๋ค. ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ 1๊ฐ ์ด์ 4,500๊ฐ ์ดํ์
๋๋ค. results ๋ฐฐ์ด ๊ฐ ํ [A, B]๋ A ์ ์๊ฐ B ์ ์๋ฅผ ์ด๊ฒผ๋ค๋ ์๋ฏธ์
๋๋ค. ๋ชจ๋ ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ์๋ ๋ชจ์์ด ์์ต๋๋ค. ๐ ์
์ถ๋ ฅ ์ n results return 5 [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]] 2 ๐ค ํ์ด ๋ฐฉ๋ฒ 1๏ธโฃ ๋ด ์๊ฐ ์ ๋ฆฌ โก๏ธ ์๋ 2๊ฐ์ง ๋ฐฉ๋ฒ์ ์๊ฐํด๋ณด์์ง๋ง ์ฝ๋๋ก ์ฎ๊ธฐ๊ฑฐ๋ ๋
ผ..

๐ ํ๋ก๊ทธ๋๋จธ์ค / Graph / Level 2 / ๊ฐ์ฅ ๋จผ ๋
ธ๋ ๐ ๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ๐ซ ์ ํ ์ฌํญ ๋
ธ๋์ ๊ฐ์ n์ 2 ์ด์ 20,000 ์ดํ์
๋๋ค. ๊ฐ์ ์ ์๋ฐฉํฅ์ด๋ฉฐ ์ด 1๊ฐ ์ด์ 50,000๊ฐ ์ดํ์ ๊ฐ์ ์ด ์์ต๋๋ค. vertex ๋ฐฐ์ด ๊ฐ ํ [a, b]๋ a๋ฒ ๋
ธ๋์ b๋ฒ ๋
ธ๋ ์ฌ์ด์ ๊ฐ์ ์ด ์๋ค๋ ์๋ฏธ์
๋๋ค. ๐ ์
์ถ๋ ฅ ์ n vertex return 6 [[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]] 3 ๐ค ํ์ด ๋ฐฉ๋ฒ 1๏ธโฃ ๊ทธ๋ํ ๊ตฌํ โก๏ธ ๊ทธ๋ํ ๊ตฌํ ..

๐ ํ๋ก๊ทธ๋๋จธ์ค / ์ฐ์ต๋ฌธ์ / Level 2 / ์ซ์ ๋ณํํ๊ธฐ ๐ ๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ๐ซ ์ ํ ์ฌํญ 1 ≤ x ≤ y ≤ 1,000,000 1 ≤ n 0) { answer = Math.min(answer, depth); return; } answer = depth; return; } // ๋ถ๋ถ โข dfs (y, depth+1, 0); dfs (y, depth+1, 1); dfs (y, depth+1, 2); return; } ๋ถ๋ถ โ โก๏ธ %2 / %3 / -n ์ค ์ด๋ค ์ฐ์ฐ์ ํด์ผํ๋์ง ํ์ธํ๊ธฐ ์ํด switch ๋ฌธ์ ..

๐ ํ๋ก๊ทธ๋๋จธ์ค / ์ฐ์ต๋ฌธ์ / Level 2 / ๋กค์ผ์ดํฌ ์๋ฅด๊ธฐ ๐ ๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ๐ซ ์ ํ ์ฌํญ 1 ≤ topping์ ๊ธธ์ด ≤ 1,000,000 1 ≤ topping์ ์์ ≤ 10,000 ๐ ์
์ถ๋ ฅ ์ topping result [1, 2, 1, 3, 1, 4, 1, 2] 2 [1, 2, 3, 1, 4] 0 ๐ค ํ์ด ๋ฐฉ๋ฒ 1๏ธโฃ ๋ฐฐ์ด โ ๊ธฐ๋ณธ ์์ด๋์ด (1) ๋ฐฐ์ด ์์ฑ โก๏ธ ์ฃผ์ด์ง topping ๋ฐฐ์ด์ ์ข์์ ์ฐ๋ก ํ ๋ฒ & ์ฐ์์ ์ข๋ก ํ ๋ฒ ํ์ํ๋ฉฐ, ํ ํ์ ์ข
๋ฅ์ ๊ฐ์๋ฅผ ๊ธฐ๋กํ ๋ฐฐ์ด์ ๋ง๋ ๋ค. ex) ์
์ถ๋ ฅ..

๐ ํ๋ก๊ทธ๋๋จธ์ค / ์๊ฐ ์ฝ๋ ์ฑ๋ฆฐ์ง ์์ฆ 1 / Level 2 / ์ผ๊ฐ ๋ฌํฝ์ด ๐ ๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ๐ซ ์ ํ ์ฌํญ n์ 1 ์ด์ 1,000 ์ดํ์
๋๋ค. ๐ ์
์ถ๋ ฅ ์ n result 4 [1,2,9,3,10,8,4,5,6,7] 5 [1,2,12,3,13,11,4,14,15,10,5,6,7,8,9] 6 [1,2,15,3,16,14,4,17,21,13,5,18,19,20,12,6,7,8,9,10,11] ๐ค ํ์ด ๋ฐฉ๋ฒ 1๏ธโฃ ์ขํํ โก๏ธ ์ด ๋ฌธ์ ์์ ์ค์ํ ํฌ์ธํธ๋ ์๊ณ ๋ฐฉํฅ์ผ๋ก ๋๊ธฐ ๋๋ฌธ์ ๊ฐ ์ธต๋ง๋ค ์ฐจ๋ก๋๋ก ๊ฐ์ ์ ์ฅํ๊ธฐ..