์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ
3์ฅ. ๊ทธ๋ฆฌ๋(Greedy) ์๊ณ ๋ฆฌ์ฆ
- ํ์๋ฒ: ํ์ฌ ์ํฉ์์ ์ง๊ธ ๋น์ฅ ์ข์ ๊ฒ๋ง ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ
- ์์ ์๊ณ ๋ฆฌ์ฆ: ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ, ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ
- ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ง์ ์ด๋ค ์ถ์ ๋๋ค
์์ 3-1. ๊ฑฐ์ค๋ฆ๋
๋ฌธ์ ํด๊ฒฐ: ๊ฐ์ฅ ํฐ ํํ ๋จ์๋ถํฐ ๋์ ๊ฑฐ์ฌ๋ฌ ์ฃผ๋ ๊ฒ
n = 1260
count = 0
# ํฐ ๋จ์์ ํํ๋ถํฐ ์ฐจ๋ก๋๋ก ํ์ธ
coin_types = [500, 100, 50, 10]
for coin in coin_types:
count += n // coin # ํด๋น ํํ๋ก ๊ฑฐ์ฌ๋ฌ ์ค ์ ์๋ ๋์ ์ ๊ฐ์ ์ธ๊ธฐ
n %= coin
print(count)
์๊ฐ๋ณต์ก๋: O(K) -> ํํ์ ์ข ๋ฅ๊ฐ K๊ฐ ์ผ๋
์ ๋น์ฑ ๊ฒ์ฌ: ๊ฐ์ง๊ณ ์๋ ๋์ ์ค์์ ํฐ ๋จ์๊ฐ ํญ์ ์์ ๋จ์์ ๋ฐฐ์์ด๋ฏ๋ก ์์ ๋จ์์ ๋์ ๋ค์ ์ข ํฉํด ๋ค๋ฅธ ํด๊ฐ ๋์ฌ ์ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํด๊ฒฐ ๊ฐ๋ฅ. ๋ง์ฝ ํํ์ ๋จ์๊ฐ ์๋ก ๋ฐฐ์ ํํ๊ฐ ์๋๋ผ ๋ฌด์์๋ก ์ฃผ์ด์ง ๊ฒฝ์ฐ์๋ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
- ๋๋ถ๋ถ์ ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ์์๋ ์ด์ฒ๋ผ ๋ฌธ์ ํ์ด๋ฅผ ์ํ ์ต์ํ์ ์์ด๋์ด๋ฅผ ๋ ์ฌ๋ฆฌ๊ณ ์ด๊ฒ์ด ์ ๋นํ์ง ๊ฒํ ํ ์ ์์ด์ผ ๋ต์ ๋์ถ ํ ์ ์๋ค.
์ค์ ๋ฌธ์ 2. ํฐ ์์ ๋ฒ์น
๋ฌธ์ ํด๊ฒฐ: ๊ฐ์ฅ ํฐ ์๋ฅผ K๋ฒ ๋ํ๊ณ ๋ ๋ฒ์งธ๋ก ํฐ ์๋ฅผ ํ ๋ฒ ๋ํ๋ ์ฐ์ฐ์ ๋ฐ๋ณต -> m์ด 10000์ดํ์ด๋ฉด ์๊ฐ์ด๊ณผ๊ฐ ๋์ง ์์ง๋ง 100์ต์ด์์ฒ๋ผ ์ปค์ง๋ค๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋ ๊ฒ์ด๋ค.
1) ๋จ์ํ๊ฒ ํธ๋ ๋ต์ ์์
n, m, k = map(int, input().split())
arr = list(map(int, input().split()))
answer = 0
# ๋ฐฐ์ด ์ ๋ ฌ
arr.sort()
first_max = arr[n - 1]
second_max = arr[n - 2]
while True:
# ๊ฐ์ฅ ํฐ ์๋ฅผ K๋ฒ ๋ํ๊ธฐ
for i in range(k):
if m == 0:
break
answer += first_max
m -= 1 # ๋ํ ๋๋ง๋ค 1์ฉ ๋นผ๊ธฐ
if m == 0:
break
# ๋ ๋ฒ์งธ๋ก ํฐ ์๋ฅผ ํ ๋ฒ ๋ํ๊ธฐ
answer += second_max
m -= 1
print(answer)
2) ๋ฐ๋ณต๋๋ ์์ด์ ๋ํด์ ํ์
- M์ K + 1 ๋ก ๋๋ ๋ชซ์ด ์์ด์ด ๋ฐ๋ณต๋๋ ํ์๊ฐ ๋๋ค
- ์ฌ๊ธฐ์ K๋ฅผ ๊ณฑํด์ฃผ๋ฉด ๊ฐ์ฅ ํฐ ์๊ฐ ๋ฑ์ฅํ๋ ํ์๊ฐ ๋๋ค
- ๊ฐ์ฅ ํฐ ์๊ฐ ๋ํด์ง๋ ํ์ : int(M / (K + 1)) * K + M % (K + 1)
count = int(m / (k + 1)) * k
count += m % (k + 1)
answer += (count) * first_max # ๊ฐ์ฅ ํฐ ์ ๋ํ๊ธฐ
answer += (m - count) * second_max # ๋๋ฒ์งธ๋ก ํฐ ์ ๋ํ๊ธฐ
์ค์ ๋ฌธ์ 3. ์ซ์ ์นด๋ ๊ฒ์
- ๊ฒ์์ ๋ฃฐ: ์ ํ๋ ํ์ ํฌํจ๋ ์นด๋๋ค ์ค ๊ฐ์ฅ ์ซ์๊ฐ ์์ ์นด๋๋ฅผ ๋ฝ๊ณ , ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ซ์์ ์นด๋๋ฅผ ๋ฝ์ ์ ์๋๋ก ์ ๋ต์ ์ธ์์ผ ํจ
- ๋ฌธ์ ํด๊ฒฐ: ๊ฐ ํ๋ง๋ค ๊ฐ์ฅ ์์ ์๋ฅผ ์ฐพ์ ๋ค์ ๊ทธ ์ ์ค์์ ๊ฐ์ฅ ํฐ ์ ์ฐพ๊ธฐ
n, m = map(int, input().split())
answer = 0
# ๋ต์ 1) min ํจ์๋ฅผ ์ด์ฉ
for i in range(n):
data = list(map(int, input().split()))
# ํ์ฌ ์ค์์ ๊ฐ์ฅ ์์ ์ ์ฐพ๊ธฐ
min_card = min(data)
# ๊ฐ์ฅ ์์ ์ ๋ค ์ค์์ ๊ฐ์ฅ ํฐ ์ ์ฐพ๊ธฐ
answer = max(answer, min_card)
# ๋ต์ 2) 2์ค ๋ฐ๋ณต๋ฌธ ์ฌ์ฉ
for i in range(n):
data = list(map(int, input().split()))
min_card = 10001
for a in data:
min_card = min(min_card, a)
answer = max(answer, min_card)
print(answer)
์ค์ ๋ฌธ์ 4. 1์ด ๋ ๋๊น์ง
- ์ด๋ ํ ์ N์ด 1์ด ๋ ๋๊น์ง 1. N์์ 1์ ๋บ๋ค 2. N์ K๋ก ๋๋๋ค ๋ ๊ณผ์ ์ค ํ๋๋ฅผ ์ํํ๋ ์ต์ ํ์ ๊ตฌํ๊ธฐ
- ๋ฌธ์ ํด๊ฒฐ : N์ ๋ํ์ฌ ์ต๋ํ ๋ง์ด ๋๋๊ธฐ๋ฅผ ์ํํ๋ค. -> 1์ ๋นผ๋ ๊ฒ๋ณด๋ค 2 ์ด์์ ์๋ก ๋๋๋ ๊ฒ์ด ์ซ์๋ฅผ ํจ์ฌ ๋ง์ด ์ค์ผ ์ ์๊ธฐ ๋๋ฌธ์
๋ต์1) ๋จ์ํ๊ฒ ํธ๋ ๋ต์
n, k = map(int, input().split())
answer = 0
# ๋ต์ 1) ๋จ์ํ๊ฒ ํ๊ธฐ
# N์ด K ์ด์์ด๋ผ๋ฉด K๋ก ๊ณ์ ๋๋๊ธฐ
while n >= k:
# N์ด K๋ก ๋๋์ด ๋จ์ด์ง์ง ์๋๋ค๋ฉด N - 1
while n % k != 0:
n -= 1
answer += 1
# K๋ก ๋๋๊ธฐ
n //= k
answer += 1
# ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ
while n > 1:
n -= 1
answer += 1
print(answer)
๋ต์2) ๋ ๋น ๋ฅด๊ฒ ๋์ํ๋ ๋ต์
- N์ด K์ ๋ฐฐ์๊ฐ ๋๋๋ก ํจ์จ์ ์ผ๋ก ํ ๋ฒ์ ๋นผ๋ ๋ฐฉ์
n, k = map(int, input().split())
answer = 0
# ๋ต์ 2) ๋ ๋น ๋ฅด๊ฒ ๋์ํ๋ ํ์ด
while True:
# N == K๋ก ๋๋์ด๋จ์ด์ง๋ ์๊ฐ ๋ ๋๊น์ง 1์ฉ ๋นผ๊ธฐ
target = (n // k) * k
answer += (n - target)
n = answer
# N์ด K๋ณด๋ค ์์ ๋ (๋์ด์ ๋๋ ์ ์์ ๋) ๋ฐ๋ณต๋ฌธ ํ์ถ
if n < k:
break
# K๋ก ๋๋๊ธฐ
answer += 1
n //= k
# ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ
answer += (n - 1)
print(answer)