1. ๋ฌธ์ ์ค๋ช ๐
- ์ฉ์ก๋ง๋ค ํน์๊ฐ์ด ์กด์ฌ
- ๋ ์ฉ์ก์ ๊ณจ๋ผ์ ๋์ ํน์ ๊ฐ์ ํฉํ์ ๋, ๊ทธ ํฉ์ด 0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์กฐํฉ์ ๊ตฌํ์ฌ๋ผ
2. ์ ๊ทผ ๋ฐฉ์ ๐๏ธ
KEY WORD
: Two way Two pointer
- ์ฉ์ก์ ํน์๊ฐ์ 1์ฐจ์ ๋ฐฐ์ด์ ์ ๋ ฅ๋ฐ๊ณ , ํด๋น ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
- index = 0์ L ํฌ์ธํฐ, index = N-1์ R ํฌ์ธํฐ๋ฅผ ๋๋ค
L+R > 0
์ผ ๊ฒฝ์ฐ, R ํฌ์ธํฐ๋ฅผ ํ ์นธ ํ์ง ์์ผ์ ํฉ์ ํํฅ์กฐ์ ํ๋ค.L-R <= 0
์ผ ๊ฒฝ์ฐ, L ํฌ์ธํฐ๋ฅผ ํ ์นธ ์ ์ง ์์ผ์ ํฉ์ ์ํฅ์กฐ์ ํ๋ค.- 0์ ๊ฐ๊น์ด ๊ฐ์ ๊ตฌํด์ผํจ์ผ๋ก, ๋ ์ฌ์ด์ ํฉ์ ์ ๋๊ฐ์ด ์ต์์ธ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค.
(์๋ํ๋ฉด, ๋ ํฌ์ธํฐ ์ฌ์ด์ ํฉ์ ์ ๋๊ฐ์ด ์ปค์ง์๋ก 0์์ ๋ฉ์ด์ง๊ธฐ ๋๋ฌธ์ด๋ค.)
(1) ๋จ๋ฑกํญ ํฌ ํฌ์ธํฐ๋ก ๋ต์ ๊ตฌํ ์ ์๋ ์ด์
์์ ์์์ ๊ฒฝ์ฐ, 0์ ์ ์ผ ๊ฐ๊น์ด ๊ฐ์ ๋ง์ง๋ง ๊ทธ ์ค -4 + 4๊ฐ ์๋ค. ํ์ง๋ง ๋จ๋ฐฉํฅ์ผ๋ก ์์ง์ด๋ฉด ๊ฐ์ด ๋ฐฐ์ด ๋๊น์ง 0๋ณด๋ค ์์์ R๋ง ๋ฐฐ์ด ๋๊น์ง ์์ง์ธ๋ค. ๋ฐ๋ผ์ ๋ฌธ์ ์ ํด๋ต์ ๊ตฌํ ์๊ฐ ์๋ค.
3. ์ฝ๋ ์๊ฐ ๐
import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
/*
*
* */
public static void main(String[] args) throws IOException {
int N;
int [] arr;
int [] ans = new int [2];
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
arr = new int[N];
StringTokenizer st = new StringTokenizer(br.readLine());
for (int i = 0; i < N; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr);
int L = 0; int R = N-1; int min = Integer.MAX_VALUE;
while (L < R){
int sum = arr[L] + arr[R];
if(Math.abs(sum) < Math.abs(min)) {
min = sum;
ans[0] = arr[L];
ans[1] = arr[R];
}
if(sum < 0) L++;
else R--;
}
System.out.println(ans[0] + " " + ans[1]);
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
์๋ฐฉํฅ ํฌ ํฌ์ธํฐ์ ์ ํ์ ์ธ ๋ฌธ์ ๋ฅผ ํ์๋ค. ํฌ ํฌ์ธํฐ ๋ฌธ์ ์ ์ค์ํ ์ ์ ๋ฌธ์ ์์ ์ด๋ค ๋ฐฉ์์ผ๋ก ํฌ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ์ง ๊ฐ์ ์ก๋ ๊ฒ์ด๋ค. ์ด๋ฅผ ์ํด์๋ ๋ค์ํ ํฌ ํฌ์ธํฐ ๋ฌธ์ ๋ฅผ ํ์ด ๋ณด์์ผ ํ๋ค. ์ด๋ฒ ๋ฌธ์ ๋ ๋ฌธ์ ์ ํ์ ์๊ณ ์ ๊ทผํ์์ผ๋ก, ์ฐ์ต์ ๋์์ง๋ง, ํด๋ต ์ฝ๋๋ฅผ ์ค๊ณํ๋ ๋ฅ๋ ฅ์ ํค์ฐ์ง ๋ชปํ ๊ฒ ๊ฐ๋ค.