๐กsolutions )
๐ฌ ์ฒ์์ ๋ฌธ์ ํ ๋ ๋ณ ์๊ฐ์์ด ํ์ด์,, ์ฃผ์ด์ง ์ฌ๋ฃ๋ค ์ค ๋ ์ฌ๋ฃ์ฉ ๋ฌถ์ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ itertools์ combinations์ ํตํด ๊ตฌํ๋ค๊ฐ ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๋ค. ์ฃผ์ด์ง ์ฌ๋ฃ ๊ฐ์์ ๋ฒ์๊ฐ N(1 ≤ N ≤ 15,000)์ธ ๊ฒ์ ๊ฐ์ํ๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋๋ ๊ฒ ๋น์ฐํ๋ค. ์ฐธ๊ณ ๋ก ํ์ด์ฌ์ ์ด๋น 2,000๋ง๋ฒ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๋ค๊ณ ํ๋ค.
๐ฌ ๋ ๋ฒ์งธ ์๋ -> ํด๋น ๋ฌธ์ ๋ ํฌํฌ์ธํฐ ๋ฌธ์ ์ ํ์ด๋ค. ๋จผ์ ์ ๋ ฌ์ ํ ํ ๋ ๊ฐ์ง ์ธ๋ฑ์ค ๊ฐ(left๋ ๋งจ ์ฒ์, right๋ ๋งจ ๋ ์ฌ๋ฃ๋ฅผ ๋ํ๋ด๊ธฐ ์ํจ)์ ์ ์ํ๋ค.
๐ฌ left, right๊ฐ ๊ฐ๋ฆฌํค๋ ๋ ์ฌ๋ฃ์ ํฉ์ด m๊ณผ ๊ฐ์ผ๋ฉด answer += 1, m๋ณด๋ค ์์ผ๋ฉด left += 1, m๋ณด๋ค ํฌ๋ฉด right -= 1์ ํด์ฃผ๋ฉฐ ์ธ๋ฑ์ค๋ฅผ ์กฐ์ ํ์ฌ ์ฌ๋ฃ์ ํฌ๊ธฐ๋ฅผ ์กฐ์ ํด์ค๋ค.
๐จ๐ปcode )
import sys
input = sys.stdin.readline
n = int(input())
m = int(input())
n_list = list(map(int, input().split()))
n_list.sort()
answer = 0
left, right = 0, n-1
while left < right:
if n_list[left] + n_list[right] == m:
answer += 1
left += 1
right -= 1
elif n_list[left] + n_list[right] < m:
left += 1
elif n_list[left] + n_list[right] > m:
right -= 1
print(answer)
๐description )
๋ฌธ์
์ฃผ๋ชฝ์ ์ฒ ๊ธฐ๊ตฐ์ ์์ฑํ๊ธฐ ์ํ ํ๋ก์ ํธ์ ๋์ฐ๋ค. ๊ทธ๋์ ์ผ์ฒ ๋์ฅ์ ํตํด ์ฒ ๊ธฐ๊ตฐ์ด ์ ์ ๊ฐ์ท์ ๋ง๋ค๊ฒ ํ์๋ค. ์ผ์ฒ ๋์ฅ์ ์ฃผ๋ชฝ์ ๋ช ์ ๋ฐ๋ฅด๊ธฐ ์ํ์ฌ ์ฐ๊ตฌ์ ์ฐฉ์ํ๋ ์ค ์๋์ ๊ฐ์ ์ฌ์ค์ ๋ฐ๊ฒฌํ๊ฒ ๋์๋ค.
๊ฐ์ท์ ๋ง๋๋ ์ฌ๋ฃ๋ค์ ๊ฐ๊ฐ ๊ณ ์ ํ ๋ฒํธ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ๊ฐ์ท์ ๋ ๊ฐ์ ์ฌ๋ฃ๋ก ๋ง๋๋๋ฐ ๋ ์ฌ๋ฃ์ ๊ณ ์ ํ ๋ฒํธ๋ฅผ ํฉ์ณ์ M(1 ≤ M ≤ 10,000,000)์ด ๋๋ฉด ๊ฐ์ท์ด ๋ง๋ค์ด ์ง๊ฒ ๋๋ค. ์ผ์ฒ ๋์ฅ์ ์์ ์ด ๋ง๋ค๊ณ ์๋ ์ฌ๋ฃ๋ฅผ ๊ฐ์ง๊ณ ๊ฐ์ท์ ๋ช ๊ฐ๋ ๋ง๋ค ์ ์๋์ง ๊ถ๊ธํด์ก๋ค. ์ด๋ฌํ ๊ถ๊ธ์ฆ์ ํ์ด ์ฃผ๊ธฐ ์ํ์ฌ N(1 ≤ N ≤ 15,000) ๊ฐ์ ์ฌ๋ฃ์ M์ด ์ฃผ์ด์ก์ ๋ ๋ช ๊ฐ์ ๊ฐ์ท์ ๋ง๋ค ์ ์๋์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ฌ๋ฃ์ ๊ฐ์ N(1 ≤ N ≤ 15,000)์ด ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ๋ ๋ฒ์งธ ์ค์๋ ๊ฐ์ท์ ๋ง๋๋๋ฐ ํ์ํ ์ M(1 ≤ M ≤ 10,000,000) ์ฃผ์ด์ง๋ค. ๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์ผ๋ก ์ ์งธ ์ค์๋ N๊ฐ์ ์ฌ๋ฃ๋ค์ด ๊ฐ์ง ๊ณ ์ ํ ๋ฒํธ๋ค์ด ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ๊ณ ์ ํ ๋ฒํธ๋ 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฐ์ท์ ๋ง๋ค ์ ์๋ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.