2024. 2. 2. 18:27ใCS - Roadmap.sh/3. Common Algorithms
CS - 3. Common Algorithms - 3.6 Greedy Algorithms
Greedy Algorithms
๐กGreedy algorithms are a type of algorithm that always makes the choice that seems to be the best at that moment. This means that it makes a locally-optimal choice in the hope that this choice will lead to a globally-optimal solution.
์์ฌ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ๊ทธ ์๊ฐ์ ์ต์ ์ธ ๊ฒ์ฒ๋ผ ๋ณด์ด๋ ์ ํ์ ํ๋ ์๊ณ ๋ฆฌ์ฆ์ ํ ์ ํ์ ๋๋ค. ์ฆ, ์ด ์ ํ์ด ์ ์ธ๊ณ์ ์ผ๋ก ์ต์ ์ ์๋ฃจ์ ์ผ๋ก ์ด์ด์ง๊ธฐ๋ฅผ ๋ฐ๋ผ๋ฉฐ ๊ตญ์ง์ ์ผ๋ก ์ต์ ์ ์ ํ์ ํ๋ ๊ฒ์ ๋๋ค.
์ฝํ , ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ ํ๋ฉด ๊ฐ์ฅ ์ ๋ช ํ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ, ์์ฌ ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ(Greedy Algorithm)์ ์ต์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋ก, ๊ฐ ๋จ๊ณ์์ ์ง์ญ์ ์ผ๋ก ์ต์ ์ ์ ํ์ ํ๋ฉฐ ์ด๋ฅผ ํตํด ์ ์ญ์ ์ธ ์ต์ ํด๋ฅผ ์ฐพ์๋ด๋ ๋ฐฉ๋ฒ์ ๋๋ค.
์ด๋ฌํ ์ ํ์ ๊ฐ ๋จ๊ณ์์ ์ดํ์ ์ ํ์ ์ํฅ์ ๋ฏธ์น๋ฉฐ, ์ ํ์ด ์ด๋ฃจ์ด์ง๋ฉด ์ทจ์ํ ์ ์์ต๋๋ค.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ "ํ์ฌ์ ์ ํ์ด ์ดํ์ ์ ํ๊ณผ๋ ๋
๋ฆฝ์ ์ด๋ฉฐ, ํ์ฌ์ ์ ํ์ด ์ต์ข
๊ฒฐ๊ณผ์ ์ํฅ์ ๋ฏธ์น๋ค"๋ ๊ฒ์
๋๋ค.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ์ต์ ์ ํด๋ฅผ ์ฐพ์์ฃผ๋ ๊ฒ์ ์๋์ง๋ง, ํน์ ๋ฌธ์ ์์๋ ํจ๊ณผ์ ์ผ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ๋ฅผ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ ์ ์์ต๋๋ค.
๊ฐ์ฅ ํฐ ๋จ์์ ๋์ ๋ถํฐ ์ต๋ํ ์ฌ์ฉํ์ฌ ๊ฑฐ์ค๋ฆ๋์ ๋ง๋๋ ๊ฒ์ด ์ต์ ์ ํด๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ ๋๋ค.
In Python
๋ฐฉ๊ธ ์์ ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ๋ฅผ ํ์ด ๋ณด๊ฒ ์ต๋๋ค.
์ฌ์ฉํ ๋ชจ๋ ๋์ ์ ๊ฐฏ์๊ฐ ์ต์๊ฐ ๋๋๋ก ์ํ๋ค๋ ๊ฐ์ ํ์, (์ด ๊ฐ์ ์ด ์ฐจํ์ค๋ช ์ ์ค์ํฉ๋๋ค.)
def change(c):
coins = [500, 100, 50, 10] # ๋์ ์ ์ข
๋ฅ
count = {500: 0, 100: 0, 50: 0, 10: 0}
for coin in coins:
num = c // coin
count[coin] = num
c %= coin
return count

๊ฐ์ฅํฐ 500์์ผ๋ก // ๋์ด์ ๋๋ ์ง์ง ์์๋๊น์ง ๋๋๋ค, ๋๋จธ์ง๋ฅผ ๋ค์ ๋ค์ 100์์ผ๋ก ๋๋๊ณ .. ์ด๋ฐ ๋ ผ๋ฆฌ๋ก ๋ฐ๋ณตํฉ๋๋ค.
์ด๋ฐ๊ฒฝ์ฐ๋ ๋๋ฌด๋๋ ๊น๋ํ ๊ฒฝ์ฐ์ ๋๋ค.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง๋ ์๋๋ค.
๊ทธ๋ฐ๋ฐ ์์์ '๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง๋ ์๋๋ค.' ๋ผ๊ณ ํ์์ต๋๋ค.
def change(c):
coins = [10, 7, 1] # ๋์ ์ ์ข
๋ฅ
count = {10: 0, 7: 0, 1: 0}
for coin in coins:
num = c // coin
count[coin] = num
c %= coin
return count
์๋ฅผ๋ค์ด 14๋ฅผ 10, 7, 1 ๋์ ์ผ๋ก ๋๋๋ค๊ณ ์๊ฐํด ๋ด ์๋ค.

