๐ก ํฌ ํฌ์ธํฐ
: ๋ฐฐ์ด์ด๋ ๋ฆฌ์คํธ์์ '๋ ๊ฐ์ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ์ฌ 'ํน์ ๊ตฌ๊ฐ์ ๋ง์กฑํ๋ ๋ถ๋ถ ๊ตฌ๊ฐ'์ ํจ์จ์ ์ผ๋ก ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ
- ๋ณดํต ์ผ์ชฝ ํฌ์ธํฐ์ ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉฐ, ๊ฐ๊ฐ ํ์ ๋ฒ์์ ์์๊ณผ ๋์ ๊ฐ๋ฆฌํต๋๋ค.
- ์ผ์ชฝ ํฌ์ธํธ๋ฅผ ๊ณ ์ ํ ์ํ์์ ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ์ด๋ํ๊ฑฐ๋, ์กฐ๊ฑด์ ๋ฐ๋ผ ์ผ์ชฝ ํฌ์ธํธ๋ ์ด๋ํ๋ฉฐ ํ์ํฉ๋๋ค.
- ํ ๋ฒ์ ๋ฐ๋ณต์ผ๋ก ๋ชจ๋ ์์๋ฅผ ์ฒ๋ฆฌํ๋ ์ ํ ์๊ฐ ๋ณต์ก๋ O(n)์ ๊ฐ์ง๋๋ค. ์ฆ, ์ํ ์๊ฐ์ด ๋ฐฐ์ด์ด๋ ๋ฆฌ์คํธ ํฌ๊ธฐ์ ๋น๋กํฉ๋๋ค.
- ํ์ ๋ฒ์ ๋ด์์ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์์๋ฅผ ์ฐพ๊ฑฐ๋, ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ถ๋ถ ๋ฐฐ์ด์ ๊ธธ์ด ๋ฑ์ ๊ณ์ฐํ๋ ๋ฌธ์ ์ ํ์ฉ
๋จ๊ณ
- ๋ฐฐ์ด ๋๋ ๋ฆฌ์คํธ์ ์์ ์์น์ ์ฒซ ๋ฒ์งธ ํฌ์ธํธ์ ๋ ๋ฒ์งธ ํฌ์ธํธ๋ฅผ ์ค์ ํฉ๋๋ค.
- ๋ ํฌ์ธํฐ ์ฌ์ด์ ๊ตฌ๊ฐ์ ์กฐ์ฌํ๋ฉฐ ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํฉ๋๋ค.
- ํฌ์ธํฐ๋ฅผ ์ด๋์ํค๋ฉฐ ๋ค์ ๊ตฌ๊ฐ์ ํ์ํฉ๋๋ค.
์ข ๋ฅ
๊ณ ์ ๊ธธ์ด ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ๊ณ ์ ๋ ๊ธธ์ด์ ์๋์ฐ(์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํ๋ ๊ตฌ๊ฐ)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ด๋ ๋ฆฌ์คํธ๋ฅผ ํ์ํฉ๋๋ค.
- ์๋์ฐ์ ํฌ๊ธฐ๋ฅผ ์ผ์ ํ๊ฒ ์ ์งํ๋ฏ๋ก ์ผ์ชฝ ํฌ์ธํฐ์ ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ ํจ๊ป ์ด๋์ํต๋๋ค.
- ๋ถ๋ถ ๋ฐฐ์ด์ ํฉ์ด๋ ํ๊ท ์ ๊ณ์ฐํ๋ ๋ฌธ์ ์ ํ์ฉํฉ๋๋ค.
๊ฐ๋ณ ๊ธธ์ด ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
- ์๋์ฐ์ ํฌ๊ธฐ๋ฅผ ํ์์ ๋ฐ๋ผ ๋ณ๊ฒฝํ๋ฉด์ ํฌ์ธํฐ๋ฅผ ์ด๋์ํต๋๋ค.
- ์ต์ ๊ธธ์ด ๋ถ๋ถ ๋ฐฐ์ด์ด๋ ์ต๋ ๊ธธ์ด ๋ถ๋ถ ๋ฐฐ์ด์ ์ฐพ๋ ๋ฌธ์ ์ ํ์ฉํฉ๋๋ค.
๐ ๋ฐฑ์ค 1253๋ฒ

