๋ฌธ์
https://www.acmicpc.net/problem/16987
๋ฐฑ์ค ๋ฌธ์ ์ง - 0x0C๊ฐ - ๋ฐฑํธ๋ํน
์๊ณ ๋ฆฌ์ฆ: ๋ฐฑํธ๋ํน, ๋ธ๋ฃจํธํฌ์ค
ํ์ด
๊ณ๋์ ์น๋ ๊ณผ์ ์ ์ค๋ช ํ๋ฉด ์๋์ ๊ฐ๋ค.
1. ๊ฐ์ฅ ์ผ์ชฝ์ ๊ณ๋์ ๋ ๋ค.
2. ์์ ๋ค๊ณ ์๋ ๊ณ๋์ผ๋ก ๊นจ์ง์ง ์์ ๋ค๋ฅธ ๊ณ๋ ์ค์์ ํ๋๋ฅผ ์น๋ค. ๋จ, ์์ ๋ ๊ณ๋์ด ๊นจ์ก๊ฑฐ๋ ๊นจ์ง์ง ์์ ๋ค๋ฅธ ๊ณ๋์ด ์์ผ๋ฉด ์น์ง ์๊ณ ๋์ด๊ฐ๋ค. ์ดํ ์์ ๋ ๊ณ๋์ ์๋ ์๋ฆฌ์ ๋ด๋ ค๋๊ณ 3๋ฒ ๊ณผ์ ์ ์งํํ๋ค.
3. ๊ฐ์ฅ ์ต๊ทผ์ ๋ ๊ณ๋์ ํ ์นธ ์ค๋ฅธ์ชฝ ๊ณ๋์ ์์ ๋ค๊ณ 2๋ฒ ๊ณผ์ ์ ๋ค์ ์งํํ๋ค. ๋จ, ๊ฐ์ฅ ์ต๊ทผ์ ๋ ๊ณ๋์ด ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์์นํ ๊ณ๋์ผ ๊ฒฝ์ฐ ๊ณ๋์ ์น๋ ๊ณผ์ ์ ์ข ๋ฃํ๋ค.
์ด ๊ณผ์ ์ ํตํด ์ต๋ํ ๋ง์ ๊ณ๋์ ๊นจ๋ ๊ฒ์ด ์์ผ๋ก ์ธ๋ฒ์ด๊ฐ ๋งค์ผ ์์นจ๋ง๋ค ํ๊ฒ ๋ ํผ์ฆ์ด๋ค. ๊ทธ๋ฆฌ๊ณ ์ ํ์ด๋ ์ธ๋ฒ์ด๊ฐ ์ฐพ์ ๋ต์ด ์ ๋ต์ด ๋ง๋์ง ํ์ธํด์ฃผ๋ ค๊ณ ํ๋ค. ์ผ๋ ฌ๋ก ๋์ธ ๊ณ๋๋ค์ ๋ด๊ตฌ๋์ ๋ฌด๊ฒ๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ก์ ๋ ์ต๋ ๋ช ๊ฐ์ ๊ณ๋์ ๊นฐ ์ ์๋์ง ์์๋ง์ถฐ๋ณด์.
๋ช๋ฒ์งธ ๊ณ๋์ ๊นจ๋์ง์๋ ์๊ด์์ด ์ง๋ ์์๋ ๋ฌด์กฐ๊ฑด 0 ~ N-1 ์์ด๋ค.
ํ์ฌ ๊ณ๋์ ๋ฒํธ๋ฅผ curr ์ด๋ผ ํ์๋, ํจ์ ์คํ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค.
curr๊ณผ N์ด ๊ฐ๋ค๋ฉด ๋ชจ๋ ๊ณ๋์ ๊นผ๋ค๋ ์๋ฆฌ์ด๋ฏ๋ก ๊ฒฐ๊ณผ๊ฐ์ ์
๋ฐ์ดํธํ๋ค.
๋๋ curr๋ฒ์งธ ๊ณ๋์ด ํ์ฌ ๊นจ์ ธ์๋ ์ํ๋ผ๋ฉด curr + 1๋ฒ์งธ ๊ณ๋์ผ๋ก ์ฌ๊ทํ๋ค.
์๋๋ผ๋ฉด 0 ~ N-1 ๋ฒ์งธ ๊ณ๋ ์ค ๊นจ์ ธ์์ง ์์ ๊ณ๋์ ๋ด๋ ค์น๋ค.
๋ด๋ ค์น ํ curr ๋ฒ์งธ ๊ณ๋๊ณผ ๋ด๋ ค์น๊ณ๋์ด ๊นจ์ ธ์๋์ง ์ฒดํฌํ๊ณ ๊นจ์ ธ์๋ค๋ฉด ์นด์ดํธํ๋ค.
๊ทธ๋ฆฌ๊ณ curr + 1๋ฒ์งธ ๊ณ๋์ผ๋ก ์ฌ๊ท๋ฅผ ์คํํ๋ค.
๋ง์ฝ ๋ชจ๋ ๊ณ๋์ ๋ด๋ ค์น์ง ์๊ณ ์ง๋์ณค๋ค๋ฉด ๊ณ๋์ด ๋ค ๊นจ์ ธ์๋ค๋ ์๋ฆฌ์ด๋ฏ๋ก curr + 1๋ฒ์งธ ๊ณ๋์ผ๋ก ์ฌ๊ท๋ฅผ ์คํํ๋ฉด ๋๋ค.
์ ์ฒด ์ฝ๋
# ๋ด๊ตฌ๋, ๋ฌด๊ฒ๋ฅผ ๋ฐ๋ก ์ ์ฅํ์๋
# ๋ฉ๋ชจ๋ฆฌ: 31120KB / ์๊ฐ: 2780ms
from sys import stdin
input = stdin.readline
N = int(input())
weight = [] # ๋ฌด๊ฒ
hard = [] # ๋ด๊ตฌ๋
for _ in range(N):
h, w = map(int, input().split())
hard.append(h)
weight.append(w)
ret = 0
def breaking(hard, weight, curr, total_broken):
global ret
if curr == N:
ret = max(ret, total_broken)
return
if hard[curr] <= 0:
breaking(hard, weight, curr+1, total_broken)
return
no_break = True
for target in range(N):
if target != curr and hard[target] > 0:
no_break = False
hard[target] -= weight[curr]
hard[curr] -= weight[target]
broken = total_broken
if hard[curr] <= 0:
broken += 1
if hard[target] <= 0:
broken += 1
breaking(hard, weight, curr+1, broken)
hard[target] += weight[curr]
hard[curr] += weight[target]
if no_break:
breaking(hard, weight, curr+1, total_broken)
breaking(hard, weight, 0, 0)
print(ret)
๋ด๊ตฌ๋์ ๋ฌด๊ฒ๋ฅผ ํ๊บผ๋ฒ์ ์ ์ฅํ๋ ๋ฐฉ์๋ณด๋ค ๋ฐ๋ก ๊ด๋ฆฌํ๋๊ฒ ๋ ๋นจ๋๋ค.
(ํฐ ์ฐจ์ด๋ ์๋์์. 3168ms, 2780ms)