์—ฌ์œ ๋กœ์›Œ์ ธ์„œ! ์ €๋ฒˆ์— ๋ชป ์ฝ์€ ์•ž๋ถ€๋ถ„๋„ ์ฝ์–ด๋ณด๋ ค๊ณ  ํ•œ๋‹ค ํ›„ํ›„ ๐Ÿ˜Ž

1. ๋‹น์žฅ ์ข‹์€ ๊ฒƒ๋งŒ ์„ ํƒํ•˜๋Š” ๊ทธ๋ฆฌ๋””

  • ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋ž€, ์–ด๋– ํ•œ ๋ฌธ์ œ๊ฐ€ ์žˆ์„ ๋•Œ ๋‹จ์ˆœ ๋ฌด์‹œํ•™ํ•˜๊ฒŒ, ํƒ์š•์ ์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ‘ธ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค.
  • ๋งค ์ˆœ๊ฐ„ ๊ฐ€์žฅ ์ข‹์•„๋ณด์ด๋Š” ๊ฒƒ์„ ์„ ํƒํ•˜๋ฉฐ, ํ˜„์žฌ์˜ ์„ ํƒ์ด ๋‚˜์ค‘์— ๋ฏธ์น  ์˜ํ–ฅ์— ๋Œ€ํ•ด์„œ๋Š” ๊ณ ๋ คํ•˜์ง€ ์•Š๋Š”๋‹ค.
  • ์•”๊ธฐํ•œ๋‹ค๊ณ  ํ•ด์„œ ์ž˜ ํ‘ธ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์•„๋‹ˆ๋‹ค. ๋ฌธ์ œ๋ฅผ ํ’€๊ธฐ ์œ„ํ•œ ์ตœ์†Œํ•œ์˜ ์•„์ด๋””์–ด๋ฅผ ๋– ์˜ฌ๋ฆด ์ˆ˜ ์žˆ๋Š” ๋Šฅ๋ ฅ์ด ํ•„์š”ํ•˜๋‹ค. ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ๊ธฐ์ค€์— ๋”ฐ๋ผ ์ข‹์€ ๊ฒƒ์„ ์„ ํƒํ•˜๋Š” ๊ฒƒ์ด๋ฏ€๋กœ ๊ฐ€์žฅ ํฐ ์ˆœ์„œ๋Œ€๋กœ, ๊ฐ€์žฅ ์ž‘์€ ์ˆœ์„œ๋Œ€๋กœ์™€ ๊ฐ™์€ ๊ธฐ์ค€์„ ์•Œ๊ฒŒ ๋ชจ๋ฅด๊ฒŒ ์ œ์‹œํ•ด์ค€๋‹ค!
  • ์ •๋ ฌ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ์ง์„ ์ด๋ค„์„œ ์ œ์ถœ๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ๋‹ค.

์˜ˆ์ œ 1. ๊ฑฐ์Šค๋ฆ„๋ˆ

๋ฌธ์ œ

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

ํ•ด์„ค

๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ๋Œ€ํ‘œ์ ์ธ ๋ฌธ์ œ. ๊ฐ€์žฅ ํฐ ํ™”ํ๋‹จ์œ„๋ถ€ํ„ฐ ๋ˆ์„ ๊ฑฐ์Šฌ๋Ÿฌ ์ฃผ๋Š” ๊ฒƒ์ด๋‹ค.

n = 1260
count = 0

coins = [500, 100, 50, 10]

for coin in coins:
    count += n // coin
    n %= coin

print(count)
  • ํ™”ํ์˜ ์ข…๋ฅ˜๊ฐ€ K๊ฐœ๋ผ๊ณ  ํ•  ๋•Œ ์œ„ ์†Œ์Šค์ฝ”๋“œ์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” O(K)๋‹ค.
  • ๊ฑฐ์Šฌ๋Ÿฌ์ค˜์•ผ ํ•˜๋Š” ๋ˆ๊ณผ ๋ฌด๊ด€ํ•˜๋ฉฐ, ๋™์ „์˜ ์ข…๋ฅ˜์— ์˜ํ–ฅ์„ ๋ฐ›๋Š”๋‹ค.

๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์ •๋‹น์„ฑ

  • ๋ชจ๋“  ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ์— ์ ์šฉํ•  ์ˆ˜ ์—†๋‹ค! ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์œผ๋กœ ํ•ด๋ฒ•์„ ์ฐพ์•˜์„ ๋•Œ๋Š” ๊ทธ ํ•ด๋ฒ•์ด ์ •๋‹นํ•œ์ง€ ๊ฒ€ํ† ํ•ด์•ผ ํ•œ๋‹ค. ๋Œ€๋ถ€๋ถ„์˜ ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ์—์„œ๋Š” ์ด์ฒ˜๋Ÿผ ๋ฌธ์ œ ํ’€์ด๋ฅผ ์œ„ํ•œ ์ตœ์†Œํ•œ์˜ ์•„์ด๋””์–ด๋ฅผ ๋– ์˜ฌ๋ฆฌ๊ณ  ์ด๊ฒƒ์ด ์ •๋‹นํ•œ์ง€ ๊ฒ€ํ† ํ•  ์ˆ˜ ์žˆ์–ด์•ผ ๋‹ต์„ ๋„์ถœํ•  ์ˆ˜ ์žˆ๋‹ค.
  • ์–ด๋–ค ๋ฌธ์ œ๋ฅผ ๋งŒ๋‚ฌ์„ ๋•Œ ๋ฌธ์ œ์˜ ์œ ํ˜•์„ ๋ฐ”๋กœ ํŒŒ์•…ํ•˜๊ธฐ ์–ด๋ ค์šธ ๋•Œ๋Š”, ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์˜์‹ฌํ•˜๊ณ  ํ•ด๊ฒฐ๋ฒ•์ด ์กด์žฌํ•˜๋Š”์ง€ ๊ณ ๋ฏผํ•ด๋ณด์ž.

2. ํฐ ์ˆ˜์˜ ๋ฒ•์น™

๋‚œ์ด๋„ ํ•˜

๋ฌธ์ œ

๋™๋นˆ์ด์˜ ํฐ ์ˆ˜ ๋ฒ•์น™์€ ๋‹ค์–‘ํ•œ ์ˆ˜๋กœ ์ด๋ฃจ์–ด์ง„ ๋ฐฐ์—ด์ด ์žˆ์„ ๋•Œ ์ฃผ์–ด์ง„ ์ˆ˜๋“ค์„ M๋ฒˆ ๋”ํ•˜์—ฌ ๊ฐ€์žฅ ํฐ ์ˆ˜๋ฅผ ๋”ํ•˜๋Š” ๋ฒ•์น™์ด๋‹ค. ๋‹จ, ๋ฐฐ์—ด์˜ ํŠน์ •ํ•œ ์ธ๋ฑ์Šค์— ํ•ด๋‹นํ•˜๋Š” ์ˆ˜๊ฐ€ ์—ฐ์†ํ•ด์„œ K๋ฒˆ์„ ์ดˆ๊ณผํ•˜์—ฌ ๋”ํ•ด์งˆ ์ˆ˜ ์—†๋Š” ๊ฒƒ์ด ์ด ๋ฒ•์น™์˜ ํŠน์ง•์ด๋‹ค. ๋‹จ, ์„œ๋กœ ๋‹ค๋ฅธ ์ธ๋ฑ์Šค์˜ ํ•ด๋‹นํ•˜๋Š” ์ˆ˜๊ฐ€ ๊ฐ™์€ ๊ฒฝ์šฐ์—๋„ ์„œ๋กœ ๋‹ค๋ฅธ ๊ฒƒ์œผ๋กœ ๊ฐ„์ฃผํ•œ๋‹ค.

