Add some solves

Author: colorbox

373/step1_fix.cpp

@@ -0,0 +1,66 @@
+/*
+step1 after review
+*/
+
+class Solution {
+public:
+  vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
+    int64_t left = nums1.front() + nums2.front();
+    int64_t right = nums1.back() + nums2.back() + 1;
+    while (left < right) {
+      int64_t mid = left + (right - left) / 2;
+      int count = count_less_pairs(nums1, nums2, mid, k);
+      if (count >= k) {
+        right = mid;
+      } else {
+        left = mid + 1;
+      }
+    }
+
+    int max_sum = left;
+    priority_queue<SumPair> sum_pairs;
+    for (int num1 : nums1) {
+      for (int num2 : nums2) {
+        if (num1 + num2 > max_sum) {
+          break;
+        }
+        sum_pairs.push({num1 + num2, {num1, num2}});
+        if (sum_pairs.size() > k) {
+          sum_pairs.pop();
+          if (num1 + num2 == sum_pairs.top().sum) {
+            break;
+          }
+        }
+      }
+    }
+
+    vector<vector<int>> answer;
+    while (!sum_pairs.empty()) {
+      answer.push_back(sum_pairs.top().pair);
+      sum_pairs.pop();
+    }
+    return answer;
+  }
+ private:
+
+  struct SumPair {
+    int sum;
+    vector<int> pair;
+
+    bool operator< (const SumPair& other) const {
+      return sum < other.sum;
+    }
+  };
+ 
+  int count_less_pairs(vector<int> nums1, vector<int>nums2, int num, int limit) {
+    int num_pairs = 0;
+    for (int num1 : nums1) {
+      auto it = upper_bound(nums2.begin(), nums2.end(), num - num1);
+      num_pairs += distance(nums2.begin(), it);
+      if (num_pairs > limit) {
+        return limit;
+      }
+    }
+    return num_pairs;
+  }
+};

373/step2_2.cpp

@@ -0,0 +1,38 @@
+/*
+step2 after review
+*/
+class Solution {
+ public:
+  vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
+    priority_queue<SumIndex> sum_index;
+    set<vector<int>> visited;
+    vector<vector<int>> answer;
+    sum_index.push({nums1[0] + nums2[0], {0, 0}});
+    while (answer.size() < k) {
+      int i = sum_index.top().index[0];
+      int j = sum_index.top().index[1];
+      sum_index.pop();
+      answer.push_back({nums1[i], nums2[j]});
+      if (i + 1 < nums1.size() && !visited.contains({i + 1, j})) {
+        sum_index.push({nums1[i + 1] + nums2[j], {i + 1, j}});
+        visited.insert({i + 1, j});
+      }
+      if (j + 1 < nums2.size() && !visited.contains({i, j + 1})) {
+        sum_index.push({nums1[i] + nums2[j + 1], {i, j + 1}});
+        visited.insert({i, j + 1});
+      }
+    }
+
+    return answer;
+  }
+
+ private:
+  struct SumIndex {
+    int sum;
+    vector<int> index;
+
+    bool operator< (const SumIndex& other) const {
+      return sum > other.sum;
+    }
+  };
+};

373/step3_3_fix.cpp

