๐ ๋ฌธ์ ์ค๋ช
์์ ์๋ ๋์ด๊ฐ B์ธ ์ ๋ฐ์ด ์๋ค.
์ด ์์ ์ ์๋ N๋ช ์ ์ ์๋ค์ด ์ ๋ฐ ์์ ์ฌ๋ ค๋์ ๋ฌผ๊ฑด์ ์ฌ์ฉํด์ผ ํ๋ ์ผ์ด ์๊ฒผ๋ค.
๊ฐ ์ ์์ ํค๋ Hi๋ก ๋ํ๋๋๋ฐ, ์ ์๋ค์ ํ์ ์์์ ์ ๋ฐ ์์ ๋ฌผ๊ฑด์ ์ฌ์ฉํ๊ธฐ๋ก ํ์๋ค.
์ ์๋ค์ด ์๋ ํ์ ์ ์ 1๋ช ์ด์์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
ํ์ ๋์ด๋ ์ ์์ด 1๋ช ์ผ ๊ฒฝ์ฐ ๊ทธ ์ ์์ ํค์ ๊ฐ๊ณ , 2๋ช ์ด์์ผ ๊ฒฝ์ฐ ํ์ ๋ง๋ ๋ชจ๋ ์ ์์ ํค์ ํฉ๊ณผ ๊ฐ๋ค.
ํ์ ๋์ด๊ฐ B ์ด์์ธ ๊ฒฝ์ฐ ์ ๋ฐ ์์ ๋ฌผ๊ฑด์ ์ฌ์ฉํ ์ ์๋๋ฐ ํ์ ๋์ด๊ฐ ๋์์๋ก ๋ ์ํํ๋ฏ๋ก ๋์ด๊ฐ B ์ด์์ธ ํ ์ค์์ ๋์ด๊ฐ ๊ฐ์ฅ ๋ฎ์ ํ์ ์์๋ด๋ ค๊ณ ํ๋ค.
์ ๋ ฅ
- ์ฒซ ๋ฒ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ์ T๊ฐ ์ฃผ์ด์ง๋ค.
- ๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ ๋ฒ์งธ ์ค์๋ ๋ ์ ์ N, B(1 ≤ N ≤ 20, 1 ≤ B ≤ S)๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
- S๋ ๋ ๋ฒ์งธ ์ค์์ ์ฃผ์ด์ง๋ ์ ์๋ค ํค์ ํฉ์ด๋ค.
- ๋ ๋ฒ์งธ ์ค์๋ N๊ฐ์ ์ ์๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ฉฐ, ๊ฐ ์ ์๋ ๊ฐ ์ ์์ ํค Hi (1 ≤ Hi ≤ 10,000)์ ๋ํ๋ธ๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค๋ง๋ค ์ฒซ ๋ฒ์งธ ์ค์๋ ‘#t’(t๋ ํ ์คํธ ์ผ์ด์ค ๋ฒํธ๋ฅผ ์๋ฏธํ๋ฉฐ 1๋ถํฐ ์์ํ๋ค)๋ฅผ ์ถ๋ ฅํ๊ณ , ๋ง๋ค ์ ์๋ ๋์ด๊ฐ B ์ด์์ธ ํ ์ค์์ ํ์ ๋์ด์ B์ ์ฐจ์ด๊ฐ ๊ฐ์ฅ ์์ ๊ฒ์ ์ถ๋ ฅํ๋ค.
๐ก ๋ฌธ์ ํ์ด
์ฌ๊ท + ๋ฐฑํธ๋ํน์ ํ์ฉํ๋ ๋ํ์ ์ธ ๋ฌธ์ ์ค ํ๋๋ค.
step 1)
๋ณ์ ์ ์ธ
- numbers : ์ ์๋ค์ ํค๋ฅผ ๋ด์ ๋ฐฐ์ด
- res : ๋ฌธ์ ์ ์ ๋ต์ ๋ด๋ ๋ณ์ - ์ต์๊ฐ์ ์ฐพ์ผ๋ฏ๋ก ํฐ ๊ฐ์ผ๋ก ์ด๊ธฐํ!
- solve : ๋ฌธ์ ํด๊ฒฐ์ ์ํด ์์ฑํ (์ฌ๊ท)ํจ์
step 2)
์ฌ๊ท ํจ์๋ฅผ ํตํ์ฌ ์ ์๋ค์ด ํ์ ์์ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ('์กฐํฉ')๋ฅผ ํ์ธํด์ผ ํ๋ค.
๋ฐ๋ผ์ ํจ์์ ์ธ์์ 0(์ธ๋ฑ์ค), 0(ํค์ ์ดํฉ)๊ฐ์ ๋ฃ์ด ํ์์ ์์ํ๋ค.
→ ์ฌ๊ท์ ์ข
๋ฃ๋ ๋ฐฐ์ด์ ๋ค ํ์ํ์ ๋(n == N)์ด๋ค.
์ข ๋ฃ์์ ์ ์ด๋ฅด๊ธฐ ๊น์ง ๋ฐฐ์ด์ ์์๋ฅผ ๋ํ๊ฑฐ๋ ๋์ด๊ฐ๋ ๋ฐฉ์์ผ๋ก ๋ชจ๋ ๊ฒฝ์ฐ์ ์์ ๋ํด ํ์ํ๋ค.
step 3)
์ฌ๊ท์ ์ข
๋ฃ์์ ์ด ๋๋ฉด ํค์ ์ดํฉ(total)์ด B๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฐ์ง ํ์ธํ๋ค.
๋์์, res์๋ ํค์ ์ดํฉ๊ณผ ์ ๋ฐ์ ๋์ด(B)์ฐจ๊ฐ ์ต์์ธ ๊ฐ์ ๋ฃ์ด์ผ ํ๋ค.
์์ ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด res์ total-B ๊ฐ์ ์ต์ ํํ๋ค.
์ถ๊ฐ์ ์ผ๋ก ์ฌ๊ท๋ฅผ ์งํํ๋ฉด์ ๊ฐ์ง์น๊ธฐ๋ฅผ ํ์๋ค. ์ต์๊ฐ์ ์ฐพ๋ ๊ฒ์ด ๋ชฉํ์ด๊ธฐ ๋๋ฌธ์ ์งํ์ค์ total-B ๊ฐ์ด res๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๋ฉด returnํ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ์๋ค.
์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
def solve(n, total):
global N, B, res
if n == N:
if total >= B and res > total - B:
res = total - B
return
if total - B >= res: return
solve(n+1, numbers[n] + total)
solve(n+1, total)
T = int(input())
for tc in range(T):
N, B = map(int, input().split())
numbers = list(map(int, input().split()))
res = 0xffffff
solve(0, 0)
print('#{} {}'.format(tc+1, res))
'Algorithm > SWEA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] SWEA : 10965. ์ ๊ณฑ์ ๋ง๋ค๊ธฐ by Python (0) | 2020.12.29 |
---|---|
[Algorithm] SWEA : 10726. ์ด์ง์ ํํ by Python (3) | 2020.12.10 |
๋๊ธ