๋ฐฐ์—ด์˜ ํฌ๊ธฐ N, ์ˆซ์ž๊ฐ€ ๋”ํ•ด์ง€๋Š” ํšŸ์ˆ˜ M, ๊ทธ๋ฆฌ๊ณ  K๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ ๋™๋นˆ์ด์˜ ํฐ ์ˆ˜์˜ ๋ฒ•์น™์— ๋”ฐ๋ฅธ ๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅํ•˜์‹œ์˜ค.

ํ•ด์„ค

์ด ๋ฌธ์ œ๋Š” ์ „ํ˜•์ ์ธ ๊ทธ๋ฆฌ๋”” ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋‹ค. ์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋ ค๋ฉด ์ผ๋‹จ ์ž…๋ ฅ๊ฐ’ ์ค‘์—์„œ ๊ฐ€์žฅ ํฐ ์ˆ˜์™€ ๋‘ ๋ฒˆ์งธ๋กœ ํฐ ์ˆ˜๋งŒ ์ €์žฅํ•˜๋ฉด ๋œ๋‹ค. ์—ฐ์†์œผ๋กœ ๋”ํ•  ์ˆ˜ ์žˆ๋Š” ํšŸ์ˆ˜๋Š” ์ตœ๋Œ€ K๋ฒˆ์ด๋ฏ€๋กœ ๊ฐ€์žฅ ํฐ ์ˆ˜๋ฅผ K๋ฒˆ ๋”ํ•˜๊ณ  ๋‘ ๋ฒˆ์งธ๋กœ ํฐ ์ˆ˜๋ฅผ ํ•œ ๋ฒˆ ๋”ํ•˜๋Š” ์—ฐ์‚ฐ์„ ๋ฐ˜๋ณตํ•˜๋ฉด ๋œ๋‹ค.

์ฝ”๋“œ

n, m, k = map(int, input().split())
data = list(map(int, input().split()))

data.sort() # ์ •๋ ฌ
first = data[n-1]
second = data[n-2]

result = 0

while True :
    for i in range(k):
        if m == 0: break
        result += first
        m -= 1 # ๋”ํ•  ๋•Œ๋งˆ๋‹ค 1์”ฉ ๊ฐ์†Œ
    
    if m == 0: break # m์ด 0์ด๋ผ๋ฉด ๋ฐ˜๋ณต๋ฌธ ํƒˆ์ถœ
    result += second
    m -= 1  

์œ„ ์ฝ”๋“œ๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ ์ž…๋ ฅ ๊ฐ’์ด 100์–ต ์ด์ƒ์ด๋ผ๋ฉด ์‹œ๊ฐ„ ์ดˆ๊ณผ๊ฐ€ ๋œฐ ์ˆ˜ ์žˆ๋Š” ์ฝ”๋“œ์ด๋‹ค. ๊ฐ„๋‹จํ•œ ์ˆ˜ํ•™์  ์•„์ด๋””์–ด๋กœ ๋” ํšจ์œจ์ ์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ด๋ณด์ž.

๊ทธ๋Ÿฌ๊ธฐ ์œ„ํ•ด์„œ๋Š” ๊ฐ€์žฅ ๋จผ์ € ๋ฐ˜๋ณต๋˜๋Š” ์ˆ˜์—ด์— ๋Œ€ํ•ด ํŒŒ์•…ํ•ด์•ผ ํ•œ๋‹ค. ๋ฐ˜๋ณต๋˜๋Š” ์ˆ˜์—ด์˜ ๊ธธ์ด๋Š” M์„ K+1๋กœ ๋‚˜๋ˆˆ ๋ชซ์ด ๋œ๋‹ค. ๋‚˜๋ˆ„์–ด ๋–จ์–ด์ง€์ง€ ์•Š์„ ๋•Œ๋Š” ๊ฐ€์žฅ ํฐ ์ˆ˜๊ฐ€ ์ถ”๊ฐ€๋กœ ๋”ํ•ด์ง€๋ฏ€๋กœ ์ด๋ฅผ ๊ณ ๋ คํ•ด์ฃผ์–ด์•ผ ํ•œ๋‹ค.

