1. ๋ฌธ์ ์ค๋ช
- ์
๋ ฅ
- ์ฒซ์งธ ์ค์๋ ์ ์ฒด ์ฉ์ก์ ์ N์ด ์ ๋ ฅ๋๋ค. N์ 2 ์ด์ 100,000 ์ดํ์ด๋ค.
- ๋์งธ ์ค์๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ๋ํ๋ด๋ N๊ฐ์ ์ ์๊ฐ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ์ด ์๋ค์ ๋ชจ๋ -1,000,000,000 ์ด์ 1,000,000,000 ์ดํ์ด๋ค.
- ์ถ๋ ฅ
- ์ฒซ์งธ ์ค์ ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค์ด๋ด๋ ๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ์ถ๋ ฅํ๋ค. ์ถ๋ ฅํด์ผ ํ๋ ๋ ์ฉ์ก์ ํน์ฑ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅํ๋ค. ํน์ฑ๊ฐ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ๋ง๋ค์ด๋ด๋ ๊ฒฝ์ฐ๊ฐ ๋ ๊ฐ ์ด์์ผ ๊ฒฝ์ฐ์๋ ๊ทธ ์ค ์๋ฌด๊ฒ์ด๋ ํ๋๋ฅผ ์ถ๋ ฅํ๋ค.
2. ์ฝ๋
solution1.py
import sys
input = sys.stdin.readline
n = int(input())
ary = list(map(int, input().split()))
ary.sort()
left = 0 #๋งจ ์
right = n-1 #๋งจ ๋
min_hab = 2000000001
answer = []
while left < right:
L = ary[left]
R = ary[right]
hab = L + R
# ๋ ์ฉ์ก์ ํฉ์ด 0๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ์ฉ์ก์ ์ ๋ต์ ๋ด์์ฃผ๊ธฐ
if abs(hab) < min_hab:
min_hab = abs(hab)
answer = [L, R]
# ๋ ์ฉ์ก์ํฉ์ด 0๋ณด๋ค ์๋ค๋ฉด ์ผ์ชฝ์ ๊ฐ์ ๋๋ ค 0์ ๊ฐ๊น๊ฒ
if hab < 0:
left += 1
# ๋ฐ๋๋ก, ๋ ์ฉ์ก์ ํฉ์ด 0๋ณด๋ค ํฌ๋ค๋ฉด ์ค๋ฅธ์ชฝ์ ๊ฐ์ ์ค์ฌ์ 0์ ๊ฐ๊น๊ฒ
else:
right -= 1
print(answer[0], answer[1])
3. ํ๊ณ
- left, right : ๋ ํฌ์ธํฐ๋ ์ ๋์์ ์์ํ๋ค.
- min_hab : 0์ ๊ฐ๊น์ด ์ต์ํฉ
- ary์ ์ซ์๊ฐ -1,000,000,000 ์ด์ 1,000,000,000 ์ดํ ๋ผ๋ ์กฐ๊ฑด์ด ์์ผ๋ฏ๋ก ๋์ฌ ์ ์๋ ์ต๋ ์ฐจ์ด์ธ 2000000001๋ก ์ด๊ธฐํํด์ค๋ค.
- ํฌํฌ์ธํฐ ์ฌ์ฉ
- ์ฃผ์ด์ง๋ ary์ ์ต๋๊ธธ์ด๊ฐ 100,000 ์ด๋ฏ๋ก ํฌํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด ํผ๋ค.
- ๋ ์ฉ์ก์ ํฉ์ด 0๋ณด๋ค ์์ผ๋ฉด ๊ฐ์ ์กฐ๊ธ ๋ ๋๋ ค์ 0์ ๋ ๊ฐ๊น์์ง๋์ง ํ์ธํด์ผํ๋ฏ๋ก ์ผ์ชฝ๊ฐ์ ๋๋ ค์ค๋ค.
- ๋ ์ฉ์ก์ ํฉ์ด 0๋ณด๋ค ํฌ๋ฉด ๊ฐ์ ์กฐ๊ธ ๋ ์ค์ฌ์ 0์ ๋ ๊ฐ๊น์์ง๋์ง ํ์ธํด์ผํ๋ฏ๋ก ๋ ํฐ ๊ฐ์ธ ์ค๋ฅธ์ชฝ ๊ฐ์ ์ค์ฌ์ค๋ค.
- L๊ณผ R์ ํฉ์ ์ ๋๊ฐ(0์์ ์ผ๋ง๋ ๋จ์ด์ก๋์ง)์ ๊ธฐ์กด์ min_hab๋ฅผ ๋น๊ตํด๊ฐ๋ฉฐ ๊ณ์ํด์ min_hab์ ๋ ์์ ๊ฐ์ผ๋ก ์
๋ฐ์ดํธ ํด์ค๋ค.
- ๊ทธ๋๋ง๋ค ์์์ ๊ฐ์ answer์ ์ ๋ฐ์ดํธ ํ๋ค๊ฐ left < right๊ฐ ์๋ ์๊ฐ์ ์ข ๋ฃํ๊ณ ์ ๋ต์ ์ถ๋ ฅํ๋ค.
4. ์ฐธ๊ณ
'Algorithm > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] #2003 ์๋ค์ ํฉ 2 (Python) (0) | 2022.02.19 |
---|---|
[๋ฐฑ์ค] #2110 ๊ณต์ ๊ธฐ ์ค์น (Python) (0) | 2022.01.29 |
[๋ฐฑ์ค] #2805 ๋๋ฌด ์๋ฅด๊ธฐ (Python) (0) | 2022.01.26 |
[๋ฐฑ์ค] #14502 ์ฐ๊ตฌ์ (Python) (0) | 2022.01.21 |
[๋ฐฑ์ค] #1260 DFS์ BFS (Python) (0) | 2022.01.19 |