์์์ ์๊ตฌํ๋ ๋ต์ ์ฌ์ฉํ ๋ชจ๋ ๋์ ์ ๊ฐ์๊ฐ ์ต์๊ฐ ๋๋๋ก ์ ๋๋ค.
(๋ฌผ๋ก ์ฝ๋๋ฅผ ๋ฐ๊พธ๋ฉด ๊ฐ๋ฅํฉ๋๋ค.)
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ฅด๋ฉด
14์์ 10์ 1๊ฐ๋ก ๋๋ ๋ค 4์์ 7์๋์ ์ผ๋ก ๋๋์ ์์ผ๋ 1์ ๋์ 4๊ฐ๋ก ์ฒ๋ฆฌํ์์ต๋๋ค.
ํ์ง๋ง, 7์ 2๊ฐ๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ๊ฐ์ฅ ์ต์์ ๋์ ๊ฐ์ 2๊ฐ๋ก ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
์?
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง ์์ง๋ง ์? ์ฌ์ฉํ ๊น์?
ํฌ๊ฒ 3๊ฐ์ง ์ด์ ๊ฐ ์์ต๋๋ค.
1.๊ณ์ฐ ์๋
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ ๋จ๊ณ์์ ์ต์ ์ ์ ํ์ ํ๋ฏ๋ก, ๋ค๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ ๋นํด ๊ณ์ฐ ์๋๊ฐ ๋น ๋ฆ ๋๋ค.
๋ฐ๋ผ์ ๋ฌธ์ ์ ํฌ๊ธฐ๊ฐ ํฌ๊ฑฐ๋, ๊ณ์ฐ ์๊ฐ์ด ์ ํ๋ ์ํฉ์์ ์ ์ฉํฉ๋๋ค.
2.๊ฐ๊ฒฐํจ
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ ๋จ๊ณ์์์ ์ต์ ์ ์ ํ๋ง์ ๊ณ ๋ คํ๋ฏ๋ก, ์๊ณ ๋ฆฌ์ฆ์ ์ค๊ณ์ ๊ตฌํ์ด ๋น๊ต์ ๊ฐ๊ฒฐํฉ๋๋ค.
3.ํน์ ๋ฌธ์ ์ ๋ํ ์ต์ ํด
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํน์ ๋ฌธ์ ์ ๋ํด ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ , ์ต์ ์ ์ฅ ํธ๋ฆฌ ๋ฌธ์ , ์์
์ค์ผ์ค๋ง ๋ฌธ์ ๋ฑ์์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ต์ ์ ํด๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๊ธฐ ์ ์, ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด๋ ์ต์ ์ ํด๋ฅผ ์ฐพ์ ์ ์๋ ๋ฌธ์ ์ธ์ง ํ๋จํด์ผ ํฉ๋๋ค. ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ด ํญ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง ์๊ธฐ ๋๋ฌธ์, ๋ฌธ์ ์ ํน์ฑ๊ณผ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉ ๊ฐ๋ฅ์ฑ์ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
3๋ฒ์ด ์์ ๋งํ ์์์ธ ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ์ ๋ชจ์๋๋ค๊ณ ์๊ฐํ ์ ์์ต๋๋ค.
ํ์ง๋ง ์ ๋ ์ฌ์ฉํ ๋ชจ๋ ๋์ ์ ๊ฐฏ์๊ฐ ์ต์๊ฐ ๋๋๋ก ์ํ๋ค๋ ๊ฐ์ ์ ์ถ๊ฐํ์์ต๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ๋๋์ ์๋ ๊ฑฐ์ค๋ฆ๋์ ํฐ๋จ์ ๋ถํฐ ๋๋ ์ฃผ๋ ๊ฒ์ ์๋ฏธํ์ฃ , ๋ 7๊ฐ์ 10๋จ์์ ๋ฒ์ด๋๋ ๋์ ์ ์ฌ์ฉํ๋ค๊ณ ๊ฐ์ ํ๊ธฐ๋ ํ์์ต๋๋ค.
์ ๋ฆฌํด๋ณด๋ฉด ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํญ์ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง ์๋ ์ด์ ๋, ์์์ ๋งํ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ ผ๋ฆฌ ๋๋ฌธ์ ๋๋ค.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ ๋จ๊ณ์์ ๋จ์ง "์ง์ญ์ ์ผ๋ก" ์ต์ ์ ์ ํ์ ํ๋ค๋ ๋ฐ ์์ต๋๋ค. ์ด "์ง์ญ์ ์ผ๋ก ์ต์ "์ด๋ผ๋ ๊ฐ๋ ์ด ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ ์ด์ ์ฝ์ ์ ๋๋ค.
'CS - Roadmap.sh > 3. Common Algorithms' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
3.6.2 Kruskalโs algorithm (ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ) (1) | 2024.02.05 |
---|---|
3.6 Greedy Algorithms - 3.6.1 Huffman Coding (0) | 2024.02.03 |
3.5 Graph - 3.5.5 A* Algorithm (0) | 2024.01.31 |
3.5 Graph - 3.5.4 Dijkstraโs Algorithm (2) | 2024.01.30 |
3.5 Graph - 3.5.3 Bellman Fordโs Algorithm (1) | 2024.01.29 |