int(M / (K + 1)) * K + M % (K + 1)

์œ„์˜ ์‹์„ ์ด์šฉํ•˜์—ฌ ๊ฐ€์žฅ ํฐ ์ˆ˜๊ฐ€ ๋”ํ•ด์ง€๋Š” ํšŸ์ˆ˜๋ฅผ ๊ตฌํ•˜๊ณ , ์ด๋ฅผ ์ด์šฉํ•ด ๋‘ ๋ฒˆ์งธ๋กœ ํฐ ์ˆ˜๊ฐ€ ๋”ํ•ด์ง€๋Š” ํšŸ์ˆ˜๊นŒ์ง€ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค.

๋” ํšจ์œจ์ ์ธ ์ฝ”๋“œ

n, m, k = map(int, input().split())
data = list(map(int, input().split()))

data.sort() # ์ •๋ ฌ
first = data[n-1]
second = data[n-2]

count = int(m / (k + 1)) * k + m % (k + 1)
count += m % (k + 1)
result = count * first + (m - count) * second

print(result)

3. ์ˆซ์ž ์นด๋“œ ๊ฒŒ์ž„

๋‚œ์ด๋„ ํ•˜

๋ฌธ์ œ

์ˆซ์ž ์นด๋“œ ๊ฒŒ์ž„์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ์ˆซ์ž ์นด๋“œ ์ค‘์—์„œ ๊ฐ€์žฅ ๋†’์€ ์ˆซ์ž๊ฐ€ ์“ฐ์ธ ์นด๋“œ ํ•œ ์žฅ์„ ๋ฝ‘๋Š” ๊ฒŒ์ž„์ด๋‹ค. ๋‹จ, ๊ฒŒ์ž„์˜ ๋ฃฐ์„ ์ง€ํ‚ค๋ฉฐ ์นด๋“œ๋ฅผ ๋ฝ‘์•„์•ผ ํ•˜๊ณ  ๋ฃฐ์€ ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

  1. ์ˆซ์ž๊ฐ€ ์“ฐ์ธ ์นด๋“œ๋“ค์ด N * M ํ˜•ํƒœ๋กœ ๋†“์—ฌ ์žˆ๋‹ค. ์ด๋•Œ N์€ ํ–‰์˜ ๊ฐœ์ˆ˜๋ฅผ ์˜๋ฏธํ•˜๋ฉฐ, M์€ ์—ด์˜ ๊ฐœ์ˆ˜๋ฅผ ์˜๋ฏธํ•œ๋‹ค.
  2. ๋จผ์ € ๋ฝ‘๊ณ ์ž ํ•˜๋Š” ์นด๋“œ๊ฐ€ ํฌํ•จ๋˜์–ด ์žˆ๋Š” ํ–‰์„ ์„ ํƒํ•œ๋‹ค.
  3. ๊ทธ ๋‹ค์Œ ์„ ํƒ๋œ ํ–‰์— ํฌํ•จ๋œ ์นด๋“œ๋“ค ์ค‘ ๊ฐ€์žฅ ์ˆซ์ž๊ฐ€ ๋‚ฎ์€ ์นด๋“œ๋ฅผ ๋ฝ‘์•„์•ผ ํ•œ๋‹ค.
  4. ๋”ฐ๋ผ์„œ ์ฒ˜์Œ์— ์นด๋“œ๋ฅผ ๊ณจ๋ผ๋‚ผ ํ–‰์„ ์„ ํƒํ•  ๋•Œ, ์ดํ›„์— ํ•ด๋‹น ํ–‰์—์„œ ๊ฐ€์žฅ ์ˆซ์ž๊ฐ€ ๋‚ฎ์€ ์นด๋“œ๋ฅผ ๋ฝ‘์„ ๊ฒƒ์„ ๊ณ ๋ คํ•˜์—ฌ ์ตœ์ข…์ ์œผ๋กœ ๊ฐ€์žฅ ๋†’์€ ์ˆซ์ž์˜ ์นด๋“œ๋ฅผ ๋ฝ‘์„ ์ˆ˜ ์žˆ๋„๋ก ์ „๋žต์„ ์„ธ์›Œ์•ผ ํ•œ๋‹ค.

