๊ตฌ๊ธ๋ง์ด ์ ์๋ผ์...์ง์ ์ฐ๋ ๋ฆฌ๋ทฐ ๐
1182๋ฒ ๋ถ๋ถ์์ด์ ํฉ๊ณผ ๊ฐ์ ์ ํ์ ๋ฌธ์ ์ด์ง๋ง ๋ฒ์์ ์๊ฐ์ ํ ๋ฑ์ผ๋ก ๋ค๋ฅธ ํ์ด ๋ฐฉ๋ฒ์ ์ ์ฉํด์ผํ๋ค.
n๊ฐ์ ์์๋ฅผ ๊ฐ์ง ์์ด์ ๋ถ๋ถ ์์ด์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ 2**n ์ด๋ผ๊ณ ํ๋ค.
์ด ๋ฌธ์ ์ ์ต๋ ๋ฒ์๋ n==40์ด๋ฏ๋ก ์ต์ ์ ๊ฒฝ์ฐ 2**40์ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ฒ๋๋ค.
๊ทธ๋์ ์ด ๋ฌธ์ ๋ ๋ฆฌ์คํธ๋ฅผ ๋ฐ์ผ๋ก ๋๋ ๋ฐ์ ํด๋นํ๋ ๋ถ๋ถ ์์ด์ ๊ตฌํ ๊ฒ์ด๋ค. ๊ทธ๋ผ ์ต์ ์ ๊ฒฝ์ฐ (2**20)*2์ด๋ค.
(2**20)*2 = 2097152 VS 2**40 = 1099511627776 ํจ์จ ใ
ใ
?
๋๋ ๋์ ๋๋ฆฌ๋ฅผ ์ฌ์ฉํด์ ๋ถ๋ถ ์์ด์ ๊ตฌํ๋ค. (์ด์ ๋ ๋ค์)
key : ๋ถ๋ถ ์์ด์ ํฉ
value : ํด๋น ๋ถ๋ถ ์์ด์ ํฉ์ด ๋์จ ํ์
์์ ๋ฅผ ์๋ก ๋ค์ด ์ฝ๋ ์ค๋ช ์ ํ์๋ฉด ์ฐ์ l=[-7,-3] r=[-2,5,8] ์ด๋ค.
lsum๊ณผ rsum์ ๊ฐ๊ฐ์ ๋ถ๋ถ ์์ด์ ํฉ์ ์ ์ฅํด์ค๋ค.
ํด๋น ๋ฆฌ์คํธ๋ฅผ ๊ฐ์ง๊ณ two-pointer๋ฅผ ํตํด ๋ถ๋ถ ์์ด์ ํฉ์ ๊ตฌํ ๊ฒ์ด๋ค.
๋จผ์ lsum๊ณผ rsum์ key๊ฐ์ sortํด์ ์ ์ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ค์๊ณผ ๊ฐ์ด ๋์ํ ๊ฒ์ด๋ค.
l=0 (lsum์์ ๊ฐ์ฅ ์์ ๊ฐ๋ถํฐ) r=len(rkey)-1 (rsum์์ ๊ฐ์ฅ ํฐ ๊ฐ๋ถํฐ)
โ ์ผ์ชฝ+์ค๋ฅธ์ชฝ > s ? r-=1 ํด์ ์ซ์๋ฅผ ์ค์ธ๋ค.
โ ์ผ์ชฝ+์ค๋ฅธ์ชฝ < s ? l+=1 ํด์ ์ซ์๋ฅผ ํค์ด๋ค.
โ ์ผ์ชฝ+์ค๋ฅธ์ชฝ == s ? ๋ง๋ค ์ ์๋ ํฉ์ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ์ถ๊ฐํ๋ค. (value*value)
์ฒ์์ 0์ value๋ฅผ 1๋ก ์ง์ ํด์ค ์ด์ ๋ ๋ค์๊ณผ ๊ฐ๋ค.
์๋ฅผ ๋ค์ด ์์ ์์ ์ฐพ๊ณ ์ํ๋ ํฉ์ด 5์ผ ๋ ์์ 5๋ง ๊ฐ์ง๊ณ ๋ง๋ค ์ ์๋ค.
ํ์ง๋ง 0์ ์ถ๊ฐํ์ง ์์ ๋ ๋ฆฌ์คํธ์ ํฉ์ผ๋ก๋ 5๋ฅผ ๊ตฌํ ์ ์๋ค.
์ฆ, 0์ ํด๋น ๋ฆฌ์คํธ์์ ์๋ฌด ์ซ์๋ ์ ํํ์ง ์์ ๊ฒฝ์ฐ๋ฅผ ๋ปํ๋ค.
๋์ ๋๋ฆฌ๋ฅผ ์ฌ์ฉํ ์ด์ ๋ ๋ค์๊ณผ ๊ฐ๋ค.
์๋ฅผ ๋ค์ด ์์ด 1 1 1 1์์ ํฉ์ด 2๊ฐ ๋ ๋๋ฅผ ์ฐพ๊ณ ์ ํ๋ค๋ฉด
๋จผ์ lsum=[0 1 1 2] rsum=[0 1 1 2]๊ฐ ๋ ๊ฒ์ด๋ค. ์ด ๋ ์ฒ์ 2๊ฐ ๋๋ ์๊ฐ์ ๋ค์๊ณผ ๊ฐ๋ค.
์ด๋ l+=1ํ ๊ฒ์ธ๊ฐ r-=1 ํ ๊ฒ์ธ๊ฐ?
๊ณ ๋ฏผํ๋ค๊ฐ ๊ทธ๋ฅ counter๋ฅผ ํตํด ์ด๋ฐ ๊ฒฝ์ฐ๋ฅผ ์์ ์ฃผ๊ณ ์ ๋์ ๋๋ฆฌ๋ฅผ ์ฌ์ฉํ์๋ค!
๋ง์ง๋ง์ผ๋ก ๋ฐ๋ก๊ฐ ์๋ค. ๊ตฌํ๊ณ ์ ํ๋ ํฉ s๊ฐ 0์ธ ๊ฒฝ์ฐ์ด๋ค.
์ฒ์ l,rsum์ ์ด๊ธฐํ ํด์ค 0=1์ ์๋ฌด๊ฒ๋ ์ ํํ์ง ์์ ๊ฒฝ์ฐ์ด๋ค.
ํ์ง๋ง ๋ ๋ฆฌ์คํธ์์ ๋ ๋ค ์๋ฌด๊ฒ๋ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ๋ ์๋๋ค. ๋ถ๋ถ์์ด์ ํฌ๊ธฐ๊ฐ ์์๋ผ๋ ์กฐ๊ฑด์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋์ ๋ง์ง๋ง์ s==0์ด๋ฉด res-=1์ ํ๋ค.
(๊ตฌํ๊ณ ์ํ๋ ํฉ์ด 0์ด ์๋๊ฒฝ์ฐ์๋ res์ 0 0 ์ธ ๊ฒฝ์ฐ๊ฐ ์ถ๊ฐ๋์ง ์๊ธฐ ๋๋ฌธ์ ์๊ด์๋ค.)
Result
import sys
from itertools import combinations
from collections import defaultdict
n,s=map(int,sys.stdin.readline().split())
m=list(map(int, sys.stdin.readline().split()))
l=m[:n//2]
r=m[n//2:]
lsum=defaultdict(int)
rsum=defaultdict(int)
lsum[0]=1
rsum[0]=1
for i in range(1,len(l)+1):
for com in combinations(l,i):
lsum[sum(com)]+=1
for i in range(1,len(r)+1):
for com in combinations(r,i):
rsum[sum(com)]+=1
lkey=sorted(lsum.keys())
rkey=sorted(rsum.keys())
res=0
l=0
r=len(rkey)-1
while l<len(lkey) and r>=0:
if lkey[l]+rkey[r]==s:
res+=(lsum[lkey[l]]*rsum[rkey[r]])
l+=1
r-=1
elif lkey[l]+rkey[r]>s:
r-=1
else:
l+=1
if s==0:
res-=1
print(res)
๋๋ ๊ฐ๊ฐ๊ฐ๊ฐ๊ฐ์ด๋ ค์ ๋ค... ์ด๋ ๊ฒ ๊ณ ๋ คํด์ผ ํ ๊ฒ ๋ง์ ๋ฌธ์ ๋ ์์ง ๋๋ฌด ๋ฒ๊ฒ๋คใ ใ
'๐ Algorithm > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python] ํ๋ก๊ทธ๋๋จธ์ค ํฉ์น ํ์ ์๊ธ (0) | 2021.03.11 |
---|---|
[Python] ๋ฐฑ์ค 7453 (2) | 2021.03.09 |
[Python] ๋ฐฑ์ค 1167, 1967 (0) | 2021.03.08 |
[Python] ๋ฐฑ์ค 10917 (0) | 2021.03.07 |
[Python] ๋ฐฑ์ค 2089 (0) | 2021.03.04 |