์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- 0์ด๋์ด์๋๊ธธ
- ์ด์งํ์
- URLSession
- IOS
- dfs
- concurrency
- algorithm
- ๊ณ ๋์ kit
- algoritm
- GCD
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- GroupBy
- ๊ธฐ์ด๋ฌธ๋ฒ
- ๋์ ๊ณํ๋ฒ
- APPJAM
- DynamicProgramming
- Swift
- HAVIT
- duno
- SwiftUI ํํ ๋ฆฌ์ผ
- binarySearch
- discardableResult
- SwiftUI
- BFS
- SQL
- ์ฐ์ํ์ค๋ถ๋ถ์์ด์ํฉ
- Til
- SOPT
- SwiftUI Tutorials
- ํ๋ก๊ทธ๋๋จธ์ค
- Today
- Total
suvera-dev ๐ฅฆ
Algorithm ) Greedy (2) ๋ณธ๋ฌธ
์ค์ ๋ฌธ์ ํ์ด
2๏ธโฃ ๋ฌธ์ 2 : ์ซ์ ์นด๋ ๊ฒ์
- ์ฌ๋ฌ ๊ฐ์ ์ซ์ ์นด๋ ์ค์์ ๊ฐ์ฅ ๋์ ์ซ์๊ฐ ์ฐ์ธ ์นด๋ ํ ์ฅ์ ๋ฝ๋ ๊ฒ์
- ๊ฒ์ ๋ฃฐ์ ๋ค์๊ณผ ๊ฐ๋ค.
- 1. ์ซ์๊ฐ ์ฐ์ธ ์นด๋๋ค์ด N x M ํํ๋ก ๋์ฌ ์๋ค. ์ด๋ N์ ํ์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ฉฐ, M์ ์ด์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ค.
- 2. ๋จผ์ ๋ฝ๊ณ ์ ํ๋ ์นด๋๊ฐ ํฌํจ๋์ด ์๋ ํ์ ์ ํํ๋ค
- 3. ๊ทธ ๋ค์ ์ ํ๋ ํ์ ํฌํจ๋ ์นด๋๋ค ์ค ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์์ผ ํ๋ค
- 4. ๋ฐ๋ผ์ ์ฒ์์ ์นด๋๋ฅผ ๊ณจ๋ผ๋ผ ํ์ ์ ํ ํ ๋, ์ดํ์ ํด๋น ํ์์ ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์ ๊ฒ์ ๊ณ ๋ คํ์ฌ ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ซ์์ ์นด๋๋ฅผ ๋ฝ์ ์ ์๋๋ก ์ ๋ต์ ์ธ์์ผ ํ๋ค.
๐ฅฆ ๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด : ๊ฐ ํ๋ง๋ค ๊ฐ์ฅ ์์ ์๋ฅผ ์ฐพ์ ๋ค์ ๊ทธ ์ ์ค์์ ๊ฐ์ฅ ํฐ ์๋ฅผ ์ฐพ๋ ๊ฒ
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)
# 2์ค ๋ฐ๋ณต๋ฌธ ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ ๋ต์ ์์
n, m = map(int, input().split())
result = 0
for i in range(n):
data = list(map(int, input().split()))
# ํ์ฌ ์ค์์ ๊ฐ์ฅ ์์ ์ ์ฐพ๊ธฐ
min_value = 10001
for a in data:
min_value = min(min_value, a)
result = max(result, min_value)
print(result)
3๏ธโฃ ๋ฌธ์ 3 : 1์ด ๋ ๋๊น์ง
์ด๋ ํ ์ N์ด 1์ด ๋ ๋๊น์ง ๋ค์์ ๋ ๊ณผ์ ์ค ํ๋๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์ ํํ์ฌ ์ํํ๋ ค๊ณ ํ๋ค.
๋จ, ๋ ๋ฒ์งธ ์ฐ์ฐ์ N์ด K๋ก ๋๋์ด๋จ์ด์ง ๋๋ง ์ ํํ ์ ์๋ค.
- N์์ 1์ ๋บ๋ค.
- N์ K๋ก ๋๋๋ค.
์๋ฅผ๋ค์ด, N์ด 17์ด๊ณ K๊ฐ 4๋ผ๊ณ ๊ฐ์ ํ์. ์ด๋ 1๋ฒ์ ๊ณผ์ ์ 1๋ฒ ์ํํ๋ฉด N์ 16์ด ๋๋ค.
์ดํ์ 2๋ฒ์ ๊ณผ์ ์ 2๋ฒ ์ํํ๋ฉด N์ 1์ด ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ์ด ๊ฒฝ์ฐ ์ ์ฒด ๊ณผ์ ์ ์คํํ ํ์๋ 3์ด ๋๋ค.
์ด๋ N์ 1๋ก ๋ง๋๋ ์ต์ ํ์์ด๋ค.
N๊ณผ K๊ฐ ์ฃผ์ด์ง ๋ N์ด 1์ด ๋ ๋๊น์ง 1๋ฒ ํน์ 2๋ฒ์ ๊ณผ์ ์ ์ํํด์ผํ๋ ์ต์ ํ์๋ฅผ ๊ตฌํ๊ธฐ
๐ฅฆ ๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด : ์ต๋ํ ๋ง์ด ๋๋๊ธฐ
- ์ด๋ ํ ์๊ฐ ์์ ๋ , 2์ด์์ ์๋ก ๋๋๋ ๊ฒ์ด 1์ ๋นผ๋ ๊ฒ๋ณด๋ค ์ซ์๋ฅผ ํจ์ฌ ๋ง์ด ์ค์ผ ์ ์์
n,k = map(int, input().split())
result = 0
# N์ด K์ด์์ด๋ผ๋ฉด K ๋ก ๊ณ์ ๋๋๊ธฐ
while n >= k:
# N์ด K๋ก ๋๋์ด ๋จ์ด์ง์ง ์๋ ๋ค๋ฉด N์์ 1์ฉ ๋นผ๊ธฐ
while n % k != 0:
n -= 1
result += 1
# K๋ก ๋๋๊ธฐ
n //= k
result += 1
# ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ
while n > 1:
n -= 1
result += 1
print(result)
# ๋ ํจ์จ์ ์ธ ํ์ด๋ฒ
n,k = map(int, input().split())
result = 0
while True:
# N ์ด K๋ก ๋๋์ด ๋จ์ด์ง๋ ์๊ฐ ๋ ๋๊น์ง 1์ฉ ๋นผ๊ธฐ
target = (n // k) * k
result += (n - target)
n = target
# N์ด k๋ณด๋ค ์์ ๋ (๋ ์ด์ ๋๋ ์ ์์ ๋) ๋ฐ๋ณต๋ฌธ ํ์ถ
if n < k:
break
# K๋ก ๋๋๊ธฐ
result += 1
n //= k
# ๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ
result += (n-1)
print(result)
- 2๋ฒ์งธ ํ์ด๋ฒ while๋ฌธ ์ค๋ช ์ถ๊ฐ !
- target ๊ฐ์ (n // k) * k ๋ผ๋ ๊ฐ์ ๋ฃ์ผ๋ฉด n์ด k๋ก ๋๋์ด ๋จ์ด์ง์ง ์๋๋ผ๋ ๊ฐ์ฅ ๊ฐ๊น์ด k๋ก ๋๋์ด ๋จ์ด์ง๋ ์๊ฐ ์ ์ฅ๋จ
- n์์ 1์ ๋นผ๋ ๊ณผ์ ์ ๋ช ๋ฒ ๋ฐ๋ณตํ ๊ฒ์ธ์ง ๊ณ์ฐํด์ result์ ์ ์ฅ
- ์ด์ n์ target์ด ๋๋ ๊ฒ -> n ์ด k๋ณด๋ค ์๋ค๋ฉด ๋ฐ๋ณต๋ฌธ ํ์ถ
- ์ดํ์ k๋ก ๋๋๊ธฐ !
'Algorithm > CodingTest - Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Algorithm) DFS/BFS ์ค์ ๋ฌธ์ (0) | 2022.04.02 |
---|---|
Algorithm) DFS/BFS (0) | 2022.04.02 |
Algorithm) ์๋ฃ๊ตฌ์กฐ ๊ธฐ์ด (Feat. DFS์ BFS์ ๋ค์ด๊ฐ๊ธฐ ์ ..) (1) | 2022.04.01 |
Algorithm ) Implementation (0) | 2022.04.01 |
Algorithm ) Greedy (0) | 2022.02.05 |