์นด๋“œ๋“ค์ด N * M ํ˜•ํƒœ๋กœ ๋†“์—ฌ ์žˆ์„ ๋•Œ, ๊ฒŒ์ž„์˜ ๋ฃฐ์— ๋งž๊ฒŒ ์นด๋“œ๋ฅผ ๋ฝ‘๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“œ์‹œ์˜ค.

ํ•ด์„ค

์ด ๋ฌธ์ œ๋ฅผ ํ‘ธ๋Š” ์•„์ด๋””์–ด๋Š” ๊ฐ ํ–‰๋งˆ๋‹ค ๊ฐ€์žฅ ์ž‘์€ ์ˆ˜๋ฅผ ์ฐพ์€ ๋’ค์— ๊ทธ ์ˆ˜ ์ค‘์—์„œ ๊ฐ€์žฅ ํฐ ์ˆ˜๋ฅผ ์ฐพ๋Š” ๊ฒƒ์ด๋‹ค.

์ฝ”๋“œ

  • min() ํ•จ์ˆ˜๋ฅผ ์ด์šฉ
n, m = map(int, input().split())
result = 0

for i in range(n) :
    data = list(map(int, input().split()))
    min_value = min(data)
    result = max(result, min_value)

print(result)

4. 1์ด ๋  ๋•Œ๊นŒ์ง€

๋‚œ์ด๋„ ํ•˜

๋ฌธ์ œ

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

  1. N์—์„œ 1์„ ๋บ€๋‹ค.
  2. N์„ K๋กœ ๋‚˜๋ˆˆ๋‹ค.

N๊ณผ K๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ N์ด 1์ด ๋  ๋•Œ๊นŒ์ง€ 1๋ฒˆ ํ˜น์€ 2๋ฒˆ์˜ ๊ณผ์ •์„ ์ˆ˜ํ–‰ํ•ด์•ผ ํ•˜๋Š” ์ตœ์†Œ ํšŸ์ˆ˜๋ฅผ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

ํ•ด์„ค

์ฃผ์–ด์ง„ N์— ๋Œ€ํ•˜์—ฌ ์ตœ๋Œ€ํ•œ ๋งŽ์ด ๋‚˜๋ˆ„๊ธฐ๋ฅผ ์ˆ˜ํ–‰ํ•˜๋ฉด ๋œ๋‹ค. ์–ด๋– ํ•œ ์ˆ˜๊ฐ€ ์žˆ์„ ๋•Œ, 2 ์ด์ƒ์˜ ์ˆ˜๋กœ ๋‚˜๋ˆ„๋Š” ๊ฒƒ์ด 1์„ ๋นผ๋Š” ๊ฒƒ๋ณด๋‹ค ์ˆซ์ž๋ฅผ ํ›จ์”ฌ ๋งŽ์ด ์ค„์ผ ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

๋‹จ์ˆœํ•œ ์ •๋‹ต ์ฝ”๋“œ

n, k = map(int, input().split())
result = 0

while n >= k:
    while n % k != 0:
        n-= 1
        result += 1
    n //= k
    result += 1

while n > 1:
    n -= 1
    result += 1

print(result)

์ข€ ๋” ํšจ์œจ์ ์ธ ์ฝ”๋“œ

n, k = map(int, input().split())
result = 0

while True:
    target = (n // k) * k
    result += (n-target) # ๋‚˜๋จธ์ง€๊ฐ€ ์žˆ์–ด์„œ +1 ํ•˜๋Š” ํšŸ์ˆ˜
    n = target
    if n < k : break

    result += 1
    n //= k

result += (n-1)
print(result)

์ฐธ๊ณ ์ž๋ฃŒ : ์ด๊ฒƒ์ด ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ๋‹ค (๋‚˜๋™๋นˆ ์ €)