๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ - ์ซ์ ์นด๋ ๊ฒ์
์ซ์ ์นด๋ ๊ฒ์์ ํ ์ข ๋ฅ๋ก์, ์ฌ๋ฌ ๊ฐ์ ์ซ์ ์นด๋ ์ค์์ ๊ฐ์ฅ ๋์ ์ซ์๊ฐ ์ฐ์ธ ์นด๋ ํ ์ฅ์ ๋ฝ๋ ๊ฒ์์ด๋ค.
๊ฒ์์ ๋ฃฐ์ ๋ค์๊ณผ ๊ฐ๋ค.
1. ์ซ์๊ฐ ์ฐ์ธ ์นด๋๋ค์ด n x m ํํ๋ก ๋์ฌ์ ธ ์์ผ๋ฉฐ, ์ด๋ n์ ํ์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ฉฐ, m์ ์ด์ ๊ฐ์๋ฅผ ์๋ฏธํ๋ค
2. ๋จผ์ ๋ฝ๊ณ ์ ํ๋ ์นด๋๊ฐ ํฌํจ๋์ด ์๋ ํ์ ์ ํํ๋ค.
3. ๊ทธ๋ค์ ์ ํ๋ ํ์ ํฌํจ๋ ์นด๋๋ค ์ค ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์์ผ ํ๋ค.
4. ๋ฐ๋ผ์ ์ฒ์์ ์นด๋๋ฅผ ๊ณจ๋ผ๋ผ ํ์ ์ ํํ ๋, ์ดํ์ ํด๋น ํ์์ ๊ฐ์ฅ ์ซ์๊ฐ ๋ฎ์ ์นด๋๋ฅผ ๋ฝ์ ๊ฒ์ ๊ณ ๋ คํ์ฌ ์ต์ข ์ ์ผ๋ก ๊ฐ์ฅ ๋์ ์ซ์์ ์นด๋๋ฅผ ๋ฝ์ ์ ์๋๋ก ์ ๋ต์ ์ธ์์ผํ๋ค.
์ฆ, ๊ฐ ํ์ ์ซ์์์ ๊ฐ์ฅ ์์ ๊ฐ๋ค ์ค์์, ๊ฐ์ฅ ํฐ ์๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ ๊ฒ์์ด๋ค.
์๋ฅผ ๋ค์ด,
3 1 2
5 1 3
3 3 3
m์ 3(์ด) ์ด๊ณ , n์ 3(ํ) ์ด๋ผ๊ณ ํ์.
์ฌ๊ธฐ์ ์นด๋๋ฅผ ๊ณจ๋ผ๋ผ ํ์ ๊ณ ๋ฅผ ๋ ์ฒซ ๋ฒ์งธ ํน์ ๋ ๋ฒ์งธ ํ์ ์ ํํ๋ ๊ฒฝ์ฐ, ์ต์ข ์ ์ผ๋ก ๋ฝ๋ ์นด๋๋ 1์ด๋ค. ํ์ง๋ง ์ธ ๋ฒ์งธ ํ์ ์ ํํ๋ ๊ฒฝ์ฐ ์ต์ข ์ ์ผ๋ก ๋ฝ๋ ์นด๋๋ 3์ด๋ค. ๋ฐ๋ผ์ ๋ค์ ์์์์๋ ์ธ ๋ฒ์งธ ํด์ ์ ํํ์ฌ ์ซ์ 3์ด ์ฐ์ฌ์ง ์นด๋๋ฅผ ๋ฝ๋ ๊ฒ์ด ์ ๋ต์ด๋ค.
์ฌ๊ธฐ์ ์ฌ์ฉํด์ผ๋ ํจ์๋ ๋ฆฌ์คํธ์์ ๊ฐ์ฅ ์์ ์์๋ฅผ ์ฐพ์์ฃผ๋ min() ํจ์์ด๋ค. ๋ํ 2์ค ๋ฐ๋ณต๋ฌธ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ค. ๊ตฌ๊ตฌ๋จ๊ณผ ์ ์ฌํ๋๊น ์ฐธ์กฐํ์.
min ํจ์
1) ์๋ฃํ์ ๋๋ฑํ๊ฒ ๋๊ธฐ
e = [3, 'a', 'b', 'c']
>> print(min(e)) # error : str ํ์ ๊ณผ int ํ์ ์ ๋น๊ตํ ์ ์๊ธฐ ๋๋ฌธ
2) ๋ฌธ์ํ์์๋ ๊ฐ๋ฅ
b = 'BlockDMask' print(min(b))
>> ๋ฐํ : 'B'
3) ์ฌ๋ฌ ๋ฆฌ์คํธ์์๋ ์ฌ์ฉ ๊ฐ๋ฅ
# min(arg1, arg2) ํจ์
a = [1, 2, 3] b = [4, 5, 6] print(min(a, b))
>> ๋ฐํ : [1,2,3]
4) ๋ฌธ์์ด 2๊ฐ ์ด์์์๋ ์ฌ์ฉ ๊ฐ๋ฅ
# min(arg1, arg2) ํจ์
c = 'BlockDMask'
d = 'BAAAlockDMask' print(min(c, d))
>> ๋ฐํ : 'B'
5) ํํ์์๋ ์ฌ์ฉ ๊ฐ๋ฅ
# min(iterable) ํจ์
d = (6, 5, 4, 2) print(min(d))
>> ๋ฐํ : 2
์ ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ซ์ ์นด๋๋ค์ด ๋์ธ ํ์ ๊ฐ์ n๊ณผ ์ด์ ๊ฐ์ m์ด ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ํ์ฌ ๊ฐ๊ฐ ์์ฐ์๋ก ์ฃผ์ด์ง๋ค
( 1 <= N, M <= 100 )
- ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑธ์ณ ๊ฐ ์นด๋์ ์ ํ ์ซ์๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์ซ์๋ 1 ์ด์ 10,000 ์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๊ฒ์์ ๋ฃฐ์ ๋ง๊ฒ ์ ํํ ์นด๋์ ์ ํ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ ์์ 1
3 3
3 1 2
5 1 5
2 2 2
์ถ๋ ฅ ์์ 1
2
์ ๋ ฅ ์์ 2
2 4
8 3 1 8
3 3 3 5
์ถ๋ ฅ ์์ 3
3
์ฒซ๋ฒ์งธ ์ฝ๋
๋๋ฒ์งธ ์ฝ๋
2. ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ - 1์ด ๋ ๋๊น์ง
์ด๋ค ์ n์ด 1์ด ๋ ๋๊น์ง, ๋ค์์ ๋ ๊ณผ์ ์ค ํ๋๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์ ํํ์ฌ ์ํํจ
๋๋ฒ์งธ ์ฐ์ฐ์ n์ด k๋ก ๋๋์ด๋จ์ด์ง ๋๋ง ์ ํ ๊ฐ๋ฅํจ
1. n์์ 1์ ๋บ๋ค
2. n์ k๋ก ๋๋
n์ด 13์ด๊ณ k๊ฐ 4๋ผ๊ณ ํ๋ฉด, 1๋ฒ์ ๊ณผ์ ์ ํตํด 12๊ฐ ๋๊ณ , 2๋ฒ์ ๊ณผ์ ์ ํตํด 3์ด ๋๊ณ , 1๋ฒ์ ๊ณผ์ ์ 2๋ฒ ๊ฑฐ์น๋ฉด 1์ด ๋๋ค.
์ฆ, 1๋ฒx1 + 2๋ฒx1 +1๋ฒx2 ์ผ๋ก ์ด 4๋ฒ ๋ฐ๋ณตํ๊ฒ ๋๋ค.
์ฆ ๋ค์๊ณผ ๊ฐ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ง์ผํ๋ค.
k๋ก ๋๋์ด ๋จ์ด์ง๋์ง or k๋ก ๋๋์ด๋จ์ด์ง์ง ์๋์ง์ ๋ฐ๋ผ, ์ฒ์์ 1์ ๋นผ์ฃผ๋ ๊ณผ์ ์ด ๋จผ์ ์คํ์ด ๋๋ค.
์ ๋ ฅ ์กฐ๊ฑด : ์ฒซ์งธ ์ค์ n(2๋ณด๋ค ํฌ๊ณ 100,000 ๋ณด๋ค ์์ ์)์ k(2๋ณด๋ค ํฌ๊ณ 100,000 ๋ณด๋ค ์์ ์)๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋๋ฉฐ, ๊ฐ๊ฐ ์์ฐ์๋ก ์ฃผ์ด์ง๋ค. ์ด๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ n์ ํญ์ k๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๋ค.
์ถ๋ ฅ ์กฐ๊ฑด : ์ฒซ์งธ ์ค์ n์ด 1์ด ๋ ๋๊น์ง 1๋ฒ ํน์ 2๋ฒ์ ๊ณผ์ ์ ์ํํด์ผ ํ๋ ํ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
25 5 => 2
10 7 => 4
n, k = map(int, input().split())
result = 0
# N์ด K ์ด์์ด๋ผ๋ฉด K๋ก ๊ณ์ ๋๋๊ธฐ 10 3
while n >= k:
# ํฌ๊ฒ 2๊ฐ์ง๋ก ๋๋ ์ ์์ : k๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฒฝ์ฐ or ์๋ ๊ฒฝ์ฐ
# N ์ด K๋ก ๋๋์ด ๋จ์ด์ง์ง ์๋๋ค๋ฉด N์์ 1์ฉ ๋นผ๊ธฐ
while n % k != 0:
n -= 1
result += 1
# k ๋ก ๋๋ ์ ์๋ ๊ฒฝ์ฐ
n //= k
result += 1
# n ์ด k๋ณด๋ค ์์์ง๋๋, 1์ฉ ๋นผ์ฃผ๋ ์นด์ดํธ
while n > 1:
n -= 1
result += 1
print(result)
(Solution1)
while๋ฌธ 2๊ฐ ์ฌ์ฉํ๊ธฐ
์์ ์์ฒ๋ผ ํ ์๋ ์๊ณ , ๋น์ทํ์ง๋ง ๋ค๋ฅธ ํ์ด๋ ์กด์ฌํ๋ค.
(Solution2)
while๋ฌธ 1๊ฐ ์ฌ์ฉํ๊ธฐ
# n,k๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์
๋ ฅ๋ฐ๊ธฐ
n, k = map(int, input().split())
result = 0
while True:
# (n==k ๋ก ๋๋์ด ๋จ์ด์ง๋ ์)๊ฐ ๋ ๋๊น์ง 1์ฉ ๋นผ๊ธฐ 10 4... 17 3
target = (n // k) * k # 8
result += (n - target) # 10 - 8 = 2
n = target # 8
# n์ด k๋ณด๋ค ์์ ๋(๋ ์ด์ ๋๋ ์ ์์ ๋) ๋ฐ๋ณต๋ฌธ ํ์ถ
if n < k:
break
# k๋ก ๋๋๊ธฐ
n //= k # n์ 2
result += 1
#๋ง์ง๋ง์ผ๋ก ๋จ์ ์์ ๋ํ์ฌ 1์ฉ ๋นผ๊ธฐ
result += (n-1) # for๋ฌธ์ ๋๋ฆฌ์ง ์๊ณ ๋ ํ์๋๊น, ๋ค์๊ณผ ๊ฐ์ด ํํ(n-1)
print(result)
'๐๏ธ์ํํธ์จ์ด > ๐ปpython' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 2ํ:์๊ฐ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.20 |
---|---|
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 1ํ:์ํ์ข์ฐ (0) | 2022.04.20 |
Python - ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋ณตํ๊ธฐ 1ํ (0) | 2022.04.18 |
[๋ฐฑ์ค] 10870๋ฒ. ํผ๋ ธ๋์น์ ์ฐพ๊ธฐ(์ฌ๊ท) & ๋ธ๋ฃจํธํฌ์ค - 2798๋ฒ. ๋ธ๋์ญ (0) | 2022.04.08 |
[๋ฐฑ์ค] 1978๋ฒ. ์์ ์ฐพ๊ธฐ (0) | 2022.04.08 |