๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ(Greedy Algorithm)
"๋งค ์ ํ์์ ์ง๊ธ ์ด ์๊ฐ ๊ฐ์ฅ ์ต์ ์ธ ๋ต์ ์ ํํ์ฌ ์ ํฉํ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ์"
Greedy(ํ์, ์์ฌ์์ด)๋ผ๋ ์ด๋ฆ์ฒ๋ผ, ์ง๊ธ ๋น์ฅ ์ต์ ์ธ ๋ต์ ์ ํํ๋ ๊ณผ์ ์ ๋จ์ ๋ฐ๋ณตํ์ฌ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ๋ง ๊ทธ๋๋ก ๊ฐ ๋จ๊ณ์์ ๋ฏธ๋๋ฅผ ์๊ฐํ์ง ์๊ณ , ๊ทธ ์๊ฐ ์ต์ ์ ์ ํ์ ํ๋ ๊ธฐ๋ฒ์ด๊ธฐ ๋๋ฌธ์ ์ต์ข ์ ์ผ๋ก๋ ์ต์ ์ ํด๋ฅผ ๋ณด์ฅํ์ง ๋ชปํ๋ค.
- ์ง์ญ์ (local)์ผ๋ก๋ ์ต์ ์ ์ ํ์ด์ง๋ง, ์ ์ฒด์ (global)์ผ๋ก๋ ์ต์ ์ ํด๊ฐ ์๋ ์ ์๋ค.
- ๋งค ์๊ฐ ์ต์ ์ ๋ฐ๋ผ๊ฐ๋ฉด 1-1-1-100์ด์ง๋ง, ์ค๊ฐ์ ์ด์ง ๋จผ ๊ธธ์ ์์ด 1-1-10-10์ผ๋ก ์์ง์ผ ๋ ์ต์ ์ผ ์ ์๊ธฐ ๋๋ฌธ.
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ํ์ ์ ํ ์์ฑ(Greedy Choice Property), ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ(Optimal Substructure) ํน์ฑ์ ๊ฐ์ง๋ ๋ฌธ์ ๋ค์ ํด๊ฒฐํ๋ ๋ฐ ๊ฐ์ ์ด ์๋ค. ์ฆ, ํ ๋ฒ์ ์ ํ์ด ๋ค์ ์ ํ์๋ ์ ํ ๋ฌด๊ดํ ๊ฐ์ด์ด์ผ ํ๋ฉฐ ๋งค ์๊ฐ ์ต์ ํด๊ฐ ๋ฌธ์ ์ ๋ํ ์ต์ ํด์ฌ์ผ ํ๋ค๋ ์๋ฏธ์ด๋ค.
- ํ์ ์ ํ ์์ฑ(Greedy Choice Property) : ํ์ฌ ์ ํ์ด ์ดํ์ ์ ํ์ ์ํฅ์ ์ฃผ์ง ์์
- ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ(Optimal Substructure) : ๋งค ์๊ฐ ์ต์ ์ ํด๊ฐ ๋ฌธ์ ์ ์ฒด์ ๋ํ ์ต์ ์ ํด์ฌ์ผ ํจ
์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ๋ฉด ์์ฃผ ๋น ๋ฅธ ์๋๋ก ์ ๋ต์ ์ฐพ์๋ผ ์ ์๋ค.
- ๊ทผ์ฌ ์๊ณ ๋ฆฌ์ฆ : ์ ์กฐ๊ฑด์ ๋ถํฉํ์ง ์๋๋ผ๋, ์ด๋ ์ ๋ ์ ํฉํ ์์ค์ ํด๋ต์ ์ฐพ์ ์๋ ์๋ค. ์ต์ ์ด ์๋ "๋๋๊ฐ" ๋๋ "์ ๋นํ ๊ด์ฐฎ์ ๋ฐฉ๋ฒ"์ ์ฐพ์ ๋ ์ฌ์ฉํ๋ค๋ ๋ป. ๊ณ์ฐ ์๋๊ฐ ์ ํํ ์๊ณ ๋ฆฌ์ฆ์ ๋นํด ๋น ๋ฅธ ๊ฒฝ์ฐ๊ฐ ๋ง์ ์ค์ฉ์ !
11047๋ฒ ๋์ 0
๋ฌธ์ | ์ค๊ท๊ฐ ๊ฐ์ง๊ณ ์๋ ๋์ ์ ์ด N์ข
๋ฅ์ด๊ณ , ๊ฐ๊ฐ์ ๋์ ์ ๋งค์ฐ ๋ง์ด ๊ฐ์ง๊ณ ์๋ค. ๋์ ์ ์ ์ ํ ์ฌ์ฉํด์ ๊ทธ ๊ฐ์น์ ํฉ์ K๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค. ์ด๋ ํ์ํ ๋์ ๊ฐ์์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. |
์ ๋ ฅ | ์ฒซ์งธ ์ค์ N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 10, 1 ≤ K ≤ 100,000,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๋์ ์ ๊ฐ์น Ai๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ฃผ์ด์ง๋ค. (1 ≤ Ai ≤ 1,000,000, A1 = 1, i ≥ 2์ธ ๊ฒฝ์ฐ์ Ai๋ Ai-1์ ๋ฐฐ์) |
์ถ๋ ฅ | ์ฒซ์งธ ์ค์ K์์ ๋ง๋๋๋ฐ ํ์ํ ๋์ ๊ฐ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค. |
- ๋์ด๋ ๋์ ์ค ๊ธ์ก์ด ๋์ ์์ผ๋ก ๋จ์ ๊ธ์ก๊ณผ ๋น๊ตํ๋ฉฐ ๋์ ์ ๊ฐ์๋ฅผ ์นด์ดํ ํ๋ค.
n, k = map(int, input().split())
a = [0] * n # n๊ฐ์ ๋์
for i in range(n):
a[i] = int(input())
count = 0 # ํ์ํ ๋์ ์ ๊ฐ์
for i in range(n-1, -1, -1):
if a[i] <= k:
count += (k // a[i]) # ๋์ ์ ๊ฐ์
k = k % a[i] # ๋จ์ ๊ธ์ก
print(count)
1931๋ฒ ํ์์ค ๋ฐฐ์
๋ฌธ์ | ํ ๊ฐ์ ํ์์ค์ด ์๋๋ฐ ์ด๋ฅผ ์ฌ์ฉํ๊ณ ์ ํ๋ N๊ฐ์ ํ์์ ๋ํ์ฌ ํ์์ค ์ฌ์ฉํ๋ฅผ ๋ง๋ค๋ ค๊ณ ํ๋ค. ๊ฐ ํ์ I์ ๋ํด ์์์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ด ์ฃผ์ด์ ธ ์๊ณ , ๊ฐ ํ์๊ฐ ๊ฒน์น์ง ์๊ฒ ํ๋ฉด์ ํ์์ค์ ์ฌ์ฉํ ์ ์๋ ํ์์ ์ต๋ ๊ฐ์๋ฅผ ์ฐพ์๋ณด์. ๋จ, ํ์๋ ํ๋ฒ ์์ํ๋ฉด ์ค๊ฐ์ ์ค๋จ๋ ์ ์์ผ๋ฉฐ ํ ํ์๊ฐ ๋๋๋ ๊ฒ๊ณผ ๋์์ ๋ค์ ํ์๊ฐ ์์๋ ์ ์๋ค. ํ์์ ์์์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ด ๊ฐ์ ์๋ ์๋ค. ์ด ๊ฒฝ์ฐ์๋ ์์ํ์๋ง์ ๋๋๋ ๊ฒ์ผ๋ก ์๊ฐํ๋ฉด ๋๋ค. |
์ ๋ ฅ | ์ฒซ์งธ ์ค์ ํ์์ ์ N(1 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N+1 ์ค๊น์ง ๊ฐ ํ์์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋๋ฐ ์ด๊ฒ์ ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ํ์์ ์์์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ด ์ฃผ์ด์ง๋ค. ์์ ์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ 231-1๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์ ๋๋ 0์ด๋ค. |
์ถ๋ ฅ | ์ฒซ์งธ ์ค์ ์ต๋ ์ฌ์ฉํ ์ ์๋ ํ์์ ์ต๋ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค. |
- ํ์๊ฐ ๋นจ๋ฆฌ ๋๋๋ ์์ผ๋ก ์ ๋ ฌํ ๋ค ์ต๋ํ ๋ง์ ํ์๋ฅผ ํ ์ ์๋๋ก ๊ตฌ์ฑํด์ผ ํจ.
- ๋๋๋ ์๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ → ์์ํ๋ ์๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
- Python์ sort๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ
- 1. (2๋ฒ sort) ์ ์ฒด๋ฅผ ์์ ์๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ → ์ ๋ ฌ๋ ๋ฆฌ์คํธ๋ฅผ ๋ค์ ๋๋๋ ์๊ฐ์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
- 2. (1๋ฒ sort) key์ ํํ๋ก ์ฌ๋ฌ ์ธ์๋ฅผ ์ฃผ์ด ํ ๋ฒ์ ์ ๋ ฌ โ
n = int(input()) # ํ์์ ๊ฐ์
time = [[0]*2 for i in range(n)] # ํ์ ์๊ฐ 2์ฐจ์ ๋ฐฐ์ด ์์ฑ, ์ด๊ธฐํ
for i in range(n): # ํ์ ๊ฐ์๋งํผ ์
๋ ฅ๋ฐ๊ธฐ
time[i] = list(map(int, input().split()))
# 1์์ : ๋๋๋ ์๊ฐ(์ค๋ฆ์ฐจ์), 2์์ : ์์ํ๋ ์๊ฐ(์ค๋ฆ์ฐจ์)
time = sorted(time, key = lambda x: (x[1], x[0]))
count = 1 # ํ์ฌ ํ์ ์ ์ ์ฅ. ์ต์ 1๋ฒ์ ํ์ ์งํ
end = time[0][1] # ์ฒซ ๋ฒ์งธ ํ์๊ฐ ๋๋๋ ์๊ฐ
for i in range(1, n):
if time[i][0] >= end: # ๋ค์ ํ์๋ฅผ ์์ํ ์ ์์ผ๋ฉด
count += 1
end = time[i][1] # ๋ค์ ํ์๊ฐ ๋๋๋ ์๊ฐ ๊ฐฑ์
print(count)