2021. 4. 14. 18:48ใ๐ Algorithm/๐ช๐ป Python ๋ฌธ์ ํ์ด
๋ฌธ์ ์ค๋ช
N๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ง ์์ด A1, A2, ..., AN์ด ์ฃผ์ด์ง๋ค. ๋, ์์ ์ ์ฌ์ด์ ๋ผ์๋ฃ์ ์ ์๋ N-1๊ฐ์ ์ฐ์ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ์ฐ์ฐ์๋ ๋ง์ (+), ๋บ์ (-), ๊ณฑ์ (×), ๋๋์ (÷)์ผ๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ค.
์ฐ๋ฆฌ๋ ์์ ์ ์ฌ์ด์ ์ฐ์ฐ์๋ฅผ ํ๋์ฉ ๋ฃ์ด์, ์์์ ํ๋ ๋ง๋ค ์ ์๋ค. ์ด๋, ์ฃผ์ด์ง ์์ ์์๋ฅผ ๋ฐ๊พธ๋ฉด ์ ๋๋ค.
์๋ฅผ ๋ค์ด, 6๊ฐ์ ์๋ก ์ด๋ฃจ์ด์ง ์์ด์ด 1, 2, 3, 4, 5, 6์ด๊ณ , ์ฃผ์ด์ง ์ฐ์ฐ์๊ฐ ๋ง์ (+) 2๊ฐ, ๋บ์ (-) 1๊ฐ, ๊ณฑ์ (×) 1๊ฐ, ๋๋์ (÷) 1๊ฐ์ธ ๊ฒฝ์ฐ์๋ ์ด 60๊ฐ์ง์ ์์ ๋ง๋ค ์ ์๋ค. ์๋ฅผ ๋ค์ด, ์๋์ ๊ฐ์ ์์ ๋ง๋ค ์ ์๋ค.
- 1+2+3-4×5÷6
- 1÷2+3+4-5×6
- 1+2÷3×4-5+6
- 1÷2×3-4+5+6
์์ ๊ณ์ฐ์ ์ฐ์ฐ์ ์ฐ์ ์์๋ฅผ ๋ฌด์ํ๊ณ ์์์๋ถํฐ ์งํํด์ผ ํ๋ค. ๋, ๋๋์ ์ ์ ์ ๋๋์ ์ผ๋ก ๋ชซ๋ง ์ทจํ๋ค. ์์๋ฅผ ์์๋ก ๋๋ ๋๋ C++14์ ๊ธฐ์ค์ ๋ฐ๋ฅธ๋ค. ์ฆ, ์์๋ก ๋ฐ๊พผ ๋ค ๋ชซ์ ์ทจํ๊ณ , ๊ทธ ๋ชซ์ ์์๋ก ๋ฐ๊พผ ๊ฒ๊ณผ ๊ฐ๋ค. ์ด์ ๋ฐ๋ผ์, ์์ ์ 4๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ๊ณ์ฐํด๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
- 1+2+3-4×5÷6 = 1
- 1÷2+3+4-5×6 = 12
- 1+2÷3×4-5+6 = 5
- 1÷2×3-4+5+6 = 7
N๊ฐ์ ์์ N-1๊ฐ์ ์ฐ์ฐ์๊ฐ ์ฃผ์ด์ก์ ๋, ๋ง๋ค ์ ์๋ ์์ ๊ฒฐ๊ณผ๊ฐ ์ต๋์ธ ๊ฒ๊ณผ ์ต์์ธ ๊ฒ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅํ์
์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(2 ≤ N ≤ 11)๊ฐ ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ A1, A2, ..., AN์ด ์ฃผ์ด์ง๋ค. (1 ≤ Ai ≤ 100) ์ ์งธ ์ค์๋ ํฉ์ด N-1์ธ 4๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ฐจ๋ก๋๋ก ๋ง์ (+)์ ๊ฐ์, ๋บ์ (-)์ ๊ฐ์, ๊ณฑ์ (×)์ ๊ฐ์, ๋๋์ (÷)์ ๊ฐ์์ด๋ค.
์ถ๋ ฅํ์
์ฒซ์งธ ์ค์ ๋ง๋ค ์ ์๋ ์์ ๊ฒฐ๊ณผ์ ์ต๋๊ฐ์, ๋์งธ ์ค์๋ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค. ์ฐ์ฐ์๋ฅผ ์ด๋ป๊ฒ ๋ผ์๋ฃ์ด๋ ํญ์ -10์ต๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10์ต๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์ค๋ ์ ๋ ฅ๋ง ์ฃผ์ด์ง๋ค. ๋ํ, ์์์๋ถํฐ ๊ณ์ฐํ์ ๋, ์ค๊ฐ์ ๊ณ์ฐ๋๋ ์์ ๊ฒฐ๊ณผ๋ ํญ์ -10์ต๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10์ต๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ ์ถ๋ ฅ ์์
ํ์ด ๊ณผ์
๋ฐฑํธ๋ ํน ๋ฌธ์ ๋ฅผ ๊ทธ ์ ์ ๋ง์ด ํ์์ด์ ์ฝ๊ฒ ํ ์ ์์๋ค.
backtracking ํ ๋ plus,minus, multi, div ๊ฐฏ์๊ฐ ์กด์ฌํ๋ฉด ๋ชจ๋ ์คํํด์ค์ min, max๋ฅผ ๊ตฌํ๋ฉด ๋๋ ๋ฌธ์ ์๋ค.
์ด๋ ์กฐ์ฌํด์ผ๋ ๋ถ๋ถ์ ๋๋๊ธฐ ํ ๋ ์ด์ ํฉ๊ณ (sum_value)๊ฐ์ด 0๋ณด๋ค ์๋ค๋ฉด -๋ฅผ ๋ถ์ธ ๋ค์์ ๋๋๊ธฐ ํ -๋ฅผ ๋ค์ ๋ถ์ฌ์ค์ผํ๋ค!
def backtracking(cnt,sum_value, plus, minus, mul, div):
global min_value, max_value
if cnt == n:
min_value = min(min_value,sum_value)
max_value = max(max_value, sum_value)
return
if plus > 0:
backtracking(cnt+1, sum_value+value[cnt], plus-1, minus, mul, div)
if minus > 0:
backtracking(cnt+1, sum_value-value[cnt], plus,minus-1, mul, div)
if mul > 0:
backtracking(cnt+1, sum_value*value[cnt], plus,minus, mul-1, div)
if div > 0:
if sum_value >= 0:
backtracking(cnt+1, sum_value//value[cnt], plus,minus, mul, div-1)
else:
backtracking(cnt+1, -(-sum_value//value[cnt]),plus,minus,mul, div-1)
if __name__ == '__main__':
n = int(input())
value = list(map(int,input().split()))
plus, minus, multi, div = map(int, input().split())
max_value = float('-inf')
min_value = float('inf')
backtracking(1,value[0], plus, minus,multi, div)
print(max_value)
print(min_value)
'๐ Algorithm > ๐ช๐ป Python ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python - ๋ฐฑ์ค 1697] ์จ๋ฐ๊ผญ์ง (0) | 2021.04.15 |
---|---|
[Python - ๋ฐฑ์ค 2529] ๋ถ๋ฑํธ (0) | 2021.04.14 |
[Python - ๋ฐฑ์ค 14889] ์คํํธ์ ๋งํฌ (0) | 2021.04.14 |