๐Ÿ™‚TIL from lecture


Greedy Algorithm

: ํ˜„์žฌ ์ƒํ™ฉ์—์„œ ์ง€๊ธˆ ๋‹น์žฅ ์ข‹์€ ๊ฒƒ๋งŒ ๊ณ ๋ฅด๋Š” ๋ฐฉ๋ฒ•

๐Ÿ”‘ ๋ฌธ์ œ๋ฅผ ํ’€๊ธฐ ์œ„ํ•œ ์ตœ์†Œํ•œ์˜ ์•„์ด๋””์–ด๋ฅผ ๋– ์˜ฌ๋ฆด ์ˆ˜ ์žˆ๋Š” ๋Šฅ๋ ฅ ์š”๊ตฌ

๐Ÿ”‘ ์ •๋‹น์„ฑ ๋ถ„์„์ด ์ค‘์š”!

โ†’ ๋‹จ์ˆœํžˆ ๊ฐ€์žฅ ์ข‹์•„ ๋ณด์ด๋Š” ๊ฒƒ์„ ๋ฐ˜๋ณต์ ์œผ๋กœ ์„ ํƒํ•ด๋„ ์ตœ์ ์˜ ํ•ด๋ฅผ ๊ตฌํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ๊ฒ€ํ† 

: ์ตœ์ ์˜ ํ•ด๊ฐ€ ๋ณด์žฅ๋˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ

ex) ๊ฑฐ์Šค๋ฆ„ ๋ˆ

์นด์šดํ„ฐ์— ๊ฑฐ์Šค๋ฆ„๋ˆ์œผ๋กœ ์‚ฌ์šฉํ•  500์›, 100์›, 50์›, 10์›์งœ๋ฆฌ ๋™์ „์ด ๋ฌดํ•œ์ด ์กด์žฌํ•  ๋•Œ,
์†๋‹˜์—๊ฒŒ ๊ฑฐ์Šฌ๋Ÿฌ ์ค„ N์›์˜ ์ตœ์†Œ ๋™์ „์˜ ๊ฐœ์ˆ˜๋ฅผ ๊ตฌํ•˜์‹œ์˜ค. ๋‹จ, N์€ ํ•ญ์ƒ 10์˜ ๋ฐฐ์ˆ˜

  • ๊ฐ€์žฅ ํฐ ํ™”ํ ๋‹จ์œ„๋ถ€ํ„ฐ ๋ˆ์„ ๊ฑฐ์Šฌ๋Ÿฌ ์ฃผ๋Š” ๊ฒƒ์ด ์ตœ์ ์˜ ํ•ด๋ฅผ ๋ณด์žฅํ•˜๋Š” ์ด์œ ?
    ๊ฐ€์ง€๊ณ  ์žˆ๋Š” ๋™์ „์˜ ํฐ ๋‹จ์œ„๊ฐ€ ํ•ญ์ƒ ์ž‘์€ ๋‹จ์œ„์˜ ๋ฐฐ์ˆ˜์ด๋ฏ€๋กœ
    โ†’ ์ž‘์€ ๋‹จ์œ„์˜ ๋™์ „๋“ค์„ ์ข…ํ•ฉํ•ด ๋‹ค๋ฅธ ๋‹จ์œ„๊ฐ€ ๋‚˜์˜ฌ ์ˆ˜ ์—†๊ธฐ ๋•Œ๋ฌธ

cf) 800์›์„ ๊ฑฐ์Šฌ๋Ÿฌ์•ผ ํ•˜๋Š”๋ฐ ํ™”ํ ๋‹จ์œ„๊ฐ€ 500, 400, 100 ์ธ ๊ฒฝ์šฐ

n = 1260
count = 0

#ํฐ ๋‹จ์œ„ ํ™”ํ๋ถ€ํ„ฐ ์ฐจ๋ก€๋Œ€๋กœ ํ™•์ธ
mon = [500, 100, 50, 10]

for coin in mon:
	count += n//coin # ํ•ด๋‹น ํ™”ํ๋กœ ๊ฑฐ์Šฌ๋Ÿฌ ์ค„ ์ˆ˜ ์žˆ๋Š” ๋™์ „์˜ ๊ฐœ์ˆ˜
	n %= coin # ํ•ด๋‹น ํ™”ํ ๋‹จ์œ„ ๋ณด๋‹ค ์ž‘์€ ๋‹จ์œ„๊ฐ€ ํ•„์š”ํ•œ ๋ˆ

print(count)

ํ™”ํ์˜ ์ข…๋ฅ˜๊ฐ€ K๋ผ๊ณ  ํ•  ๋•Œ, ์†Œ์Šค์ฝ”๋“œ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„ O(k)

๐Ÿ†Today Code Test


๐Ÿ› Problem Approach

