๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์ ํ์ด๋ฐฉ๋ฒ1. dp[][] ๋ฐฐ์ด ์ ์ธ 2. ์ฒซ ๋ฒ์งธ ์ค ๊ฐ ์ฑ์ฐ๊ธฐ (dp[0][0] = triangle[0][0])2. ์ผ์ชฝ ์ฒซ๋ฒ์งธ ์ด์ธ dp[i][0] ๊ฐ์ ์ด์ ์ค์ ์ฒซ ๋ฒ์งธ ๊ฐ๋ผ๋ฆฌ ๋ํด์ ์
๋ ฅํ๋ค. (dp[i][0] = dp[i-1][0] + triangle[i][0]) 3. ๊ทธ ์ธ์ ๊ฐ๋ค์ ์์ชฝ๊ณผ ์ผ์ชฝ์์ ์ค๋ ๊ฐ์ ๋น๊ตํ์ฌ ์ต๋๊ฐ์ ๋ํ๊ธฐ(dp[i][j] = Math.max(dp[i-1][j-1], dp[i-1][j]) + triangle[i][j]) ์ฆ, ์์ชฝ์์ ์ค๊ฑฐ๋ ์ผ์ชฝ ์์์ ์จ ๊ฐ ์ค ๋ ํฐ ๊ฐ์ ํ์ฌ triangle[i][j] ๊ฐ์ ๋ํ๋ค. dp[][] ๋ฐฐ์ด ์ ์ธ๋์ฒ๋ผ ์ํ์ ์ด๋ ค์ํ๋ ์ฌ๋๋ค์ ์ํด ๋ฐฐ์ด์ ๋์ผ๋ก ๋ณด๊ธฐ ์ฝ๊ฒ ์๊ฐํ ํด ๋ณด์๋ค.์ฝ..
๐ 1. ๋ฌธ์ ์ค๋ช
๊ณ์๋๋ ํญ์ฐ๋ก ์ผ๋ถ ์ง์ญ์ด ๋ฌผ์ ์ ๊ฒผ์ต๋๋ค. ๋ฌผ์ ์ ๊ธฐ์ง ์์ ์ง์ญ์ ํตํด ํ๊ต๋ฅผ ๊ฐ๋ ค๊ณ ํฉ๋๋ค. ์ง์์ ํ๊ต๊น์ง ๊ฐ๋ ๊ธธ์ m x n ํฌ๊ธฐ์ ๊ฒฉ์๋ชจ์์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค. ์๋ ๊ทธ๋ฆผ์ m = 4, n = 3 ์ธ ๊ฒฝ์ฐ์
๋๋ค. ๊ฐ์ฅ ์ผ์ชฝ ์, ์ฆ ์ง์ด ์๋ ๊ณณ์ ์ขํ๋ (1, 1)๋ก ๋ํ๋ด๊ณ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋, ์ฆ ํ๊ต๊ฐ ์๋ ๊ณณ์ ์ขํ๋ (m, n)์ผ๋ก ๋ํ๋
๋๋ค. ๊ฒฉ์์ ํฌ๊ธฐ m, n๊ณผ ๋ฌผ์ด ์ ๊ธด ์ง์ญ์ ์ขํ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด puddles์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค๋ฅธ์ชฝ๊ณผ ์๋์ชฝ์ผ๋ก๋ง ์์ง์ฌ ์ง์์ ํ๊ต๊น์ง ๊ฐ ์ ์๋ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ๊ฒฉ์์ ํฌ๊ธฐ m, n์ 1 ์ด์ ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์์๋ฃ ๋ง๋ค ์๊ฐ์ ๋ฒ์จ๋ถํฐ ํผ๊ณคํ๋ค. ํํํ ๋ฌธ์ ํ์ด์ ์์, ๋ช
์์ด ๊ทธ๋ํ ๋ฌธ์ ์ธ ๋งํผ ๊ทธ๋ํ์ ๋ํด ๊ฐ๋ตํ ์ค๋ช
ํ๊ณ ์ ํ๋ค.2-1. ๊ทธ๋ํ์ ๊ตฌ์กฐ๋
ธ๋: ์(circle)์ผ๋ก ํ์ํ๊ณ , ์ซ์๋ก ๋ฒํธ๋ฅผ ์ ๋๋ค.๊ฐ์ : ๋
ธ๋๋ฅผ ์ฐ๊ฒฐํ๋ ์ (segment)์ผ๋ก, ๋ชจ๋ ๊ฐ์ ์ด ์๋ฐฉํฅ์์ ๋ณด์ฌ์ฃผ๊ธฐ ์ํด ํ์ดํ ์์ด ์ง์ ์ผ๋ก ๊ทธ๋ฆฐ๋ค.return ํ๊ณ ์ ํ๋ ๊ฐ์ 1๋ฒ ๋
ธ๋์์ ๊ฐ์ฅ ๋ฉ๋ฆฌ ๋จ์ด์ง ๋
ธ๋์ ์ ์ด๋ค.์ฆ 1๋ฒ ๋
ธ๋์์ ๋ค๋ฅธ ๋
ธ๋๋ค๋ก ์ด๋ํ๋ ์ต๋จ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํด์ ์ต๋จ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ๋จผ ๋
ธ๋๋ค์ด ๋ช ๊ฐ์ธ์ง๋ฅผ ๊ตฌํด์ผ ํ๋ค. 2-2. ํด๊ฒฐ ๋ฐฉ๋ฒ(1) ์ธ์ ๋ฆฌ์คํธ๋ก ๊ทธ๋ํ ๋ง๋ค๊ธฐ List> graph = new ArrayList(); ์๋ฅผ ๋ค์ด ๋ฌธ์ ์์ ์ ์๋ vertex ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์n๋ช
์ ์ ์๊ฐ ์์ ๋, ๊ฐ ์ ์๋ ๋ชจ๋ ๋ค๋ฅธ ์ ์์ ๊ฒฝ๊ธฐ๋ฅผ ํ์ฌ n-1๋ฒ์ ์นํจ๋ฅผ ๊ธฐ๋กํ๋ค.์ฆ, ์ ์ฒด ์นํจ ๊ฒฐ๊ณผ๋ง ์์ผ๋ฉด ๊ฐ ์ ์์ ์๋์ ์์น๋ฅผ ์ ํํ ํ๋จํด์ ์์๋ฅผ ํ์ ํ ์ ์๋ค. ์นํจ๋ฅผ ํตํด ์์๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ ๋งํ๋ฉด ๋ชจ๋ ์ ์๋ค ๊ฐ์ ์ง์ ์ ์ธ ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์ํ๋ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, ์ ์ i์ ์ ์ j๊ฐ ๊ฒฝ๊ธฐ๋ฅผ ํ์ฌ ์นํจ๊ฐ ๊ฒฐ์ ๋๋ฉด, ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋กํ๋ค. ํ๋ก์ด๋ ์์
(Floyd-Warshall) ์๊ณ ๋ฆฌ์ฆ๋ชจ๋ ์ ์ต๋จ ๊ฒฝ๋ก(all-pairs shortest path)๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ทธ๋ํ์ ๋ชจ๋ ๋
ธ๋ ์์ ๋ํด ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ฉด ๊ทธ๋ํ์ ๋ชจ๋ ๋
ธ๋์ ๋ํด ๋ค๋ฅธ ๋ชจ๋ ๋
ธ๋๋ก ๊ฐ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์๋์ ๊ณํ๋ฒ(Dynamic Programming)์ด๋?๋์ ๊ณํ๋ฒ์ ์์ฃผ ์ฝ๊ฒ ์ค๋ช
ํ์๋ฉด, '์ด๋ฏธ ๊ณ์ฐํ ๊ฑด ๊ธฐ์ตํด ๋์๋ค๊ฐ, ๋ค์ ํ์ง ๋ง์'๋ ์ ๋ต์ด๋ค.๋์ ๊ณํ๋ฒ(Dynamic Programming, DP)์ ๋ณต์กํ ๋ฌธ์ ๋ฅผ ์์ ํ์ ๋ฌธ์ ๋ก ๋๋์ด ํด๊ฒฐํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ์ฌ ๋์ผํ ํ์ ๋ฌธ์ ๋ฅผ ๋ค์ ๊ณ์ฐํ์ง ์๋๋ก ํ๋ ์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ๊ธฐ๋ฒ์ด๋ค. ์ฃผ๋ก ์ต์ ํ ๋ฌธ์ ๋ ์กฐํฉ ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ํด๊ฒฐํ ๋ ์ฌ์ฉ๋๋ค. ๋์ ๊ณํ๋ฒ์๋ Top-Down ๋ฐฉ์์ธ ๋ฉ๋ชจ์ด์ ์ด์
๊ณผ Bottom-Up ๋ฐฉ์์ธ ํ
์ด๋ธ๋ง์ด ์๋ค. Top-Down (๋ฉ๋ชจ์ด์ ์ด์
)์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐ. ํ์ ๋ฌธ์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ์ฌ ์ค๋ณต ๊ณ์ฐ ๋ฐฉ์งBottom-Up (ํ
์ด๋ธ๋ง)์์ ๋ฌธ์ ๋ถํฐ ์ฐจ๋ก๋๋ก ํด๊ฒฐ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์์ด ๋ฌธ์ ๋ ๋๋ฌด ์ด๋ ค์์ ์ค์ค๋ก ํ๊ธฐ ํ๋ค์ด์ ๊ฒ์์ ๋์์ ๋ฐ์.์ฃผ์ด์ง ๋ฌธ์ ๋ ๊ทธ๋ํ ์ด๋ก ์ ์ต์ ์ ์ฅ ํธ๋ฆฌ(MST, Minimum Spanning Tree) ๋ฌธ์ ์ด๋ค. ์ด ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ํ์ํ ์ ์ ์ง์- Union-Find(์ ๋์จ ํ์ธ๋) ์๋ฃ๊ตฌ์กฐ- Kruskal's Algorithm (ํฌ๋ฃจ์ค์นผ) ์๊ณ ๋ฆฌ์ฆ Kruskal's Algorithm (ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ)ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ์์ ๋งํ ์ต์์ ์ฅํธ๋ฆฌ(MST)๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๋ฌธ์ ์ ๋ถ๋ฅ ๋ต๊ฒ greedy์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ฒฐ์ ์ ์๊ฐ๋ง๋ค ์ต์ ์ ๊ฒฐ์ ์ ํจ์ผ๋ก์ ์ต์ข
์ ์ธ ๋ต์ ๊ตฌํ๋ ๋ฐฉ์์ผ๋ก ๋ชจ๋ ์ ์ ์ ์ต์ ๋น์ฉ์ผ๋ก ์ฐ๊ฒฐํ ์ ์๊ฒ ํด์ค๋ค.ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น ๊ธฐ์ค(์ฌ๊ธฐ์๋ ๋ค๋ฆฌ ๊ฐ์ค..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์์
์ถ๋ ฅ ์๋ก ์ฃผ์ด์ง route ๋ฐฐ์ด์ ๋ง๋๊ทธ๋ํ๋ก ๊ทธ๋ ค ๋ดค๋ค. ์ต์ํ์ ์นด๋ฉ๋ผ๋ฅผ ๋ฐฐ์นํด์ผ ํ๋ฏ๋ก ๊ตฌ๊ฐ ์ข
๋ฃ ์์น๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ์ฐจ๋์ด ๊ตฌ๊ฐ์์ ์นด๋ฉ๋ผ๋ฅผ ๋จ ํ ๋ฒ๋ง์ด๋ผ๋ ๋ง๋๋ฉด ๋จ์ข
๋ฃ ์ง์ ์์ ๋ค์ ๊ตฌ๊ฐ๊ณผ ๊ฒน์น๊ฒ ๋๋ฏ๋ก ์ต์ํ์ ์นด๋ฉ๋ผ๋ฅผ ๋ฐฐ์น๊ฐ๋ฅ์นด๋ฉ๋ผ ๋ฐฐ์น๋ ๋๋ก์ ๊ฐ์ฅ ์ผ์ชฝ ๋๋ถํฐ ํ์ํ๋ฉฐ ์์๋๋ค.์
์ถ๋ ฅ ์์์์ MIN_VALUE์ธ -20 ์ง์ ๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ฉฐ ์ข
๋ฃ๊ตฌ๊ฐ๊ณผ ์์๊ตฌ๊ฐ์ด ๊ฒน์น๋ ๋ถ๋ถ์ ์นด๋ฉ๋ผ๊ฐ ๋ฐฐ์น๋๋ค.๊ตฌ๊ฐ ์ค ๊ฐ์ฅ ์ฒ์์ผ๋ก ๋ง๋๋ ์ข
๋ฃ ์์น๋ -15์ด๋ค.๋ฐ๋ผ์ ์ด ์์น์ ์ฒซ ๋ฒ์งธ ์นด๋ฉ๋ผ๋ฅผ ์ค์นํ๋ค. ๊ทธ๋ฆฌ๊ณ -13์ง์ ์์ ํ์ฌ ๊ตฌ๊ฐ๊ณผ ๋ค์ ๊ตฌ๊ฐ์ด ๋ง๋์ง๋ง ์ด๋ฏธ ํด๋น ๊ตฌ๊ฐ์๋ ์นด๋ฉ๋ผ๊ฐ ์ค์น ์๋ฃ ๋์์ผ๋ฏ๋ก ์คํตํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์ ๊ตฌ๊ฐ์ธ [-..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์ ๋ฌธ์ ์ ํ์กฐ๊ฑด1. ํ ๋ฒ์ ์ต๋ ๋๋ช
๊น์ง ๋ณดํธ์ ํ์ธ ์ ์์2. ๋ชธ๋ฌด๊ฒ ํฉ์ด `limit` ์ดํ์ฌ์ผ ํจ ๋ฐ๋ผ์ ์ต์๋ณดํธ๋ฅผ ์ฌ์ฉํ๋ ์ ๋ต์ ์ง๋ ค๋ฉด ๋ฐฐ์ด์ ์ ๋ ฌํ์ฌ ๊ฐ์ฅ ๊ฐ๋ฒผ์ด ์ฌ๋ + ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ์ฌ๋ ์กฐํฉ์ ์ง์ง์ด์ผ ํจ.๊ฐ์ฅ ํฐ ๋ชธ๋ฌด๊ฒ๋ฅผ ๊ฐ์ง ์ฌ๋์ ์ต๋ํ ๋นจ๋ฆฌ ์ฒ๋ฆฌํ๋ฉด์๋ ๋ณดํธ ์ฌ์ฉ์ ์ค์ผ ๊ฐ๋ฅ์ฑ์ด ๋๊ธฐ ๋๋ฌธ์ด๋ค.๋ง์ฝ ๋ ์ฌ๋์ ๋ชธ๋ฌด๊ฒ ํฉ์ด limit ์ดํ๋ผ๋ฉด, ํ ๋ณดํธ์ ํ์ธ ์ ์๋ค. ํฉ์ด limit์ ์ด๊ณผํ๋ค๋ฉด, ๋ฌด๊ฑฐ์ด ์ฌ๋์ ๋ฐ๋์ ํ ๋ช
๋ง ๋ณดํธ์ ํ์์ผ ํ๋ค.์ด๋ ๊ฒ ํ๋ ๊ฒ์ด ๋จ์ ์ฌ๋๋ค์ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ์ํ ์ต์ ์ ์ ํ์ด๋ค. โญ 3. ์ ๋ต์ฝ๋import java.util.*;class Solution { public int solution(i..
'Algorithm/Programmers_Best' ์นดํ
๊ณ ๋ฆฌ์ ๊ธ ๋ชฉ๋ก
๋จ์ถํค
๋ด ๋ธ๋ก๊ทธ
๋ด ๋ธ๋ก๊ทธ - ๊ด๋ฆฌ์ ํ ์ ํ |
Q
Q
|
์ ๊ธ ์ฐ๊ธฐ |
W
W
|
๋ธ๋ก๊ทธ ๊ฒ์๊ธ
๊ธ ์์ (๊ถํ ์๋ ๊ฒฝ์ฐ) |
E
E
|
๋๊ธ ์์ญ์ผ๋ก ์ด๋ |
C
C
|
๋ชจ๋ ์์ญ
์ด ํ์ด์ง์ URL ๋ณต์ฌ |
S
S
|
๋งจ ์๋ก ์ด๋ |
T
T
|
ํฐ์คํ ๋ฆฌ ํ ์ด๋ |
H
H
|
๋จ์ถํค ์๋ด |
Shift + /
โง + /
|
* ๋จ์ถํค๋ ํ๊ธ/์๋ฌธ ๋์๋ฌธ์๋ก ์ด์ฉ ๊ฐ๋ฅํ๋ฉฐ, ํฐ์คํ ๋ฆฌ ๊ธฐ๋ณธ ๋๋ฉ์ธ์์๋ง ๋์ํฉ๋๋ค.