- ํฌ ํฌ์ธํฐ๋ก ํธ๋ ๋ฌธ์ ์ธ์ง ์ด๋ป๊ฒ ์๊น?
- ๋ฐฐ์ด์ ๊ฐ ์์์ ๋ํด ์ข์ ์์ธ์ง ํ์ธํด์ผ ํฉ๋๋ค.
- ๋ค๋ฅธ ์ ๋ ๊ฐ, ์ฆ ๋ ๊ฐ์ ์์๋ก ํ์ธํ๋ฏ๋ก ํฌ์ธํฐ 2๊ฐ๋ฅผ ์ค์ ํด์ผ ํ๋ฏ๋ก ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ์ ํด๋นํฉ๋๋ค.
- ํฌ์ธํฐ๋ ์ด๋ป๊ฒ ์ด๋ํด์ผ ํ ๊น?
- ์๊ธฐ ์์ ์ ์ธ๋ฑ์ค๋ ์ ์ธ
- ๋ฐฐ์ด์ ์ ๋ ฌ ํ ์ผ์ชฝ ํฌ์ธํฐ๋ ๊ฐ์ฅ ์์ ๊ฐ๋ถํฐ, ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ ๊ฐ์ฅ ํฐ ๊ฐ๋ถํฐ ์ถ๋ฐํฉ๋๋ค.
- ๋ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฆฌํค๋ ์์์ ํฉ์ด ๋ชฉํ๊ฐ๋ณด๋ค ํฌ๋ฉด ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ 1 ๊ฐ์์ํค๊ณ , ์์ผ๋ฉด ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ 1 ์ฆ๊ฐ์ํต๋๋ค.
- ๋ฐฐ์ด์ด ์ ๋ ฌ๋ ์ํ๋ผ๋ฉด ์ผ์ชฝ ํฌ์ธํฐ๋ฅผ 1 ์ฆ๊ฐ์ํค๋ฉด ๋ ํฐ ๊ฐ์ ๋ํ ์ ์๊ณ , ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ฅผ 1 ๊ฐ์์ํค๋ฉด ๋ ์์ ๊ฐ์ ๋ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
- ๊ทธ ์ธ ์ฃผ์์ฌํญ
- ์์ ๊ฐ์๋ ์ต๋ 2000๊ฐ๋ก for๋ฌธ์ ๋๋ ค๋ ๊ด์ฐฎ์ ์์ ๋๋ค.
- ์์์ ๊ฐ์ ์ต๋ 1,000,000,000์ผ๋ก longํ์ ์ฌ์ฉํฉ๋๋ค.
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// ์ด๊ธฐํ
int n = sc.nextInt();
long[] arr = new long[n];
for(int i=0; i<n; i++)
arr[i] = sc.nextLong();
// ์ ๋ ฌ
Arrays.sort(arr);
int count = 0; //์ข์ ์์ ๊ฐ์
// ์ํํ๋ฉด์ ์ข์ ์์ธ์ง ํ์ธ
for(int i=0; i<n; i++) {
int left = 0; // ์ผ์ชฝ ํฌ์ธํฐ๋ ๊ฐ์ฅ ์์ ๊ฐ๋ถํฐ
int right = n-1; // ์ค๋ฅธ์ชฝ ํฌ์ธํฐ๋ ๊ฐ์ฅ ํฐ ๊ฐ๋ถํฐ
while(left < right) {
// ์๊ธฐ ์์ ์ ์ ์ธ(๋ค์ ์ธ๋ฑ์ค๋ก ์คํต)
if(left==i || right==i) {
if(left==i) left++;
else right--;
continue;
}
// ๋ํ ๊ฐ ํ์ธ
long sum = arr[left] + arr[right];
if(sum == arr[i]) {
count++;
break;
} else if(sum > arr[i]) {
// ํฉ์ด ๋ ํฌ๋ค๋ฉด ๋ ์์ ์๋ฅผ ๋ํด์ผํจ -> right๋ฅผ ํ ์นธ ์์ผ๋ก
right--;
} else if(sum < arr[i]) {
// ํฉ์ด ์๋ค๋ฉด ๋ ํฐ ์๋ฅผ ๋ํด์ผํจ -> left๋ฅผ ํ ์นธ ๋ค๋ก
left++;
}
}
}
System.out.println(count);
}
}
์ฐธ๊ณ ์๋ฃ
