1. ๋ฌธ์ ์ค๋ช ๐
N๊ฐ์ ์๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ด ์ค ํ๋๋ฅผ ํํด๋ณด์. (ํํ ์๋ฅผ E
๋ผ ๋ถ๋ฅด๊ฒ ๋ค.)
์ด E
๋ฅผ ๋๋จธ์ง N-1
๊ฐ ์ค 2๊ฐ๋ฅผ ํฉํด์ ๋ง๋ค ์ ์์ผ๋ฉด ์ข์ ์
๋ผ๊ณ ๋ถ๋ฅด๊ฒ ๋ค.
์ด๋ ์ข์ ์
์ ๊ฐ์๋ ๋ช ๊ฐ ์ธ๊ฐ?
2. ๊ตฌํ ๋ฐฉ๋ฒ ๐๏ธ
KEY WORD
: ๋ง์ฃผ๋ณด๋ ํฌ ํฌ์ธํฐ
- 1๏ธโฃ N๊ฐ์ ์๋ฅผ
arr
์ด๋ ๋ฐฐ์ด์ ์ ๋ ฅ ๋ฐ์์ ์ค๋ฆ ์ฐจ์ ์ ๋ ฌํ๋ค. - 2๏ธโฃ ํฌ์ธํฐ๋ฅผ 3๊ฐ ๋์ด๋ณด์. ๊ฐ๊ฐ์ ์๋ฏธ๋ ๋ค์๊ณผ ๊ฐ๋ค.
E
= ์ข์ ์๊ฐ ๋ ์ง ์๋ ์ง ํ์ธํ๋ target์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ (0๋ถํฐ ์ ์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ค.)L
= N๊ฐ์ ์ ๋ ฌ๋ ์ ์ค ์ ์ผ ์ข์ธก์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ (์ ์ ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ๋ค.)R
= N๊ฐ์ ์ ๋ ฌ๋ ์ ์ค ์ ์ผ ์ฐ์ธก์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ (์ ์ ์ผ์ชฝ์ผ๋ก ๊ฐ๋ค.)
- 3๏ธโฃL๊ณผ R์ด ์๋ก ๋ง๋ ๋ ๊น์ง ๋ค์์ ๋ฐ๋ณตํ๋ค.
arr[E] = arr[L] + arr[R]
: ์ข์ ์์ธ ๊ฒ์ด ํ์ธ๋์๋ค. 2๏ธโฃ ๋ค์ ์์arr[E] > arr[L] + arr[R]
:L
ํฌ์ธํฐ๋ฅผ ++ ํด์ ํฉ์ด ๋์์ง๊ฒ ๋ฐ๊พผ๋ค.arr[E] < arr[L] + arr[L]
:R
ํฌ์ธํฐ๋ฅผ -- ํด์ ํฉ์ ๋ฎ์์ง๊ฒ ๋ฐ๊พผ๋ค.
- 4๏ธโฃ
E
๊ฐ ๋ฐฐ์ด์ index๋ฅผ ๋์ด์ค ๋๊น์ง 2๏ธโฃ,3๏ธโฃ์ ๋ฐ๋ณตํ๋ค.
(1) ๋ง์ฃผ๋ณด๋ ํฌ ํฌ์ธํฐ๋ฅผ ์ฐ๋ ์ด์ ? โจ
๋๋ฝ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํผํ๊ธฐ ์ํด์ ์ด๋ค. ํด๋น ๋ฌธ์ ๋ N๊ฐ์ ์์ ์์๊ฐ ํฌํจ๋๋ฏ๋ก ๋จ๋ฐฉํฅ ํฌํฌ์ธํฐ๋ฅผ ์ธ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ ์์ธ๊ฐ ๋์ฌ ์ ์๋ค.
[-5,-4,-3,-2,-1,0,1,2,3,4,5]
๋ผ๋ ๋ฐฐ์ด์์ ํ์ฌ E
๊ฐ ๊ฐ๋ฆฌํค๋ ์ซ์๊ฐ 3
์ด๋ผ๊ณ ํด๋ณด์. L๊ณผ R ํฌ์ธํฐ๊ฐ ๋จ๋ฐฉํฅ์ผ๋ก 0์์๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ๋ค๊ณ ํ๊ณ , ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ํฉ์ด target๋ณด๋ค ํฌ๋ฉด L
์ด ์์ง์ด๊ณ , ๋ฐ๋์ ๊ฒฝ์ฐ R
์ด ์์ง์ธ๋ค๊ณ ํ์ ๋, R
์ด ๋ฐฐ์ด์ ๋ฒ์ด๋ ๋๊น์ง ๋ต์ ์ฐพ์ง ๋ชปํ๋ค.
(1) ์๊ฐ๋ณต์ก๋ ๋ถ์ ๐
E
์ ํ(2000๊ฐ ) x L
๊ณผ R
๋ง๋ ๋๊น์ง ์ ํ(๋์ด ํฉ์ณ์ ์ต๋ 2000๊ฐ) = 4,000,000 ๋ฒ์ ์ฐ์ฐ์ด ํ์ํ๋ค.
๋ฐ๋ผ์ SAFE!
3. ์ฝ๋ ์๊ฐ ๐
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static int N, ans;
static int [] arr;
public static void main(String[] args) throws IOException {
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);
for (int E = 0; E < N; E++) {
int target = arr[E];
int L = 0; int R = arr.length-1;
while (L < R) {
if(L == E) { L++; continue;}
if(R == E) { R--; continue;}
int now = arr[L] + arr[R];
if(now == target) { ans++; break;}
else if (now < target) L++;
else R--;
}
}
System.out.println(ans);
}
}
4. ๋ฐฐ์ด ๊ฒ๋ค ๐ฏ
์ฝํ ํด๋ฝ ๋ฌธ์ ๋ก ๋ค์ ์ด ๋ ์์ ๋ณด๋, ๋ฐ๊ฐ์ด ๋์ฐฝ์ ๋ง๋ ๋๋์ด๋๊น? ๊ณ ๋ง๋ค.