'''
๋ฌธ์ œ : ์–ด๋–ค ์ˆ˜ N์ด 1์ด ๋  ๋•Œ๊นŒ์ง€ ๋‹ค์Œ์˜ ๋‘ ๊ณผ์ • ์ค‘ ํ•˜๋‚˜๋ฅผ ๋ฐ˜๋ณต์ ์œผ๋กœ ์„ ํƒํ•˜์—ฌ ์ˆ˜ํ–‰
(๋‹จ, ๋‘๋ฒˆ์งธ ์—ฐ์‚ฐ์€ N/K๋กœ ๋‚˜๋ˆ„์–ด ๋–จ์–ด์งˆ๋•Œ๋งŒ!)

1. N - 1
2. N / K

! ์ •๋‹น์„ฑ
# 2๋ฒˆ์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๊ฒŒ ์ตœ์†Œ๊ฐ’์„ ๋งŒ๋“œ๋Š” ๋ฐ ์œ ๋ฆฌ -> ๋‚˜๋ˆ„๊ธฐ๋Š” N ๊ฐ’์„ ํฌ๊ฒŒ ๋‚ฎ์ถ”๋ฏ€๋กœ
# 1๋ฒˆ์€ 2๋ฒˆ์„ ์ˆ˜ํ–‰ํ•˜์ง€ ๋ชปํ• ๋•Œ๋งŒ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐฉ๋ฒ• ์‚ฌ์šฉ
'''

N, K = map(int, input().split())
count = 0

while N != 1: # N์ด 1์ด ์•„๋‹ ๋™์•ˆ ์‹คํ–‰
    count += 1
    if N % K == 0: # N์ด K์˜ ๋ฐฐ์ˆ˜์ด๋ฉด
        N //= K # ๋ชซ์„ N์œผ๋กœ
    else:
        N -= 1

print(count)

์‹œ๊ฐ„๋ณต์žก๋„ O(kk) : count์˜ ํšŸ์ˆ˜ ๋งŒํผ

๐Ÿ”‘Solution

โœ…์ •๋‹น์„ฑ
: N์ด ์•„๋ฌด๋ฆฌ ํฐ ์ˆ˜์—ฌ๋„ K(K โ‰ฅ 2)๋กœ ๊ณ„์† ๋‚˜๋ˆˆ๋‹ค๋ฉด ๊ธฐํ•˜ ๊ธ‰์ˆ˜์ ์œผ๋กœ ๋น ๋ฅด๊ฒŒ ์ˆ˜๋ฅผ ์ค„์ผ ์ˆ˜ ์žˆ์Œ!

## ์ฝ”๋“œ ์†”๋ฃจ์…˜

N, K = map(int, input().split())
res = 0

while True:
	target = (N//K)*K # N๋ณด๋‹ค ์ž‘์€ K์˜ ์ตœ๋Œ€ ๋ฐฐ์ˆ˜ ๊ฐ’
	result += (n - target) # K์˜ ๋ฐฐ์ˆ˜๊ฐ€ ์•„๋‹ ์‹œ, 1๋ฒˆ ๊ณผ์ •(-1)์„ ์ˆ˜ํ–‰ ํ•ด์•ผํ•˜๋Š” ๊ฐ’
	n = target # K์˜ ์ตœ๋Œ€ ๋ฐฐ์ˆ˜ ๊ฐ’
	if n < k: # K๋ณด๋‹ค ์ž‘์•„์„œ ๋‚˜๋ˆ ์ง€์ง€ ์•Š์€ ๊ฐ’์ด ์žˆ๋‹ค๋ฉด ๋ฐ˜๋ณต๋ฌธ ํƒˆ์ถœ
		break
	result += 1 # N/K๋ฅผ ๊ณ„์‚ฐํ•œ ํšŸ์ˆ˜ ์ฆ๊ฐ€ ์‹œํ‚ค๊ธฐ
	n //= k # K๋กœ ๋‚˜๋ˆ  ์ค„์ธ N๊ฐ’ ๊ณ„์‚ฐํ•˜๊ธฐ

result += (n-1) # K๋ณด๋‹ค ์ž‘์•„์„œ ๋‚˜๋ˆ ์ง€์ง€ ์•Š์€ ๊ฐ’์ด ์žˆ๋‹ค๋ฉด 1์ด ๋ ๋•Œ๊นŒ์ง€ 1๋‹จ๊ณ„ ์ˆ˜ํ–‰ํ•˜๋Š” ๊ฐ’ ๋”ํ•ด์ฃผ๊ธฐ

print(result)

์‹œ๊ฐ„๋ณต์žก๋„ O(logโกk\log{k})

โ†’ ํ•œ ๋ฐ˜๋ณต๋ฌธ ์•ˆ์—์„œ 1, 2๋‹จ๊ณ„๊ฐ€ ๋™์‹œ ์ˆ˜ํ–‰๋˜๊ธฐ ๋•Œ๋ฌธ์— ํฐ ์ˆ˜ ์ผ์ˆ˜๋ก ๋” ์œ ๋ฆฌํ•˜๋‹ค

profile
Always, Better than.

0๊ฐœ์˜ ๋Œ“๊ธ€