๋ฌธ์ ํ์

๋น ๋ด๋ฆผ์ฐจ์์ธ ๋ ์ ์ ๋ฐฐ์ด nums1
๊ณผ nums2
๊ทธ๋ฆฌ๊ณ k
๊ฐ ์ฃผ์ด์ง๋ค.
k
๊ฐ์ ๊ฐ์ฅ ํฉ์ด ์์ pair
๋ฅผ ๋ฐํํด์ผํ๋ค.
ํ์ด
1๏ธโฃ PriortyQueue ์ ์ผ์ข ์ ๊ทธ๋ฆฌ๋ ๋ฒ์ ํ์ฉ
๐ก ์ฐธ๊ณ ํ Idea
์ด๋ฒ ๋ฌธ์ ๋, ์๋ฌด๋ฆฌ ์ด์ฌํ ๋ ์ฌ๋ ค๋ด๋ ์๊ฐ ์ด๊ณผ & ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ๋๋ฌธ์ ํด๊ฒฐํ์ง ๋ชปํ๊ณ ๋ค๋ฅธ ์ฌ๋์ ์์ด๋์ด๋ฅผ ์ฐธ๊ณ ํ์ฌ ํด๊ฒฐํ์๋ค.
ํต์ฌ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค.
๋จผ์ , ๋ ์์์ ํฉ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์ฐ์ ์์ ํ๋ฅผ ์ค๋นํ๋ค.nums1
๋ฐฐ์ด์ ์ธ๋ฑ์ค๋ 0 ์ผ๋ก ๊ณ ์ ํ ์ฑ,nums2
๋ฐฐ์ด์ ์ํํ๋ฉฐ ํฉ์ ๊ตฌํ๊ณ ์ฐ์ ์์ ํ์ ์ ๋ ฅํ๋ค.
์ฐ์ ์์ ํ์๋ [ nums1์ ๊ฐ, nums2 ์ ๊ฐ, nums1์ ์ธ๋ฑ์ค, nums1์ ๊ฐ +nums2์ ๊ฐ ] ์ผ๋ก ์ ๋ ฅํด์ค๋ค.
์ด์ ์ฐ์ ์์ ํ์์poll()
์ ํ๋๋ฐ ์ฌ๊ธฐ์poll()
ํ ๊ฐ์ ํ์์ ๋ ์์์ ํฉ์ด ๊ฐ์ฅ ์์ ๊ฐ์ด ์ถ์ถ๋ ๊ฒ์ด๋ค.
๊ทธ๋ ๊ฒpoll()
ํ ๊ฐ์์nums1
์ ์ธ๋ฑ์ค๋ฅผ 1 ์ถ๊ฐํด์ฃผ๊ณ (nums1
๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ด๊ณผํ์ง ์๋ ํ)
์ฐ์ ์์ ํ์ ๋ค์ ๋ฃ์ด์ค๋ค.
์ด ๊ฐ์ ๋ค์ ๋ฃ์ด์ฃผ๋ ์ด์ ๋, ์ด ๊ฐ์ ์ ๊ฑฐ๋นํ ๊ฐ๊ณผ ๊ฐ์ฅ ๋น์ทํ ์์น์ ๋ค๋ฅธ ์์ด ๋ ์ ์๊ณ ์ด ํฉ์ด ์ด๋ฏธ ๋ค์ด๊ฐ ๋ค๋ฅธ ์๋ณด๋ค ์ ์ ํฉ์ด ๋์ฌ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ง๋ก ์ค๋ช ํ๋ ์ฝ๊ฐ ์ดํดํ๊ธฐ ํ๋ค ์ ์๋๋ฐ, ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ดํด๊ฐ ์ ๋ ๊ฒ์ด๋ค.
import java.util.*;
class Solution {
public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
List<List<Integer>> ans = new ArrayList<>();
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[3] - b[3]);
for (int i = 0; i < Math.min(k, nums2.length); i++) {
pq.offer(new int[]{nums1[0], nums2[i], 0, nums1[0] + nums2[i]});
}
while (!pq.isEmpty() && k-- > 0) {
int[] poll = pq.poll();
int num1 = poll[0], num2 = poll[1];
ans.add(List.of(num1, num2));
int idx1 = poll[2];
if (idx1 + 1 < nums1.length) {
// num2์ ์ ๊ฑฐํ num1 ๋ค์ ์๋ ์์ ์กฐํฉ์ ์ถ๊ฐ
pq.offer(new int[]{nums1[idx1 + 1], num2, idx1 + 1, nums1[idx1 + 1] + num2});
}
}
return ans;
}
}
๊ฒฐ๊ณผ

๐ ํ๊ณ
์ง๊ธ๊น์ง ํ์๋ ์ฐ์ ์์ ํ ๊ด๋ จ ๋ฌธ์ ์ค์ ๊ฐ์ฅ ์ด๋ ค์ ๋ ๋ฌธ์ ์๋ค.
์ฐ์ ์์ ํ๋ฅผ ํ๋์๋ ์ด๋ค ์กฐ๊ฑด์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ์ฌ ํ์ ๋ฃ์ด์ผ ๋ต์ ๊ตฌํ ์ ์๋์ง๋ฅผ ์ ํ์ ํด์ผํ๋ ๊ฒ ๊ฐ๋ค๊ณ ๋๊ผ๋ค.