๐ ๋ฌธ์ ํ์
- ๊ธธ์ด N(2 ≤ N ≤ 100,000)์ ์ฉ์ก ๋ฐฐ์ด
- ๊ฐ๊ฐ์ ์ฉ์ก์ ์ฐ์ฑ ๋๋ ์์นผ๋ฆฌ์ฑ
- ์ฐ์ฑ : 1๋ถํฐ 1,000,000,000๊น์ง์ ์์ ์ ์
- ์์นผ๋ฆฌ์ฑ : -1๋ถํฐ -1,000,000,000๊น์ง์ ์์ ์ ์
- ๋ ๊ฐ์ง ์ฉ์ก์ ์์ผ๋ฉด ๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ํฉ์ด ์๋ก์ด ์ฉ์ก์ ํน์ฑ๊ฐ์ด ๋จ
- ๋ ์ฉ์ก์ ์์ด ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ํผํฉ ์ฉ์ก์ ๋ง๋ค์ด ๋ผ ๋๋ฅผ ์ฐพ์์, ๋ ์ฉ์ก ๊ฐ๊ฐ์ ํน์ฑ๊ฐ ๊ตฌํ๊ธฐ
- ์ฐ์ฑ ์ฉ์ก๊ณผ ์์นผ๋ฆฌ ์ฉ์ก์ ๋ฐ๋์ ๊ฐ๊ฐ ํ๋์ฉ ์ธ ํ์ ์์์ ์ฃผ์
์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ณด๋ฉด ์ฉ์ก์ ์๊ฐ ์ต๋ 100,000๊ฐ์ด๋ฏ๋ก, ๋จ์ํ ๋ชจ๋ ์ฉ์ก ์์ ๊ณ์ฐํ๋ ๋ฐฉ์์ O(N^2)์ผ๋ก ์๊ฐ์ด ๋งค์ฐ ์ค๋ ๊ฑธ๋ฆด ์ ์๋ค. ์ฉ์ก์ ๋ฆฌ์คํธ๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ผ๋ฏ๋ก, ๋ฆฌ์คํธ์ ๊ฐ์ฅ ์ผ์ชฝ์๋ ๊ฐ์ฅ ์์ ์ฉ์ก, ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์๋ ๊ฐ์ฅ ํฐ ์ฉ์ก์ด ์กด์ฌํ๋ค. ๋ ๊ฐ์ ํฉ์ด 0์ ๊ฐ๊น์์ง๊ธฐ ์ํด์ , ํ์ชฝ ๊ฐ์ด ํฌ๋ฉด ๋ค๋ฅธ์ชฝ ๊ฐ์ ๊ทธ๋งํผ ์์์ผ ํ๋ค. ์ฆ, ์ด ํน์ฑ์ ํ์ฉํด ๋ฆฌ์คํธ์ ์ ๋์์๋ถํฐ ๊ฐ์ ๋น๊ตํด๋๊ฐ๋ฉด, ๋ถํ์ํ ์ฐ์ฐ์ ์ค์ผ ์ ์๋ค.
๋ฆฌ์คํธ์ ์ ๋์์๋ถํฐ ๊ฐ์ ๋น๊ตํ๊ธฐ ์ํด ํฌ์ธํฐ ๋ ๊ฐ๋ฅผ ์ฌ์ฉํด์, ์ ๋์ ๊ฐ๋ฆฌํค๋๋ก ํ๋ค. ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๋ ์ฉ์ก์ ํฉ์ด 0๋ณด๋ค ํฌ๋ค๋ฉด, ๋ ๊ฐ์ ํฉ์ ๋ ์๊ฒ ๋ง๋ค๊ธฐ ์ํด ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๊ณ , ๊ทธ๋ ์ง ์๋ค๋ฉด ํฉ์ ๋ ํฌ๊ฒ ๋ง๋ค๊ธฐ ์ํด ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋์ํจ๋ค.
์ด๋ ๊ฒ ํฌํฌ์ธํฐ๋ฅผ ํ์ฉํ๋ฉด ๋ฆฌ์คํธ๋ฅผ ํ ๋ฒ๋ง ํ์ํ๋ฏ๋ก ์๊ฐ๋ณต์ก๋๋ O(N)์ด ๋๊ณ , ์ถฉ๋ถํ ์๊ฐ ๋ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
+)
๋น์ฅ ๋ ์ค๋ฅธ ๋ฐฉ๋ฒ์ ์์ ๊ฐ์ด ํฌํฌ์ธํฐ๋ฅผ ํ์ฉํ ๋ฐฉ๋ฒ์ด๋ผ ํฌํฌ์ธํฐ๋ก ํ์์ง๋ง, ํ๋์ ์ฉ์ก์ ๊ณ ์ ํ๊ณ ๋๋จธ์ง ์ฉ์ก ์ค์์ ๋ํด์ 0์ ๊ฐ๊น์ด ๊ฐ์ ์ฐพ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ผ๋ก ์ด๋ถํ์์ผ๋ก๋ ํ ์ ์๋ค. ์ด๋ถํ์์ผ๋ก ํธ๋ ๊ฒฝ์ฐ, ๋ฆฌ์คํธ์ ๊ฐ ์ฉ์ก์ ํ๋์ฉ ๊ณ ์ ํ๋ ๋ฐ O(N)์ ์๊ฐ๋ณต์ก๋, ๊ฐ ์ฉ์ก ๊ณ ์ ํ ๋๋จธ์ง ์ฉ์ก์ ๋ํ ์ด๋ถํ์์ O(logN)์ ์๊ฐ ๋ณต์ก๋๋ก, O(NlogN)์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๋๋ค.
๐ ์ฝ๋ ์ค๊ณ
- ์ฉ์ก์ ๊ฐ์ N์ ์ ๋ ฅ๋ฐ๋๋ค.
- N๊ฐ์ ์ฉ์ก ๋ฆฌ์คํธ(liquids)๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค. (์ด๋ฏธ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋ ์ํ๋ก ์ ๋ ฅ์ด ๋ค์ด์ด)
- ํฌ์ธํฐ ๋๊ฐ(left, right)๋ฅผ ๋ฆฌ์คํธ์ ์ ๋์ ์ค์ ํ๋ค.
- ํฌ์ธํฐ ๋๊ฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ํฉ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด์ง ํ์ธํ๋ฉฐ, ํฌ์ธํฐ๋ฅผ ์กฐ์ ํ๋ค.
- ํ์ฌ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ํฉ์ด ๊ฐ์ฅ 0์ ๊ฐ๊น๋ค๋ฉด, best_value, best_value_left, best_value_right์ ๊ฐฑ์ ํ๋ค.
- ํ์ฌ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ํฉ์ด 0๋ณด๋ค ์๋ค๋ฉด, left์ 1์ ๋ํ๋ค.
- ํ์ฌ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ํฉ์ด 0๋ณด๋ค ํฌ๋ค๋ฉด, right์ 1์ ๋บ๋ค.
- ์ต์ข ์ ์ผ๋ก 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ์ฉ์ก์ ๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ ์๋ ํ์ฐจ ์์ ์ฌํญ
1ํ์ฐจ
best_value = 1e9
ํ์ ์ค ์ฐพ์๋ธ ๊ฐ์ฅ 0์ ๊ฐ๊น์ด ํน์ฑ๊ฐ์ ์ ์ฅํ๋ ๋ณ์(best_value)๋ฅผ 1e9๋ก ์ค์ ํ๋ค. ๋ฌธ์ ์กฐ๊ฑด ์ ์ผ๋ถ ํ ์คํธ์ผ์ด์ค์ ๊ฒฝ์ฐ ์ค์ 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ํน์ฑ๊ฐ์ด 1e9๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๊ฐ์ด ๋ ์ ์๊ธฐ ๋๋ฌธ์ ์กฐ๊ฑด ์ ๊ฑธ๋ฆฌ์ง ์๋ ๊ฐ์ธ 1e10์ผ๋ก ์์ ํ์ฌ ์ ๋ต์ ๋ฐ์๋ค. ์ข ๋ ์ ํํ๊ฒ ํ๋ ค๋ฉด best_value๋ abs(liquids[0] + liquids[n-1])๋ก ์ด๊ธฐํ ํ๊ณ , best_value_left, best_value_right๋ฅผ ๊ฐ๊ฐ liquids[0], liquids[n-1]๋ก ์์ ํด์ฃผ๋ ๊ฒ์ด ์ข์ ๊ฒ์ด๋ค.
๐ ์ ๋ต ์ฝ๋
N = int(input())
liquids = list(map(int, input().split()))
left, right = 0, N-1
best_value = abs(liquids[left]-liquids[right])
best_value_left, best_value_right = liquids[left], liquids[right]
while left < right:
current_value = liquids[left] + liquids[right]
if abs(current_value) < abs(best_value):
best_value = current_value
best_value_left, best_value_right = liquids[left], liquids[right]
if best_value == 0:
break
if current_value < 0:
left += 1
else:
right -= 1
print(best_value_left, best_value_right)