์ฌ์ ๋ก์์ ธ์! ์ ๋ฒ์ ๋ชป ์ฝ์ ์๋ถ๋ถ๋ ์ฝ์ด๋ณด๋ ค๊ณ ํ๋ค ํํ ๐
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. ์ซ์ ์นด๋ ๊ฒ์
๋์ด๋ ํ
๋ฌธ์
์ซ์ ์นด๋ ๊ฒ์์ ์ฌ๋ฌ ๊ฐ์ ์ซ์ ์นด๋ ์ค์์ ๊ฐ์ฅ ๋์ ์ซ์๊ฐ ์ฐ์ธ ์นด๋ ํ ์ฅ์ ๋ฝ๋ ๊ฒ์์ด๋ค. ๋จ, ๊ฒ์์ ๋ฃฐ์ ์งํค๋ฉฐ ์นด๋๋ฅผ ๋ฝ์์ผ ํ๊ณ ๋ฃฐ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์ซ์๊ฐ ์ฐ์ธ ์นด๋๋ค์ด N * M ํํ๋ก ๋์ฌ ์๋ค. ์ด๋ N์ ํ์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ฉฐ, M์ ์ด์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ค.
- ๋จผ์ ๋ฝ๊ณ ์ ํ๋ ์นด๋๊ฐ ํฌํจ๋์ด ์๋ ํ์ ์ ํํ๋ค.
- ๊ทธ ๋ค์ ์ ํ๋ ํ์ ํฌํจ๋ ์นด๋๋ค ์ค ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์์ผ ํ๋ค.
- ๋ฐ๋ผ์ ์ฒ์์ ์นด๋๋ฅผ ๊ณจ๋ผ๋ผ ํ์ ์ ํํ ๋, ์ดํ์ ํด๋น ํ์์ ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์ ๊ฒ์ ๊ณ ๋ คํ์ฌ ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ซ์์ ์นด๋๋ฅผ ๋ฝ์ ์ ์๋๋ก ์ ๋ต์ ์ธ์์ผ ํ๋ค.
์นด๋๋ค์ด 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๋ก ๋๋์ด๋จ์ด์ง ๋๋ง ์ ํํ ์ ์๋ค.
- N์์ 1์ ๋บ๋ค.
- 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)
์ฐธ๊ณ ์๋ฃ : ์ด๊ฒ์ด ์ฝ๋ฉ ํ ์คํธ๋ค (๋๋๋น ์ )