@@ -0,0 +1,39 @@
+/*
+{i + 1, j}と{i, j + 1}をpriority_queueにいれる時に、{i + 1, j - 1}と{i - 1, j + 1}がvisitedに含まれているかを確認して効率化するパターン
+条件判定部分が無駄に複雑なので関数化したいが、いい感じにできないのでそのままにしている
+*/
+class Solution {
+ public:
+  vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
+    priority_queue<SumIndex, vector<SumIndex>, greater<SumIndex>> sum_index;
+    vector<vector<int>> minimum_k_pair;
+    set<vector<int>> visited;
+    sum_index.push({nums1[0] + nums2[0], 0, 0});
+    while (minimum_k_pair.size() < k && sum_index.size() > 0) {
+      int i = sum_index.top().num1_index;
+      int j = sum_index.top().num2_index;
+      sum_index.pop();
+      minimum_k_pair.push_back({nums1[i], nums2[j]});
+      if (i + 1 < nums1.size() && !visited.contains({i + 1, j}) && (j == 0 || visited.contains({i + 1, j - 1}))) {
+        sum_index.push({nums1[i + 1] + nums2[j], i + 1, j});
+        visited.insert({i + 1, j});
+      }
+      if (j + 1 < nums2.size() && !visited.contains({i, j + 1}) && (i == 0 || visited.contains({i - 1, j + 1}))) {
+        sum_index.push({nums1[i] + nums2[j + 1], i, j + 1});
+        visited.insert({i, j + 1});
+      }
+    }
+    return minimum_k_pair;
+  }
+
+ private:
+  struct SumIndex {
+    int sum;
+    int num1_index;
+    int num2_index;
+
+    bool operator> (const SumIndex& other) const {
+      return sum > other.sum;
+    }
+  };
+};

373/step3_3_no_set.cpp

@@ -0,0 +1,37 @@
+/*
+https://github.com/colorbox/leetcode/pull/25#discussion_r1759948961
+https://github.com/ryoooooory/LeetCode/pull/17/files#diff-1288c579d3218c63304f49c9c9a04568c3305bef4a38145045001270d6f6b5c6
+を参考としたコード
+右・下移動をpriority_queueから取り出すごとに行うが、下移動は一番上にいるときのみに限って行うことで、衝突を避ける。
+*/
+class Solution {
+ public:
+  vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
+    priority_queue<SumIndex> k_pair_candidates;
+    vector<vector<int>> minimum_k_pair;
+    k_pair_candidates.push({nums1[0] + nums2[0], 0, 0});
+    while (minimum_k_pair.size() < k && k_pair_candidates.size() > 0) {
+      auto [sum, i, j] = k_pair_candidates.top();
+      k_pair_candidates.pop();
+      minimum_k_pair.push_back({nums1[i], nums2[j]});
+      if (j == 0 && i + 1 < nums1.size()) {
+        k_pair_candidates.push({nums1[i + 1] + nums2[j], i + 1, j});
+      }
+      if (j + 1 < nums2.size()) {
+        k_pair_candidates.push({nums1[i] + nums2[j + 1], i, j + 1});
+      }
+    }
+    return minimum_k_pair;
+  }
+
+ private:
+  struct SumIndex {
+    int sum;
+    int num1_index;
+    int num2_index;
+
+    bool operator< (const SumIndex& other) const {
+      return sum > other.sum;
+    }
+  };
+};

373/step3_3_no_set_2.cpp

@@ -0,0 +1,36 @@
+/*
+https://github.com/colorbox/leetcode/pull/25#discussion_r1766166184
+https://github.com/seal-azarashi/leetcode/pull/10/files#diff-1738c7b2b125c2158f2d6502754f18d9c179c559fca2b92d22d1a6bfc16ce429
+上記を参考にしたコード
+一旦1行目の候補をすべてpriority_queueにpushし、その後取り出した候補を一つずつ降下させることで重複なく候補を取り出す。
+*/
+class Solution {
+ public:
+  vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
+    priority_queue<SumIndex> k_pair_candidates;
+    vector<vector<int>> minimum_k_pair;
+    for (int i = 0; i < nums1.size(); i++) {
+      k_pair_candidates.push({nums1[i] + nums2[0], i, 0});
+    }
+    while (minimum_k_pair.size() < k && k_pair_candidates.size() > 0) {
+      auto [sum, i, j] = k_pair_candidates.top();
+      k_pair_candidates.pop();
+      minimum_k_pair.push_back({nums1[i], nums2[j]});
+      if (j + 1 < nums2.size()) {
+        k_pair_candidates.push({nums1[i] + nums2[j + 1], i, j + 1});
+      }
+    }
+    return minimum_k_pair;
+  }
+
+ private:
+  struct SumIndex {
+    int sum;
+    int num1_index;
+    int num2_index;
+
+    bool operator< (const SumIndex& other) const {
+      return sum > other.sum;
+    }
+  };
+};