[BOJ][๐ก5][๋ฐฑ์ค#02470] ๋ ์ฉ์ก
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
KOI ๋ถ์ค ๊ณผํ์ฐ๊ตฌ์์์๋ ๋ง์ ์ข ๋ฅ์ ์ฐ์ฑ ์ฉ์ก๊ณผ ์์นผ๋ฆฌ์ฑ ์ฉ์ก์ ๋ณด์ ํ๊ณ ์๋ค. ๊ฐ ์ฉ์ก์๋ ๊ทธ ์ฉ์ก์ ํน์ฑ์ ๋ํ๋ด๋ ํ๋์ ์ ์๊ฐ ์ฃผ์ด์ ธ์๋ค. ย ์ฐ์ฑ ์ฉ์ก์ ํน์ฑ๊ฐ์ 1๋ถํฐ 1,000,000,000๊น์ง์ ์์ ์ ์๋ก ๋ํ๋ด๊ณ , ์์นผ๋ฆฌ์ฑ ์ฉ์ก์ ํน์ฑ๊ฐ์ -1๋ถํฐ -1,000,000,000๊น์ง์ ์์ ์ ์๋ก ๋ํ๋ธ๋ค. ๊ฐ์ ์์ ๋ ์ฉ์ก์ ํผํฉํ ์ฉ์ก์ ํน์ฑ๊ฐ์ ํผํฉ์ ์ฌ์ฉ๋ ๊ฐ ์ฉ์ก์ ํน์ฑ๊ฐ์ ํฉ์ผ๋ก ์ ์ํ๋ค. ์ด ์ฐ๊ตฌ์์์๋ ๊ฐ์ ์์ ๋ ์ฉ์ก์ ํผํฉํ์ฌ ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค๋ ค๊ณ ํ๋ค.ย ์๋ฅผ ๋ค์ด, ์ฃผ์ด์ง ์ฉ์ก๋ค์ ํน์ฑ๊ฐ์ด [-2, 4, -99, -1, 98]์ธ ๊ฒฝ์ฐ์๋ ํน์ฑ๊ฐ์ด -99์ธ ์ฉ์ก๊ณผ ํน์ฑ๊ฐ์ด 98์ธ ์ฉ์ก์ ํผํฉํ๋ฉด ํน์ฑ๊ฐ์ด -1์ธ ์ฉ์ก์ ๋ง๋ค ์ ์๊ณ , ์ด ์ฉ์ก์ด ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ด๋ค. ์ฐธ๊ณ ๋ก, ๋ ์ข ๋ฅ์ ์์นผ๋ฆฌ์ฑ ์ฉ์ก๋ง์ผ๋ก๋ ํน์ ๋ ์ข ๋ฅ์ ์ฐ์ฑ ์ฉ์ก๋ง์ผ๋ก ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ํผํฉ ์ฉ์ก์ ๋ง๋๋ ๊ฒฝ์ฐ๋ ์กด์ฌํ ์ ์๋ค. ์ฐ์ฑ ์ฉ์ก๊ณผ ์์นผ๋ฆฌ์ฑ ์ฉ์ก์ ํน์ฑ๊ฐ์ด ์ฃผ์ด์ก์ ๋, ์ด ์ค ๋ ๊ฐ์ ์๋ก ๋ค๋ฅธ ์ฉ์ก์ ํผํฉํ์ฌ ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค์ด๋ด๋ ๋ ์ฉ์ก์ ์ฐพ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ ์ฒด ์ฉ์ก์ ์ N์ด ์ ๋ ฅ๋๋ค. N์ 2 ์ด์ 100,000 ์ดํ์ด๋ค. ๋์งธ ์ค์๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ๋ํ๋ด๋ N๊ฐ์ ์ ์๊ฐ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ์ด ์๋ค์ ๋ชจ๋ -1,000,000,000 ์ด์ 1,000,000,000 ์ดํ์ด๋ค. N๊ฐ์ ์ฉ์ก๋ค์ ํน์ฑ๊ฐ์ ๋ชจ๋ ๋ค๋ฅด๊ณ , ์ฐ์ฑ ์ฉ์ก๋ง์ผ๋ก๋ ์์นผ๋ฆฌ์ฑ ์ฉ์ก๋ง์ผ๋ก ์ ๋ ฅ์ด ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๋ ์์ ์ ์๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค์ด๋ด๋ ๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ์ถ๋ ฅํ๋ค. ์ถ๋ ฅํด์ผ ํ๋ ๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํ๋ค. ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค์ด๋ด๋ ๊ฒฝ์ฐ๊ฐ ๋ ๊ฐ ์ด์์ผ ๊ฒฝ์ฐ์๋ ๊ทธ ์ค ์๋ฌด๊ฒ์ด๋ ํ๋๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
5
-2 4 -99 -1 98
์ถ๋ ฅ
-99 98
My Sol
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
N = int(input().rstrip())
arr = list(map(int, input().rstrip().split()))
maxH = []
minH = []
for a in arr:
heappush(maxH, -a)
heappush(minH, a)
diff = float('inf')
mx, mn = -heappop(maxH), heappop(minH)
while mx > mn:
if diff > abs(mn+mx):
diff = abs(mn+mx)
rmn, rmx = mn, mx
if not diff: break
if mx+mn < 0:
mn = heappop(minH)
else :
mx = -heappop(maxH)
print(rmn, rmx)
heapq๋ฅผ ์ด์ฉํด ์์ชฝ์์ ์ขํ์ค๋ฉฐ ํฌ๊ธฐ๋ฅผ ๋น๊ตํ์๋ค. heapq๋ ์ ๋ ฌ์ ์๊ฐ๋ณต์ก๋๊ฐ O(nlogn)์ด๋ฏ๋ก ํฌ๊ธฐ์์ผ๋ก ์ต๋ํ๊ณผ ์ต์ํ์ ๊ตฌํํ์ฌ ์์ชฝ์์ ๋น๊ตํ๋ฉฐ ๊ฐฑ์ ํ๋ฉฐ ์ต์ ์ฐจ์ด๋ฅผ ๊ธฐ๋กํ์๊ณ , ์ด ๊ฐฑ์ ๋์ ์์ ๊ฐ๊ณผ ํฐ ๊ฐ์ ๊ธฐ๋กํ์ฌ ์ถ๋ ฅํ์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys
N = int(sys.stdin.readline())
A = sorted(map(int, sys.stdin.readline().split()))
res = 2000000002
start = 0
end = len(A)-1
one = 0
two = 0
while start<end:
temp = A[start] + A[end]
val = abs(temp)
if res>val:
res = val
one = A[start]
two = A[end]
if temp>0:
end-=1
else:
start+=1
print(one, two)
๋ด ์ฐ์ฐ์๊ฐ์ ์ ๋ฐ์ ํด๋นํ๋ ํ์ด๋ฅผ ์ฐพ์ ๋ถ์ํด๋ณด๋ ค ํ๋ค. heapq์ ๋ฃ์ ๊ฒ์ด ์๋ sorted๋ก ์ ๋ ฌํด์ ์๊ณผ ๋ค๋ฅผ ๋๋์ด ์ขํ์๋ค. ํ๋ณธ์ ํฌ๊ธฐ๊ฐ 10๋ง์ธ๋ฐ ์ ๋ ฌ์ ํด๋ ์๊ฐ์ด ํฌ๊ฒ ๋์ง ์๋ ๊ฒ์ด ์ด์ํ ๋ฐ๋ฆ์ด๋ค. ์๋ง ์ต๋ 10๋ง์ ํด๋๊ณ 10๋ง๋งํผํ์ง ์์๊ธฐ ๋๋ฌธ์ผ ๊ฒ์ด๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