20250619 finished.

src/problems/1432-max-difference-you-can-get-from-changing-an-integer.cpp

@@ -0,0 +1,94 @@
+/**
+* [1432] Max Difference You Can Get From Changing an Integer
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+class Solution
+{
+public:
+    int maxDiff(int num)
+    {
+        string numString = to_string(num);
+
+        // Select the first, not 9 number.
+        int targetPos = 0;
+        while (targetPos < numString.size() - 1)
+        {
+            if (numString[targetPos] != '9')
+            {
+                break;
+            }
+
+            targetPos += 1;
+        }
+
+        auto maxNumber = replaceDigit(numString, numString[targetPos], '9');
+
+        targetPos        = 0;
+        char minimumChar = '1';
+        // If the first number is not 1, select the first number.
+        // If the first number is 1, select next, not zero number.
+        if (numString[targetPos] == '1')
+        {
+            targetPos   = 1;
+            minimumChar = '0';
+            while (targetPos < numString.size())
+            {
+                if (numString[targetPos] == '1')
+                {
+                    // Can not replace 1 when the first number is 1.
+                    targetPos += 1;
+                    continue;
+                }
+
+                if (numString[targetPos] != '0')
+                {
+                    break;
+                }
+
+                targetPos += 1;
+            }
+        }
+
+        int minNumber = num;
+        if (targetPos != numString.size())
+        {
+            minNumber = replaceDigit(numString, numString[targetPos], minimumChar);
+        }
+
+        return maxNumber - minNumber;
+    }
+
+    static auto replaceDigit(const string &num, char source, char target) -> int
+    {
+        int result = 0;
+        for (const char i : num)
+        {
+            if (i == source)
+            {
+                result = result * 10 + target - '0';
+            }
+            else
+            {
+                result = result * 10 + i - '0';
+            }
+        }
+
+        return result;
+    }
+};
+
+// submission codes end
+
+TEST(P1432, Test1)
+{
+    ASSERT_EQ(888, Solution().maxDiff(555));
+    ASSERT_EQ(8, Solution().maxDiff(9));
+    ASSERT_EQ(888, Solution().maxDiff(111));
+    ASSERT_EQ(80000, Solution().maxDiff(10000));
+}

src/problems/2016-maximum-difference-between-increasing-elements.cpp

@@ -0,0 +1,49 @@
+/**
+* [2016] Maximum Difference Between Increasing Elements
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+class Solution
+{
+public:
+    int maximumDifference(vector<int> &nums)
+    {
+        vector<int> heap;
+        heap.reserve(nums.size());
+
+        ranges::make_heap(heap, greater());
+
+        int result = -1;
+        for (int i = 1; i < nums.size(); ++i)
+        {
+            heap.push_back(nums[i - 1]);
+            ranges::push_heap(heap, greater());
+
+            if (heap[0] < nums[i])
+            {
+                result = max(result, nums[i] - heap[0]);
+            }
+        }
+
+        return result;
+    }
+};
+
+// submission codes end
+
+TEST(P2016, Test1)
+{
+    vector nums1 = {7, 1, 5, 4};
+    ASSERT_EQ(4, Solution().maximumDifference(nums1));
+
+    vector nums2 = {9, 4, 3, 2};
+    ASSERT_EQ(-1, Solution().maximumDifference(nums2));
+
+    vector nums3 = {1, 5, 2, 10};
+    ASSERT_EQ(9, Solution().maximumDifference(nums3));
+}

src/problems/2294-partition-array-such-that-maximum-difference-is-k.cpp

@@ -0,0 +1,50 @@
+/**
+* [2294] Partition Array Such That Maximum Difference Is K
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+class Solution
+{
+public:
+    int partitionArray(vector<int> &nums, int k)
+    {
+        ranges::sort(nums);
+
+        // At least to split into one segment.
+        int result   = 1;
+        int pos      = 1;
+        int minValue = nums[0];
+
+        while (pos < nums.size())
+        {
+            if (nums[pos] > minValue + k)
+            {
+                result   += 1;
+                minValue  = nums[pos];
+            }
+            else
+            {
+                pos += 1;
+            }
+        }
+
+        return result;
+    }
+};
+
+// submission codes end
+
+TEST(P2294, Test1)
+{
+    vector nums1 = {3, 6, 1, 2, 5};
+    ASSERT_EQ(2, Solution().partitionArray(nums1, 2));
+    vector nums2 = {1, 2, 3};
+    ASSERT_EQ(2, Solution().partitionArray(nums2, 1));
+    vector nums3 = {2, 2, 4, 5};
+    ASSERT_EQ(3, Solution().partitionArray(nums3, 0));
+}

src/problems/2566-maximum-difference-by-remapping-a-digit.cpp

@@ -0,0 +1,71 @@
+/**
+* [2566] Maximum Difference by Remapping a Digit
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+class Solution
+{
+public:
+    int minMaxDifference(int num)
+    {
+        const string numString = to_string(num);
+
+        // Select the first not 9 number when converting to maximum value.
+        int targetPos = 0;
+        while (targetPos < numString.size() - 1)
+        {
+            if (numString[targetPos] != '9')
+            {
+                break;
+            }
+
+            targetPos += 1;
+        }
+
+        int maxNum = 0;
+
+        char targetChar = numString[targetPos];
+        for (const auto c : numString)
+        {
+            if (c == targetChar)
+            {
+                maxNum = maxNum * 10 + 9;
+            }
+            else
+            {
+                maxNum = maxNum * 10 + c - '0';
+            }
+        }
+
+        // The minimum value is replacing the first number into zero.
+
+        targetChar = numString[0];
+        int minNum = 0;
+        for (const auto c : numString)
+        {
+            if (c == targetChar)
+            {
+                minNum = minNum * 10;
+            }
+            else
+            {
+                minNum = minNum * 10 + c - '0';
+            }
+        }
+
+        return maxNum - minNum;
+    }
+};
+
+// submission codes end
+
+TEST(P2566, Test1)
+{
+    ASSERT_EQ(99009, Solution().minMaxDifference(11891));
+    ASSERT_EQ(99, Solution().minMaxDifference(90));
+}

src/problems/2966-divide-array-into-arrays-with-max-difference.cpp

@@ -0,0 +1,51 @@
+/**
+* [2966] Divide Array Into Arrays With Max Difference
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+class Solution
+{
+public:
+    vector<vector<int>> divideArray(vector<int> &nums, int k)
+    {
+        ranges::sort(nums);
+
+        vector<vector<int>> result;
+        bool flag = true;
+        result.reserve(nums.size() / 3);
+
+        for (int i = 0; i < nums.size(); i += 3)
+        {
+            if (nums[i + 2] - nums[i + 1] > k || nums[i + 1] - nums[i] > k || nums[i + 2] - nums[i] > k)
+            {
+                flag = false;
+                break;
+            }
+
+            vector array = {nums[i], nums[i + 1], nums[i + 2]};
+            result.push_back(move(array));
+        }
+
+        if (flag)
+        {
+            return result;
+        }
+
+        return {};
+    }
+};
+
+// submission codes end
+
+TEST(P2966, Test1)
+{
+    vector nums                = {1, 3, 4, 8, 7, 9, 3, 5, 1};
+    vector<vector<int>> result = {{1, 1, 3}, {3, 4, 5}, {7, 8, 9}};
+
+    ASSERT_EQ(result, Solution().divideArray(nums, 2));
+}

src/problems/3405-count-the-number-of-arrays-with-k-matching-adjacent-elements.cpp

@@ -0,0 +1,80 @@
+/**
+* [3405] Count the Number of Arrays with K Matching Adjacent Elements
+ */
+#include <bits/stdc++.h>
+#include <gtest/gtest.h>
+using namespace std;
+
+
+// submission codes start here
+
+constexpr long long MOD         = 1e9 + 7;
+constexpr long long UPPER_BOUND = 1e5;
+
+static long long fact[UPPER_BOUND];
+static long long inverseFact[UPPER_BOUND];
+
+class Solution
+{
+    static long long quickPower(long long x, int n)
+    {
+        long long result = 1;
+
+        while (n > 0)
+        {
+            if ((n & 1) == 1)
+            {
+                result = result * x % MOD;
+            }
+
+            x   = x * x % MOD;
+            n >>= 1;
+        }
+
+        return result;
+    }
+
+    static long long combine(int n, int m)
+    {
+        return fact[n] * inverseFact[m] % MOD * inverseFact[n - m] % MOD;
+    }
+
+    static void init()
+    {
+        if (fact[0] != 0)
+        {
+            return;
+        }
+
+        fact[0] = 1;
+        for (int i = 1; i < UPPER_BOUND; ++i)
+        {
+            fact[i] = fact[i - 1] * i % MOD;
+        }
+
+        // Modular Multiplicative Inverse is calculated by  the quick power.
+        inverseFact[UPPER_BOUND - 1] = quickPower(fact[UPPER_BOUND - 1], MOD - 2);
+        for (int i = UPPER_BOUND - 1; i > 0; --i)
+        {
+            inverseFact[i - 1] = inverseFact[i] * i % MOD;
+        }
+    }
+
+public:
+    int countGoodArrays(int n, int m, int k)
+    {
+        init();
+        const long long result = combine(n - 1, k) * m % MOD * quickPower(m - 1, n - k - 1) % MOD;
+        return result;
+    }
+};
+
+// submission codes end
+
+TEST(P3405, Test1)
+{
+    Solution s;
+    ASSERT_EQ(4, s.countGoodArrays(3, 2, 1));
+    ASSERT_EQ(6, s.countGoodArrays(4, 2, 2));
+    ASSERT_EQ(2, s.countGoodArrays(5, 2, 0));
+}

src/template.cpp

@@ -10,9 +10,8 @@ using namespace std;
 
 __PROBLEM_DEFAULT_CODE__
 
-// submission codes endo
+// submission codes end
 
 TEST(__TEST_CASE_NAME__, Test1)
 {
-
-}
+}