[1] ์ ๋ต ์ฝ๋
import sys
n = int(sys.stdin.readline())
weight = list(map(int, sys.stdin.readline().split()))
m = int(sys.stdin.readline())
check = list(map(int, sys.stdin.readline().split()))
possible = []
ans = [[0 for _ in range(15001)] for __ in range(n + 1)]
def scale(weight, n, now, left, right):
new = abs(left - right)
if new not in possible:
possible.append(new)
if now == n:
return 0
if ans[now][new] == 0:
scale(weight, n, now + 1, left + weight[now], right)
scale(weight, n, now + 1, left, right + weight[now])
scale(weight, n, now + 1, left, right)
ans[now][new] = 1
scale(weight, n, 0, 0, 0)
for i in check:
if i in possible:
print('Y', end=' ')
else:
print('N', end=' ')
[2] ์ค๋ช
import sys
n = int(sys.stdin.readline())
weight = list(map(int, sys.stdin.readline().split()))
m = int(sys.stdin.readline())
check = list(map(int, sys.stdin.readline().split()))
possible = []
ans = [[0 for _ in range(15001)] for __ in range(n + 1)]
1. n = int(sys.stdin.readline()): ์ฒซ ๋ฒ์งธ ์ค์์ ์ ์๋ฅผ ์ฝ์ด๋ค์ฌ ๋ณ์ n์ ํ ๋นํ๋ค. n์ ์ถ์ ๊ฐ์๋ฅผ ๋ํ๋ธ๋ค.
2. weight = list(map(int, sys.stdin.readline().split())): ๋ค์ ์ค์์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ์ ์๋ฅผ ์ฝ์ด๋ค์ฌ ๋ฆฌ์คํธ weight์ ์ ์ฅํ๋ค. weight๋ ๊ฐ ์ถ์ ๋ฌด๊ฒ๋ฅผ ์๋ฏธํ๋ค.
3. m = int(sys.stdin.readline()): ๊ทธ ๋ค์ ์ค์์๋ ๋ ๋ค๋ฅธ ์ ์๋ฅผ ์ฝ์ด๋ค์ฌ ๋ณ์ m์ ํ ๋นํ๋ค. ์ด ๊ฐ์ ํ์ธํ ๋ฌด๊ฒ๋ค์ ๊ฐ์๋ฅผ ๋ํ๋ธ๋ค.
4. check = list(map(int, sys.stdin.readline().split())): ๊ทธ ๋ค์ ์ค์์๋ ๋ค์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋ ์ ์๋ฅผ ์ฝ์ด๋ค์ฌ ๋ฆฌ์คํธ check์ ์ ์ฅํ๋ค. ์ด๋ ํ์ธํ ๋ฌด๊ฒ๋ค์ ๋ํ๋ธ๋ค.
5. possible = []: ๊ฐ๋ฅํ ๋ชจ๋ ์กฐํฉ์ ์ ์ฅํ ๋น ๋ฆฌ์คํธ possible์ ์ด๊ธฐํํ๋ค.
6. ans = [[0 for _ in range(15001)] for __ in range(n + 1)]: ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ธฐ๋กํ ์ด์ค ๋ฆฌ์คํธ ans๋ฅผ ์ด๊ธฐํํ๋ค. ์ด ์ด์ค ๋ฆฌ์คํธ์ ํฌ๊ธฐ๋ (n+1) × 15001์ด๋ค.
sys.stdin.readline() ํจ์
sys.stdin.readline() ํจ์๋ Python์ sys ๋ชจ๋์์ ์ ๊ณต๋๋ ํจ์๋ก, ํ์ค ์
๋ ฅ์์ ํ ์ค์ ์ฝ์ด๋ค์ธ๋ค. ์ด ํจ์๋ ํ์ค ์
๋ ฅ(stdin)์์ ๋ฌธ์์ด์ ์ฝ์ด๋ค์ฌ ๋ฐํํ๋ค.
๋ณดํต ํ์ผ ๊ฐ์ฒด์์ ์ฌ์ฉ๋๋ readline() ๋ฉ์๋์ ์ ์ฌํ์ง๋ง, ์ด ํจ์๋ ํ์ผ์ด ์๋ ํ์ค ์
๋ ฅ(stdin)์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด๋ค์ธ๋ค. ํ์ค ์
๋ ฅ(stdin)์ ๋ณดํต ํฐ๋ฏธ๋์์ ์ฌ์ฉ์๋ก๋ถํฐ ์
๋ ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์๋ฏธํ๋ค.
์๋ฅผ ๋ค์ด, ํฐ๋ฏธ๋์์ ์ฌ์ฉ์๋ก๋ถํฐ ๋ฌธ์์ด์ ์
๋ ฅ๋ฐ์ ์ฒ๋ฆฌํ๊ณ ์ ํ ๋, sys.stdin.readline()์ ์ฌ์ฉํ์ฌ ์
๋ ฅ์ ์ฝ์ด๋ค์ผ ์ ์๋ค. ์ด ํจ์๋ ๊ฐํ ๋ฌธ์('\n')๋ฅผ ํฌํจํ ๋ฌธ์์ด์ ๋ฐํํ๋ฏ๋ก, ํ์์ ๋ฐ๋ผ ๋ฌธ์์ด์ ์ฒ๋ฆฌํ ๋ ์ด๋ฅผ ์ ๊ฑฐํ๋ ๋ฑ์ ์์
์ ์ถ๊ฐ๋ก ์ํํด์ผ ํ ์ ์๋ค.
์๋ฅผ ๋ค์ด,
import sys
# ํ์ค ์
๋ ฅ์์ ํ ์ค์ ์ฝ์ด๋ค์
input_str = sys.stdin.readline()
# ๊ฐํ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ ๋ฌธ์์ด์ ์ถ๋ ฅ
print(input_str.strip())
์ด ์ฝ๋๋ ํ์ค ์ ๋ ฅ์์ ํ ์ค์ ์ฝ์ด๋ค์ฌ ๋ณ์ input_str์ ์ ์ฅํ ํ, strip() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด์ ์์ชฝ ๊ณต๋ฐฑ๊ณผ ๊ฐํ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ ํ ์ถ๋ ฅํ๋ค.
์ด์ค ๋ฆฌ์คํธ
์ด์ค ๋ฆฌ์คํธ๋ ๋ฆฌ์คํธ ์์ ๋ฆฌ์คํธ๊ฐ ํฌํจ๋ ํํ๋ฅผ ๋งํ๋ค. ์ฆ, ๋ฆฌ์คํธ์ ์์๋ก์ ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค. ์ด๋ฅผ ํตํด ๋ค์ฐจ์์ ๋ฐ์ดํฐ๋ฅผ ํํํ ์ ์๋ค.
์๋ฅผ ๋ค์ด, ์ด์ฐจ์ ๋ฐฐ์ด์ด๋ ํ๋ ฌ์ ํํํ ๋ ์ฌ์ฉ๋๋ค. ์ด์ค ๋ฆฌ์คํธ์ ๊ฐ ์์๋ ๋ค๋ฅธ ๋ฆฌ์คํธ์ด๋ฏ๋ก, ์ด๋ฅผ ํตํด ๊ฐ ํ๊ณผ ์ด์ ์์์ ์ ๊ทผํ ์ ์๋ค.
๋ค์์ ์ด์ค ๋ฆฌ์คํธ์ ์์์ด๋ค.
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
์์ ์์์์ matrix๋ ์ด์ค ๋ฆฌ์คํธ์ด๋ฉฐ, ๊ฐ ์์๋ ๋ค๋ฅธ ๋ฆฌ์คํธ์ด๋ค.
์ฒซ ๋ฒ์งธ ์์ matrix[0]๋ [1, 2, 3]์ด๊ณ , ๋ ๋ฒ์งธ ์์ matrix[1]๋ [4, 5, 6]์ด๋ค. ๋ฐ๋ผ์ matrix[ํ][์ด]์ ํํ๋ก ๊ฐ ์์์ ์ ๊ทผํ ์ ์๋ค.
์ด์ค ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ๋ฅผ ํ๋ ฌ ํํ๋ก ํํํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋๋ฉฐ, ๋ค์ฐจ์์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ํจ๊ณผ์ ์ด๋ค. ์๋ฅผ ๋ค์ด, ์ด๋ฏธ์ง๋ ๋น๋์ค ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ๊ฐ ํฝ์
์ ์์ ๊ฐ์ ์ด์ค ๋ฆฌ์คํธ๋ก ํํํ๋ ๋ฑ์ ํ์ฉ์ด ๊ฐ๋ฅํ๋ค.
def scale(weight, n, now, left, right):
new = abs(left - right)
if new not in possible:
possible.append(new)
if now == n:
return 0
if ans[now][new] == 0:
scale(weight, n, now + 1, left + weight[now], right)
scale(weight, n, now + 1, left, right + weight[now])
scale(weight, n, now + 1, left, right)
ans[now][new] = 1
์์ ์ฝ๋๋ ๊ฐ๋ฅํ ์กฐํฉ์ ์ฐพ๋ ์ฌ๊ท ํจ์์ธ scale์ ์ ์ํ๋ ๋ถ๋ถ์ด๋ค.
1. scale(weight, n, now, left, right): ํจ์์ ๋งค๊ฐ๋ณ์๋ก๋ ์ถ์ ๋ฌด๊ฒ๋ฅผ ๋ด์ ๋ฆฌ์คํธ weight, ์ถ์ ๊ฐ์ n, ํ์ฌ ์ฒ๋ฆฌ ์ค์ธ ์ถ์ ์ธ๋ฑ์ค now, ์ผ์ชฝ ์ ์ธ์ ์ฌ๋ผ๊ฐ ์ถ์ ๋ฌด๊ฒ ํฉ left, ์ค๋ฅธ์ชฝ ์ ์ธ์ ์ฌ๋ผ๊ฐ ์ถ์ ๋ฌด๊ฒ ํฉ right๊ฐ ์๋ค.
2. new = abs(left - right): ํ์ฌ ์ผ์ชฝ ์ ์ธ๊ณผ ์ค๋ฅธ์ชฝ ์ ์ธ์ ์ฌ๋ผ๊ฐ ์ถ๋ค์ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ์ฌ new์ ์ ์ฅํ๋ค. ์์์ผ ๊ฒฝ์ฐ๋ฅผ ๋๋นํ์ฌ abs()๋ฅผ ์ฌ์ฉํ๋ค.
3. if new not in possible: possible.append(new): ์๋ก ๊ณ์ฐํ ๋ฌด๊ฒ ์ฐจ์ด๊ฐ possible ๋ฆฌ์คํธ์ ์๋ ๊ฒฝ์ฐ, ์๋ก์ด ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ possible ๋ฆฌ์คํธ์ ์ถ๊ฐํ๋ค. ์ด๋ ๊ฒ ํจ์ผ๋ก์จ ์ค๋ณต๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๋ฐฉ์งํ๋ค.
4. if now == n: return 0: ํ์ฌ ์ฒ๋ฆฌ ์ค์ธ ์ถ์ ์ธ๋ฑ์ค๊ฐ ์ถ์ ๊ฐ์์ ๊ฐ์ ๊ฒฝ์ฐ, ์ฆ ๋ชจ๋ ์ถ์ ๋ํ ์ฒ๋ฆฌ๊ฐ ๋๋ ๊ฒฝ์ฐ์๋ ๋ ์ด์ ์ฌ๊ท ํธ์ถ์ ํ์ง ์๊ณ ํจ์๋ฅผ ์ข
๋ฃํ๋ค.
5. if ans[now][new] == 0: ... ans[now][new] = 1: ์ด์ค ๋ฆฌ์คํธ ans๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฏธ ๊ณ์ฐํ ๋ฌด๊ฒ ์ฐจ์ด์ธ์ง ํ์ธํ๋ค. ๋ง์ฝ ํด๋น ๋ฌด๊ฒ ์ฐจ์ด๊ฐ ๊ณ์ฐ๋์ง ์์ ๊ฒฝ์ฐ๋ผ๋ฉด, ์๋ก์ด ์ถ๋ฅผ ์ผ์ชฝ ์ ์ธ์ ์ฌ๋ฆฌ๋ ๊ฒฝ์ฐ, ์ค๋ฅธ์ชฝ ์ ์ธ์ ์ฌ๋ฆฌ๋ ๊ฒฝ์ฐ, ํน์ ์ฌ๋ฆฌ์ง ์๋ ๊ฒฝ์ฐ๋ฅผ ๊ฐ๊ฐ ์ฌ๊ท์ ์ผ๋ก ํธ์ถํ์ฌ ๊ฐ๋ฅํ ๋ชจ๋ ์กฐํฉ์ ๊ณ์ฐํ๋ค. ๊ทธ๋ฆฌ๊ณ ํด๋น ๋ฌด๊ฒ ์ฐจ์ด์ ์ธ๋ฑ์ค์ 1์ ํ ๋นํ์ฌ ์ค๋ณต ๊ณ์ฐ์ ๋ฐฉ์งํ๋ค.
์ด ํจ์๋ฅผ ํตํด ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๊ณ possible ๋ฆฌ์คํธ์ ์ ์ฅํ๊ฒ ๋๋ค.
scale(weight, n, 0, 0, 0)
for i in check:
if i in possible:
print('Y', end=' ')
else:
print('N', end=' ')
์ฃผ์ด์ง ์ฝ๋๋ scale ํจ์๋ฅผ ํธ์ถํ์ฌ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๊ณ , ์ด๋ฅผ ๋ฐํ์ผ๋ก ๊ฐ ํ์ธํ ๋ฌด๊ฒ์ ๋ํด ๊ฐ๋ฅํ์ง ์ฌ๋ถ๋ฅผ ์ถ๋ ฅํ๋ ๋ถ๋ถ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ์๋์์ ๊ฐ ๋ถ๋ถ์ ์์ธํ ์ค๋ช
ํ๊ฒ ๋ค.
1. scale(weight, n, 0, 0, 0): ์ด ๋ถ๋ถ์ scale ํจ์๋ฅผ ํธ์ถํ์ฌ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๋ค. ์ด ๋, weight๋ ์ฃผ์ด์ง ์ถ์ ๋ฌด๊ฒ๋ฅผ ๋ด์ ๋ฆฌ์คํธ์ด๋ฉฐ, n์ ์ ์ฒด ์ถ์ ๊ฐ์์ด๋ค. 0์ ํ์ฌ ์ฒ๋ฆฌ ์ค์ธ ์ถ์ ์ธ๋ฑ์ค๋ฅผ ๋ํ๋ด๋ฉฐ, 0์ ์ผ์ชฝ ์ ์ธ๊ณผ ์ค๋ฅธ์ชฝ ์ ์ธ์ ์ฌ๋ผ๊ฐ ์ถ์ ์ด๊ธฐ ๋ฌด๊ฒ ํฉ์ ์๋ฏธํ๋ค. ์ด ํธ์ถ์ ํตํด possible ๋ฆฌ์คํธ์ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๊ฐ ์ ์ฅ๋๋ค.
2. for i in check:: ์ด ๋ถ๋ถ์ ํ์ธํ ๋ฌด๊ฒ๋ค์ ๋ํ ๋ฐ๋ณต๋ฌธ์ด๋ค. check ๋ฆฌ์คํธ์ ์๋ ๊ฐ ๋ฌด๊ฒ๋ฅผ ์ํํ๋ค.
3. if i in possible:: ์ด ๋ถ๋ถ์ ํ์ฌ ํ์ธ ์ค์ธ ๋ฌด๊ฒ i๊ฐ possible ๋ฆฌ์คํธ์ ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธํ๋ค. ์ฆ, ์ฃผ์ด์ง ์ถ์ ๋ฌด๊ฒ๋ก ๊ฐ๋ฅํ ๋ฌด๊ฒ ์ฐจ์ด ์ค์ ํ์ฌ ํ์ธ ์ค์ธ ๋ฌด๊ฒ๊ฐ ์๋์ง๋ฅผ ๊ฒ์ฌํ๋ค.
4. print('Y', end=' ')์ print('N', end=' '): ์ด ๋ถ๋ถ์ ๊ฐ๋ฅํ ๊ฒฝ์ฐ์๋ 'Y'๋ฅผ ์ถ๋ ฅํ๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ์๋ 'N'์ ์ถ๋ ฅํ๋ค. ์ฌ๊ธฐ์ end=' '๋ ์ถ๋ ฅ ํ ์ค ๋ฐ๊ฟ ๋์ ์ ๊ณต๋ฐฑ์ ์ถ๊ฐํ๋ ์ต์
์ด๋ค.
๋ฐ๋ผ์ ์ฃผ์ด์ง ์ฝ๋๋ ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌด๊ฒ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ ๋ค, ๊ฐ ํ์ธํ ๋ฌด๊ฒ์ ๋ํด ๊ฐ๋ฅํ์ง ์ฌ๋ถ๋ฅผ ํ๋จํ์ฌ ์ถ๋ ฅํ๋ ๊ฒ์ ๋ชฉ์ ์ผ๋ก ํ๋ค.
[3] ๋๋ ์
ํ ์ค์ ์ฌ๋ฌ ๋ฌธ์๋ฅผ ์ ๋ ฅ๋ฐ๋ ํจ์์ธ 'sys.stdin.readline()'์ ๋ํด์๋ ์ด๋ฒ ๊ธฐํ๋ก ์ฒ์ ์๊ฒ ๋์๋ค.
๋ฌธ๋ฒ๋ ๋ชฐ๋์ง๋ง, ๋ก์ง๋ ๋ ์ฌ๋ฆฌ์ง ๋ชปํด์ ๋ง์ด ์ด๋ ค์ ๋ ๋ฌธ์ ์๋ค.
ํ์ง๋ง ์ด๋ ๊ฒ ๊ณต๋ถํ๋ค๋ณด๋ฉด ์ค๋ ฅ์ด ์กฐ๊ธ์ฉ์ด๋ผ๋ ๋์ง ์์๊น?
๊ทธ๋ฌ์ผ๋ฉด ์ข๊ฒ ๋ค...
[4] ์ฐธ๊ณ
'SWLUG > ๋ฐฑ์ค BEAKJOON' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BAEKJOON/๋ฐฑ์ค] 9095๋ฒ: 1, 2, 3 ๋ํ๊ธฐ (0) | 2024.05.01 |
---|---|
[BAEKJOON/ ๋ฐฑ์ค] 1520๋ฒ: ๋ด๋ฆฌ๋ง ๊ธธ (Python) (1) | 2024.04.02 |
[C] ๋ฐฑ์ค/BAEKJOON 2839๋ฒ: ์คํ ๋ฐฐ๋ฌ (1) | 2023.11.21 |
[C] ๋ฐฑ์ค/BAEKJOON 2566๋ฒ: ์ต๋๊ฐ (0) | 2023.11.15 |
[C] ๋ฐฑ์ค/BAEKJOON 15649๋ฒ: N๊ณผ M (1) (1) | 2023.11.15 |