๐ ๋ฌธ์
- ์๋ก ๋ค๋ฅธ ๋ง๋๊ธฐ n๊ฐ๊ฐ ์ฃผ์ด์ง๋ค.
- ๊ฐ ๋ง๋๊ธฐ์ ๊ธธ์ด๋ a1, a2, ..., an ์ด๋ค.
- ์ด ์ค 3๊ฐ ์ด์์ ๋ง๋๊ธฐ๋ฅผ ๊ณจ๋ผ ๋์ด๊ฐ 0์ด ์๋ ๋จ์ ๋ค๊ฐํ์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํด์ผ ํ๋ค.
- ๊ฒฝ์ฐ์ ์๋ ๋งค์ฐ ํด ์ ์์ผ๋ฏ๋ก 10^9 + 7 ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ถ๋ ฅํ๋ค.
๐ ์กฐ๊ฑด ๋ถ์
์ด ๋ฌธ์ ๋ ๊ฝค ์ด๋ ค์์ ์๊ฐ์ ๋ง์ด ํฌ์ํ๋ ๋งํผ ,,
์กฐ๊ฑด ๋ถ์๋ถํฐ ํ๊ณ ์์ํด๋ณด๋ ค ํ๋ค.
์ฐ๋ฆฌ๊ฐ ๋จ์ ๋ค๊ฐํ์ ํ๋ ๊ทธ๋ ธ๋ค๊ณ ์๊ฐํ์.
๊ฐ์ฅ ๊ธด ๋ณ์ ๊ธธ์ด๋ฅผ Lmax , ๋๋จธ์ง ๋ณ๋ค์ ํฉ์ Srest ๋ผ ํด๋ณด์.
์ด์ ๋ค๊ฐํ์์ Lmax์ ์ ๋ ์ ์ A, B๋ผ ๋๊ณ ,
๋๋จธ์ง ๋ณ๋ค๋ง ๋ฐ๋ผ์ A์์ B๊น์ง ๊ฑธ์ด๊ฐ๋ ์ํฉ์ ์์ํด๋ณด์.
๋น์ฐํ ์ด ๊ฒฝ๋ก์ ๊ธธ์ด๋ ๋๋จธ์ง ๋ณ๋ค์ ํฉ์ธ Srest ์ผ ๊ฒ์ด๋ค.

์ผ๊ฐ๋ถ๋ฑ์์ ์ํด, ์ด๋ค ๊ฒฝ๋ก๋ก ๋ ์ A, B ๋ฅผ ์๋ ๊ฐ์ AB์ ์ง์ ๊ฑฐ๋ฆฌ <= ๊ฒฝ๋ก์ ๊ธธ์ด ์ฌ์ผ ํ๋ค.
๊ทธ๋ฆฌ๊ณ ์ฌ๊ธฐ์ ๋งํ๋ AB์ ์ง์ ๊ฑฐ๋ฆฌ๊ฐ ๋ฐ๋ก Lmax ์ด๊ณ , ๊ฒฝ๋ก ๊ธธ์ด๊ฐ Srest ์ด๋ฏ๋ก,
Lmax <= Srest ๋ผ๋ ์กฐ๊ฑด์ด ๋ง๋ค์ด์ง๋ค.
๊ทธ๋ฐ๋ฐ ๋ง์ฝ, Lmax == Srest ๋ผ๊ณ ํด๋ณด์.
๊ทธ๋ฌ๋ฉด, AB๋ฅผ ์๋ ๋ง๋๊ธฐ ์ธ์ ๋๋จธ์ง ๋ชจ๋ ๋ง๋๊ธฐ๋ค์ ํ์ค๋ก ์ญ ํผ์ณ๋์ผ์ง๋ง ๊ธธ์ด๊ฐ ๋ง๊ฒ ๋๋ค.

๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๋์ด๊ฐ 0์ด ์๋ ๋ค๊ฐํ์ ์ํ๊ธฐ ๋๋ฌธ์
์กฐ๊ฑด์ Lmax < Srest ๋ก ๋ฐ๊ฟ์ฃผ์ด์ผ ํ๋ค.
์ ๊ทธ๋ผ ์ด์ ์์ ์ด์ง ๋ณํํด๋ณด๋ ค๊ณ ํ๋ค.
์งํฉ S์ ์ ์ฒด ํฉ์ sum(S), ์ด์ค์์ ๊ฐ์ฅ ๊ธด ๋ณ์ max(S)๋ผ๊ณ ๋ถ๋ฅด๋ฉด,
๋๋จธ์ง ๋ณ๋ค์ ํฉ์ ์ ์ฒด ํฉ sum(S)์์ ๊ฐ์ฅ ๊ธด ๋ณ max(S)๋ฅผ ๋บ ๊ฐ์ด ๋ ๊ฒ์ด๋ค.
์ฆ, ๋๋จธ์ง ๋ณ๋ค์ ํฉ Srest = sum(S) - max(S) ์ด๋ค.
์ด์ ๋ค์ ์ ๋ฆฌํด๋ณด๋ฉด ๋ค๊ฐํ์ ์กฐ๊ฑด์
์์์ ๋งํ๋ Lmax, ์ฆ ์ง๊ธ์ max(S)๊ฐ Srest, ์ฆ ์ง๊ธ์ sum(S) - max(S) ๋ณด๋ค ์์์ผ ํ์ผ๋ฏ๋ก,
max(S) < sum(S) - max(S) ๋ผ๊ณ ํ ์ ์๋ค.
์ด๊ฑฐ๋ฅผ ์์ ์กฐ๊ธ๋ง ๊น๊ธํ๊ฒ ์ ๋ฆฌํด์ฃผ๋ฉด,
2 * max(s) < sum(S) ๋ก ๋ฐ๊ฟ ์ ์๋ค.
๐ก ์์ด๋์ด
์์ ์กฐ๊ฑด ๋ถ์์ ํตํด ์ฐ๋ฆฌ๋
์ ํํ ๋ง๋ ์งํฉ S์์ 2 * max(S) < sum(S) ์ผ ๋๋ง ๋์ด๊ฐ 0์ด ์๋ ๋ค๊ฐํ์ ๋ง๋ค ์ ์๋ค๋ ์ฌ์ค์ ์๊ฒ ๋์๋ค.
์ด์ ๋จ์ ๋ฌธ์ ๋ ๋ชจ๋ ๊ฐ๋ฅํ ๋ถ๋ถ ์งํฉ์ ์ด๋ป๊ฒ ํจ์จ์ ์ผ๋ก ์ ๊ฒ์ธ๊ฐ์ด๋ค.
๊ทธ๋ฌ๊ธฐ ์ํด์๋ ๋จผ์ , ๋ง๋๊ธฐ๋ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด์ค์ผ ํ๋ค.
์ด๋ ๊ฒ ํ๋ฉด, ์ธ๋ฑ์ค๊ฐ ๋ค๋ก ๊ฐ์๋ก ๋ง๋ ๊ธธ์ด๊ฐ ๊ธธ์ด์ง๋ฏ๋ก, ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ฅผ ๊ณ ์ ํ๊ธฐ๊ฐ ์ฌ์์ง๊ธฐ ๋๋ฌธ์ด๋ค.
์๋ฅผ ๋ค์ด, i๋ฒ์งธ ๋ง๋๊ธฐ๋ฅผ ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ก ์ ํํ๋ค๋ฉด,
์์ชฝ์ ๋ง๋๊ธฐ๋ค๋ง ๊ณ ๋ คํด์ ๋ถ๋ถ์งํฉ์ ๋ง๋ค์ด์ฃผ๋ฉด ๋๋ ๊ฒ์ด๋ค.
๋ค์์ผ๋ก๋, ์์์ ๋ค๊ฐํ ์งํฉ์ ์ก์์ ๋,
๊ฒฐ๊ตญ ๊ทธ ์งํฉ์ ์ฑ๋ฆฝ ์ฌ๋ถ๋ ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ ํ๋์ ์ํด์ ๊ฒฐ์ ๋๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ฅผ ํ๋์ฉ ๊ณ ์ ํ๊ณ , ๊ทธ๋ณด๋ค ์งง์ ๋ง๋๊ธฐ๋ค ์ค ์ผ๋ถ๋ฅผ ๊ณจ๋ผ ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํด์ฃผ๋ฉด ๋๋ค.
์๋ฅผ ๋ค์ด, i๋ฒ์งธ ๋ง๋๊ธฐ๋ฅผ ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ก ๊ณ ์ ํ๋ค๊ณ ํ์.
๊ทธ๋ฌ๋ฉด ํ๋ณด ์งํฉ์ ์ด ๊ฐ์๋, i๊ฐ์ ๋ง๋๊ธฐ ์ค ์๋ฌด๊ฑฐ๋ ๊ณ ๋ฅด๋ ๋ถ๋ถ์งํฉ์ ์์ ๊ฐ๋ค.
(๋จ, ๊ณต์งํฉ๊ณผ ํฌ๊ธฐ๊ฐ 1์ธ ์งํฉ์ ๋ค๊ฐํ์ ๋ง๋ค ์ ์์ผ๋ ๋นผ์ค์ผ ํ๋ค.)
์ด ๊ฒฝ์ฐ ์ด ํ๋ณด์ ๊ฐ์๋ 2^i - 1 - i ๊ฐ ๋๋ค.
(-1์ ๊ณต์งํฉ์ ๋นผ์ค ๊ฒ์ด๊ณ , -i๋ ํฌ๊ธฐ๊ฐ 1์ธ ์งํฉ์ ๊ฐ์๋ฅผ ๋นผ์ค ๊ฒ์ด๋ค.)
์ด์ ๋ฌธ์ ์ ํต์ฌ์ธ๋ฐ, ์กฐ๊ฑด์ ๋ง์กฑํ์ง ๋ชปํ๋ ์งํฉ์ ์ธ์ด์ฃผ๋ฉด ๋๋ค.
์๊น ๋ฌธ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์กฐ๊ฑด์ด 2 * max(S) < sum(S) ๋ผ๊ณ ํ์ผ๋๊น,
๋ง์กฑํ์ง ๋ชปํ ์กฐ๊ฑด์ 2 * max(S) >= sum(S) ๊ฐ ๋ ๊ฒ์ด๋ค.
๊ทธ๋ผ ์ด์ ์ด ๊ฐ์๋ฅผ ์ธ์ผ ํ๋๋ฐ,
๋จ์ํ ๋ถ๋ถ์งํฉ์ ํ๋์ฉ ๋ง๋ค์ด์ ํฉ์ ๊ณ์ฐํ๊ฒ ๋๋ฉด
์๊ฐ ๋ณต์ก๋๊ฐ O(2^n) ์ด์ด์ ์ ๋ ๋ถ๊ฐ๋ฅํ๋ค ..๐คง
๊ทธ๋์ ์ด์ฉํด์ฃผ๋ ๊ฒ์ DP์ด๋ค.
๋๋ ์๋์ ๊ฐ์ด ๋๋ ์ฃผ์๋ค.
- dp1[x] ๐๐ป ํฉ์ด ์ ํํ x์ด๋ฉด์ ๋ถ๋ถ ์งํฉ์ ํฌ๊ธฐ๊ฐ 1์ธ ๋ถ๋ถ ์งํฉ์ ๊ฐ์
- dp2[x] ๐๐ป ํฉ์ด ์ ํํ x์ด๋ฉด์ ๋ถ๋ถ ์งํฉ์ ํฌ๊ธฐ๊ฐ 2 ์ด์์ธ ๋ถ๋ถ ์งํฉ์ ๊ฐ์
์ด๋ ๊ฒ ๋๋๋ ์ด์ ๋,
๋ค๊ฐํ์ด ๋๋ ค๋ฉด ์ต์ 3๊ฐ ์ด์์ ๋ง๋๊ธฐ๊ฐ ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ผ์ ์๋ก์ด ๋ง๋๊ธฐ๋ฅผ ์ถ๊ฐํ ๋ ์๋์ ๊ณผ์ ์ ๊ฑฐ์น๊ฒ ๋๋ค.
- ๊ธฐ์กด์ ํฌ๊ธฐ๊ฐ 2 ์ด์์ธ ์งํฉ์ ๋ง๋๊ธฐ๋ฅผ ์ถ๊ฐํ๋ฉด, ์ฌ์ ํ ํฌ๊ธฐ๊ฐ 2 ์ด์์ด๋ฏ๋ก dp2์ ๋ํด์ค๋ค.
- ๊ธฐ์กด์ ํฌ๊ธฐ๊ฐ 1์ธ ์งํฉ์ ๋ง๋๊ธฐ๋ฅผ ์ถ๊ฐํ๋ฉด, ํฌ๊ธฐ๊ฐ 2 ์ด์์ผ๋ก ์น๊ฒฉํ๋ฏ๋ก dp2์ ๋ํด์ค๋ค.
- ๋ง๋๊ธฐ ํ๋๋ง ๋จ๋ ์ผ๋ก ์ถ๊ฐํ๋ฉด, dp1์ ๋ํด์ค๋ค.
์์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด,
ํ์ฌ๊น์ง ๊ณ ๋ คํ ๋ง๋๊ธฐ๋ค๋ก ๋ง๋ค ์ ์๋ ๋ถ๋ถ์งํฉ์ ํฉ ๋ถํฌ๋ฅผ DP ๋ฐฐ์ด์ ๋ชจ๋ ๊ธฐ๋กํ ์ ์๋ค.
๐ฉ๐ป๐ป ์ ์ฒด ์ฝ๋
MOD = 10**9 + 7
n = int(input())
A = list(map(int, input().split()))
A.sort()
Amax = max(A)
ans = 0
# ๋ถ๋ถ ์งํฉ์ ๊ฐ์๋ฅผ ๊ด๋ฆฌํ๋ DP ํ
์ด๋ธ
dp1 = [0] * (Amax + 1) # ํฌ๊ธฐ๊ฐ 1์ธ ์งํฉ
dp2 = [0] * (Amax + 1) # ํฌ๊ธฐ๊ฐ 2 ์ด์์ธ ์งํฉ
# 2^i ๋ฏธ๋ฆฌ ๊ณ์ฐํด๋๊ธฐ
pow2 = [1] * (n + 1)
for i in range(1, n + 1):
pow2[i] = (pow2[i - 1] * 2) % MOD
for i, x in enumerate(A):
# i๋ฒ์งธ ๋ง๋๊ธฐ๋ฅผ ๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ก ์ ํใ
๋ฅด ๋, ๊ฐ๋ฅํ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ ๊ฐ์
total = (pow2[i] - 1 - i) % MOD
# ์กฐ๊ฑด์ ๋ง์กฑ ๋ชปํ๋ ๋ถ๋ถ์งํฉ์ ๊ฐ์ ์ธ๊ธฐ
delete = 0
jsum = 0
for j in range(0, x + 1):
jsum = (jsum + dp2[j]) % MOD
delete = jsum
ans = (ans + (total - delete)) % MOD
# ์๋ก์ด ๋ง๋๊ธฐ ์ถ๊ฐ ์ DP ๊ฐฑ์
l = x
for k in range(Amax - l, -1, -1):
if dp2[k] or dp1[k]:
dp2[k + l] = (dp2[k + l] + dp2[k] + dp1[k]) % MOD
# dp1๋ ๊ฐฑ์ ํด์ฃผ๊ธฐ
if l <= Amax:
dp1[l] = (dp1[l] + 1) % MOD
print(ans % MOD)
๐ ๊ฒฐ๋ก
๊ฐ์ธ์ ์ผ๋ก DP ๋ฌธ์ ๋ค ๋ณด๋๊น ๋ญ ์์ด๋์ด ๋ ์ฌ๋ฆฌ๋๊ฒ ์ ค ์ด๋ ค์ ์ ๊ฒ ๊ฐ์์
๋ด๊ฐ ์๊ฐํ ์์ด๋์ด๋ฅผ ๊ตฌ์ฒด์ ์ผ๋ก ์ ๋ค ๋ณด๋ ๊ธ์ด ๊ฝค ๊ธธ์ด์ ธ ๋ฒ๋ ธ๋ค ..๐
์ด ๋ฌธ์ ๋ ๋จ์ ์กฐํฉ์ผ๋ก ํ๋ฉด ๊ฒฝ์ฐ์ ์๊ฐ ๋๋ฌด ์ปค์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ฏ๋ก,
๊ฐ์ฅ ๊ธด ๋ง๋๊ธฐ๋ฅผ ๊ณ ์ ํ ๋ค, ๋๋จธ์ง ๋ถ๋ถ์งํฉ์ ํฉ์ DP๋ก ๊ด๋ฆฌํ๋ ๊ฒ์ด ํต์ฌ์ด์๋ค.
์ด ๋ฐฉ๋ฒ์ผ๋ก ํ๋ฉด O(n * Amax) ์ ๋์ ๋ณต์ก๋๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๊ณ ,
๋ค๊ฐํ ์ฑ๋ฆฝ ์กฐ๊ฑด์ ๋ถ๋ถ์งํฉ ํฉ์ ๋ถํฌ๋ฅผ ํ์ฉํด์ ํจ์จ์ ์ผ๋ก ํ๋ณํ ์ ์๋ค.
์ง์ง ์ด ๋ฌธ์ ํ๋ค๊ฐ ๋๋ฌด ์คํธ๋ ์ค ๋ฐ์์ 4๋ฒ ๋ฌธ์ ๋ ๋ณด์ง๋ ์๊ณ ๋นก์ข ํ ๋ป ํ๋๋ฐ,
๊ทธ๋๋ ํ๊ณ ๋๋๊น ์พ๊ฐ์ ์งฑ์ธ ๊ฒ ๊ฐ๋ค ,,ใ ใ
์ค๋๋ง์ ์ฝํ ๋ฌธ์ ํ๋ ค๋๊น ๋จธ๋ฆฌ๊ฐ ์ ์ ๋์๊ฐ์ด์
์์ผ๋ก๋ ์ข ์ข ์ฝํ ๋ฌธ์ ๋ค ํธ๋ ์๊ฐ์ ๋ค์ ๊ฐ์ ธ์ผ๊ฒ ๋ค ,,๐ญ๐ญ
'๐ป ์ฝํ > ๐ Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [์ฝํ /Python] ์ธ๊ธ ์ง์ (0) | 2025.09.26 |
|---|---|
| [์ฝํ /Python] ์์ ์ (0) | 2025.09.26 |
| [์ฝํ /Python] ํ์ธํธ์น (0) | 2025.09.26 |