🤖 Daily Challenge: Problem #3507

include/leetcode/problems/minimum-pair-removal-to-sort-array-i.h

@@ -0,0 +1,18 @@
+#include "leetcode/core.h"
+
+namespace leetcode {
+namespace problem_3507 {
+
+using Func = std::function<int(vector<int>&)>;
+
+class MinimumPairRemovalToSortArrayISolution : public SolutionBase<Func> {
+ public:
+  //! 3507. Minimum Pair Removal to Sort Array I
+  //! https://leetcode.com/problems/minimum-pair-removal-to-sort-array-i/
+  int minimumPairRemoval(vector<int>& nums);
+
+  MinimumPairRemovalToSortArrayISolution();
+};
+
+}  // namespace problem_3507
+}  // namespace leetcode

src/leetcode/problems/minimum-pair-removal-to-sort-array-i.cpp

@@ -0,0 +1,56 @@
+#include "leetcode/problems/minimum-pair-removal-to-sort-array-i.h"
+
+namespace leetcode {
+namespace problem_3507 {
+
+// 辅助函数：检查数组是否非递减
+static bool isNonDecreasing(const vector<int>& arr) {
+  for (size_t i = 1; i < arr.size(); ++i) {
+    if (arr[i] < arr[i - 1]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// 策略1：模拟操作过程
+static int solution1(vector<int>& nums) {
+  vector<int> cur = nums;  // 拷贝一份，避免修改原数组
+  int operations = 0;
+
+  // 当数组长度大于1且尚未有序时继续操作
+  while (cur.size() > 1 && !isNonDecreasing(cur)) {
+    // 找到最小和的相邻对
+    int minSum = INT_MAX;
+    size_t idx = 0;
+    for (size_t i = 0; i < cur.size() - 1; ++i) {
+      int sum = cur[i] + cur[i + 1];
+      if (sum < minSum) {
+        minSum = sum;
+        idx = i;
+      }
+    }
+
+    // 合并该对
+    int newVal = cur[idx] + cur[idx + 1];
+    cur.erase(cur.begin() + idx, cur.begin() + idx + 2);
+    cur.insert(cur.begin() + idx, newVal);
+    ++operations;
+  }
+
+  return operations;
+}
+
+MinimumPairRemovalToSortArrayISolution::MinimumPairRemovalToSortArrayISolution() {
+  setMetaInfo({.id = 3507,
+               .title = "Minimum Pair Removal to Sort Array I",
+               .url = "https://leetcode.com/problems/minimum-pair-removal-to-sort-array-i/"});
+  registerStrategy("Simulation", solution1);
+}
+
+int MinimumPairRemovalToSortArrayISolution::minimumPairRemoval(vector<int>& nums) {
+  return getSolution()(nums);
+}
+
+}  // namespace problem_3507
+}  // namespace leetcode

test/leetcode/problems/minimum-pair-removal-to-sort-array-i.cpp

@@ -0,0 +1,104 @@
+#include "leetcode/problems/minimum-pair-removal-to-sort-array-i.h"
+
+#include "gtest/gtest.h"
+
+namespace leetcode {
+namespace problem_3507 {
+
+class MinimumPairRemovalToSortArrayITest : public ::testing::TestWithParam<string> {
+ protected:
+  void SetUp() override { solution.setStrategy(GetParam()); }
+
+  MinimumPairRemovalToSortArrayISolution solution;
+};
+
+TEST_P(MinimumPairRemovalToSortArrayITest, Example1) {
+  vector<int> nums = {5, 2, 3, 1};
+  int expected = 2;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, Example2) {
+  vector<int> nums = {1, 2, 2};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, SingleElement) {
+  vector<int> nums = {5};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, AlreadySorted) {
+  vector<int> nums = {1, 2, 3, 4};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, NegativeNumbers) {
+  vector<int> nums = {-1, -2, 3};
+  int expected = 1;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, AllNegative) {
+  vector<int> nums = {-5, -4, -3};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, NeedMultipleOperations) {
+  vector<int> nums = {4, 3, 2, 1};
+  int expected = 2;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, DecreasingArray) {
+  vector<int> nums = {5, 4, 3, 2, 1};
+  int expected = 4;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, MixedNumbers) {
+  vector<int> nums = {0, -1, 2, -3, 4};
+  int expected = 2;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, AllEqual) {
+  vector<int> nums = {2, 2, 2, 2};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, LengthTwoAlreadySorted) {
+  vector<int> nums = {1, 2};
+  int expected = 0;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, LengthTwoNeedOneOperation) {
+  vector<int> nums = {2, 1};
+  // 合并(2,1)=3 -> [3] 有序
+  int expected = 1;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+TEST_P(MinimumPairRemovalToSortArrayITest, LargeNumbers) {
+  vector<int> nums = {1000, -1000, 1000, -1000};
+  // 最小和相邻对：(1000,-1000)=0 最左边
+  // 合并后：[0, 1000, -1000]
+  // 最小和相邻对：(1000,-1000)=0 最左边
+  // 合并后：[0, 0]
+  // 有序
+  int expected = 2;
+  EXPECT_EQ(expected, solution.minimumPairRemoval(nums));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    LeetCode, MinimumPairRemovalToSortArrayITest,
+    ::testing::ValuesIn(MinimumPairRemovalToSortArrayISolution().getStrategyNames()));
+
+}  // namespace problem_3507
+}  // namespace leetcode