์ด๋ฒ ๊ธ์์๋ ๋ฐฑ์ค 14888๋ฒ ๋ฌธ์ ์ธ “์ฐ์ฐ์ ๋ผ์๋ฃ๊ธฐ”๋ฅผ ํจ๊ป ํด๊ฒฐํด ๋ณด๊ฒ ์ต๋๋ค. ์ด ๋ฌธ์ ๋ ์ฃผ์ด์ง ์๋ค๊ณผ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ค ์ ์๋ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๊ตฌํ๋ ๋ฌธ์ ์ ๋๋ค.
๋ฌธ์ URL : https://www.acmicpc.net/problem/14888
1. ๋ฌธ์ ์ค๋ช
1) ๋ฌธ์ ๊ฐ์
• ์ฌ๋ฌ ๊ฐ์ ์๊ฐ ์ฃผ์ด์ง๊ณ , ์ด ์๋ค ์ฌ์ด์ ์ฐ์ฐ์๋ฅผ ๋ผ์ ๋ฃ์ด์ผ ํฉ๋๋ค.
• ์ฌ์ฉํ ์ ์๋ ์ฐ์ฐ์๋ ๋ง์ , ๋บ์ , ๊ณฑ์ , ๋๋์ ์ ๋๋ค.
• ๋ชจ๋ ๊ฐ๋ฅํ ์ฐ์ฐ์ ์กฐํฉ์ ํ์ํ์ฌ ๋ง๋ค ์ ์๋ ๊ฒฐ๊ณผ์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ๊ตฌํฉ๋๋ค.
2) ์ ๋ ฅ
• ์ฒซ ๋ฒ์งธ ์ค์ ์์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋๋ค. (2 ≤ N ≤ 11)
• ๋ ๋ฒ์งธ ์ค์ N๊ฐ์ ์๊ฐ ์ฃผ์ด์ง๋๋ค. (1 ≤ ์ ≤ 100)
• ์ธ ๋ฒ์งธ ์ค์ ๋ง์ , ๋บ์ , ๊ณฑ์ , ๋๋์ ์ฐ์ฐ์์ ๊ฐ์๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋๋ค.
3) ์ถ๋ ฅ
• ๋ง๋ค ์ ์๋ ๊ฒฐ๊ณผ์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
2. ์ ๊ทผ๋ฒ
1) ์ ๋ ฅ๋ฐ๊ธฐ
• sys.stdin.readline์ ์ฌ์ฉํ์ฌ ์ ๋ ฅ ์๋๋ฅผ ๋์ ๋๋ค.
• ์ฒซ ๋ฒ์งธ ์ค์์ ์์ ๊ฐ์ N์ ์ ๋ ฅ๋ฐ์ต๋๋ค.
• ๋ ๋ฒ์งธ ์ค์์ N๊ฐ์ ์๋ฅผ ๋ฆฌ์คํธ๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค.
• ์ธ ๋ฒ์งธ ์ค์์ ๋ง์ , ๋บ์ , ๊ณฑ์ , ๋๋์ ์ฐ์ฐ์์ ๊ฐ์๋ฅผ ์ฐจ๋ก๋๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค.
2) ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ํ์
• ์ฌ๊ท ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ฐ๋ฅํ ์ฐ์ฐ์ ์กฐํฉ์ ํ์ํฉ๋๋ค.
• ๊ฐ ์ฐ์ฐ์์ ๋ํด ๋จ์ ์๋ ๊ฐ์๋ฅผ ํ์ธํ๊ณ , ์ฌ์ฉํ ์ ์๋ ๊ฒฝ์ฐ ์ฌ๊ท ํธ์ถ์ ํฉ๋๋ค.
• ์ฌ๊ท ํธ์ถ์ ํตํด ๋ชจ๋ ์๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ผ๋ก ๊ฐฑ์ ํฉ๋๋ค.
3. ์ ๋ต ์ฝ๋
import sys
input = sys.stdin.readline
# ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N์ ์
๋ ฅ๋ฐ์
N = int(input().strip())
# ๋์งธ ์ค์ N๊ฐ์ ์๋ฅผ ๋ฆฌ์คํธ๋ก ์
๋ ฅ๋ฐ์
arr = list(map(int, input().strip().split()))
# ์
์งธ ์ค์ ๋ง์
, ๋บ์
, ๊ณฑ์
, ๋๋์
์ฐ์ฐ์์ ๊ฐ์๋ฅผ ์
๋ ฅ๋ฐ์
A, B, C, D = map(int, input().strip().split())
# ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ณ์๋ค์ ์ด๊ธฐํ
maxAns = -1000000000 # ์ต๋๊ฐ์ ์ ์ฅํ ๋ณ์
minAns = 1000000000 # ์ต์๊ฐ์ ์ ์ฅํ ๋ณ์
# ์ฌ๊ท ํจ์๋ฅผ ์ ์ํ์ฌ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์
def rec(n, sm, a, b, c, d):
global maxAns
global minAns
if sm > 1000000000 or sm < -1000000000:
return
# ์ข
๋ฃ ์กฐ๊ฑด: ๋ชจ๋ ์๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ
if n == N:
maxAns = max(maxAns, sm) # ์ต๋๊ฐ ๊ฐฑ์
minAns = min(minAns, sm) # ์ต์๊ฐ ๊ฐฑ์
return
# ๊ฐ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์๋์ง ์ฒดํฌํ๊ณ , ์ฌ์ฉํ ์ ์์ผ๋ฉด ์ฌ๊ท ํธ์ถ
if a > 0: # ๋ง์
์ฐ์ฐ์๊ฐ ๋จ์ ์๋ ๊ฒฝ์ฐ
rec(n+1, sm+arr[n], a-1, b, c, d)
if b > 0: # ๋บ์
์ฐ์ฐ์๊ฐ ๋จ์ ์๋ ๊ฒฝ์ฐ
rec(n+1, sm-arr[n], a, b-1, c, d)
if c > 0: # ๊ณฑ์
์ฐ์ฐ์๊ฐ ๋จ์ ์๋ ๊ฒฝ์ฐ
rec(n+1, sm*arr[n], a, b, c-1, d)
if d > 0: # ๋๋์
์ฐ์ฐ์๊ฐ ๋จ์ ์๋ ๊ฒฝ์ฐ
rec(n+1, int(sm/arr[n]), a, b, c, d-1) # ๋๋์
์ ์ ์ ๋๋์
์ ์ฌ์ฉ
# ์ฌ๊ท ํจ์ ํธ์ถ์ ์์, ์ฒซ ๋ฒ์งธ ์๋ ์ด๋ฏธ ์ฌ์ฉํ ๊ฒ์ผ๋ก ์ฒ๋ฆฌ
rec(1, arr[0], A, B, C, D)
print(maxAns)
print(minAns)
4. ์ฝ๋ ์ค๋ช
1) ์ ๋ ฅ ๋ฐ๊ธฐ
• ์ฒซ์งธ ์ค์์ ์์ ๊ฐ์ N์ ์ ๋ ฅ๋ฐ์ต๋๋ค.
• ๋์งธ ์ค์์ N๊ฐ์ ์๋ฅผ ๋ฆฌ์คํธ๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค.
• ์ ์งธ ์ค์์ ๋ง์ , ๋บ์ , ๊ณฑ์ , ๋๋์ ์ฐ์ฐ์์ ๊ฐ์๋ฅผ ์ฐจ๋ก๋๋ก ์ ๋ ฅ๋ฐ์ต๋๋ค.
2) ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ํ์
• ์ฌ๊ท ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ฐ๋ฅํ ์ฐ์ฐ์ ์กฐํฉ์ ํ์ํฉ๋๋ค.
• ๊ฐ ์ฐ์ฐ์์ ๋ํด ๋จ์ ์๋ ๊ฐ์๋ฅผ ํ์ธํ๊ณ , ์ฌ์ฉํ ์ ์๋ ๊ฒฝ์ฐ ์ฌ๊ท ํธ์ถ์ ํฉ๋๋ค.
• ์ฌ๊ท ํธ์ถ์ ํตํด ๋ชจ๋ ์๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ผ๋ก ๊ฐฑ์ ํฉ๋๋ค.
3) ๊ฒฐ๊ณผ ์ถ๋ ฅ
• ์ต์ข ์ ์ผ๋ก ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
3) ์์์ ์๊ฐ์ ์ค๋ช
์์
์๋ฅผ ๋ค์ด, ์๋์๊ฐ์ด ์ ๋ ฅ๊ฐ์ด ์ฃผ์ด์ง๋ค๊ณ ์๊ฐํ๊ณ ์งํ์ ํด๋ณด๊ฒ ์ต๋๋ค.
N = 3
arr = [3, 4, 5]
A = 1
B = 0
C = 1
D = 0
์ด ๊ฒฝ์ฐ, ๊ฐ๋ฅํ ์ฐ์ฐ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
• 3 + 4 * 5
• 3 * 4 + 5
์ฒซ ๋ฒ์งธ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ 23์ด๊ณ , ๋ ๋ฒ์งธ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ 17์ ๋๋ค. ๋ฐ๋ผ์ ์ต๋๊ฐ์ 23์ด๊ณ ์ต์๊ฐ์ 17์ด ๋ฉ๋๋ค.
์๊ฐ์ ์ค๋ช
์ฌ๊ท ํจ์ rec์ ํธ์ถ ํ๋ฆ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค
rec(1, 3, 1, 0, 1, 0)
โโโ rec(2, 7, 0, 0, 1, 0) # 3 + 4
โ โโโ rec(3, 35, 0, 0, 0, 0) # 7 * 5
โโโ rec(2, 12, 1, 0, 0, 0) # 3 * 4
โโโ rec(3, 17, 0, 0, 0, 0) # 12 + 5
์ด ํ๋ฆ์ ํตํด ๋ชจ๋ ๊ฐ๋ฅํ ์ฐ์ฐ ์กฐํฉ์ ํ์ํ์ฌ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐพ์ต๋๋ค.
5. Github์ผ๋ก ํ์ธ
'๐ ์๊ณ ๋ฆฌ์ฆ > BOJ(๋ฐฑ์ค)_Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
BOJ(๋ฐฑ์ค) 14503[๋ก๋ด ์ฒญ์๊ธฐ] (0) | 2024.07.16 |
---|---|
BOJ(๋ฐฑ์ค) 5567[๊ฒฐํผ์] (0) | 2024.07.12 |
BOJ(๋ฐฑ์ค) 13458[์ํ ๊ฐ๋ ] (0) | 2024.07.10 |
BOJ(๋ฐฑ์ค) 14889[์คํํธ์ ๋งํฌ] (0) | 2024.07.09 |
BOJ(๋ฐฑ์ค) 2606[๋ฐ์ด๋ฌ์ค] (0) | 2024.07.08 |