diff --git a/solution/3300-3399/3356.Zero Array Transformation II/Solution.cpp b/solution/3300-3399/3356.Zero Array Transformation II/Solution.cpp index 4ddc2d5c17cd0..f7951969c5f75 100644 --- a/solution/3300-3399/3356.Zero Array Transformation II/Solution.cpp +++ b/solution/3300-3399/3356.Zero Array Transformation II/Solution.cpp @@ -1,33 +1,34 @@ class Solution { public: - int minZeroArray(vector& nums, vector>& queries) { - int n = nums.size(); - int d[n + 1]; - int m = queries.size(); - int l = 0, r = m + 1; - auto check = [&](int k) -> bool { - memset(d, 0, sizeof(d)); - for (int i = 0; i < k; ++i) { - int l = queries[i][0], r = queries[i][1], val = queries[i][2]; - d[l] += val; - d[r + 1] -= val; - } - for (int i = 0, s = 0; i < n; ++i) { - s += d[i]; - if (nums[i] > s) { + int minimizeMaxDifference(vector& nums) { + int left = 0, right = 1e9, result = 1e9; + + auto isValid = [&](int maxDiff) { + int n = nums.size(); + int prev = nums[0]; + for (int i = 1; i < n; ++i) { + if (nums[i] == -1) { + continue; + } + if (prev != -1 && abs(nums[i] - prev) > maxDiff) { return false; } + prev = nums[i]; } return true; }; - while (l < r) { - int mid = (l + r) >> 1; - if (check(mid)) { - r = mid; + + while (left <= right) { + int mid = left + (right - left) / 2; + + if (isValid(mid)) { + result = mid; + right = mid - 1; } else { - l = mid + 1; + left = mid + 1; } } - return l > m ? -1 : l; + + return result; } }; diff --git a/solution/3300-3399/3356.Zero Array Transformation II/Solution.java b/solution/3300-3399/3356.Zero Array Transformation II/Solution.java index 951dc57069d94..ad624dc702516 100644 --- a/solution/3300-3399/3356.Zero Array Transformation II/Solution.java +++ b/solution/3300-3399/3356.Zero Array Transformation II/Solution.java @@ -1,38 +1,44 @@ class Solution { - private int n; - private int[] nums; - private int[][] queries; + private int x, y; - public int minZeroArray(int[] nums, int[][] queries) { - this.nums = nums; - this.queries = queries; - n = nums.length; - int m = queries.length; - int l = 0, r = m + 1; - while (l < r) { - int mid = (l + r) >> 1; - if (check(mid)) { - r = mid; - } else { - l = mid + 1; + public int minimizeMaxDifference(int[] nums) { + int left = 0, right = (int) 1e9, result = (int) 1e9; + + boolean isValid(int maxDiff) { + int prev = nums[0]; + int minVal = 1, maxVal = (int) 1e9; + + for (int i = 1; i < nums.length; i++) { + if (nums[i] == -1) { + minVal = Math.max(prev - maxDiff, 1); + maxVal = Math.min(prev + maxDiff, (int) 1e9); + if (minVal > maxVal) { + return false; + } + prev = (minVal + maxVal) / 2; + } else { + if (prev != -1 && Math.abs(nums[i] - prev) > maxDiff) { + return false; + } + prev = nums[i]; + } } + x = minVal; + y = maxVal; + return true; } - return l > m ? -1 : l; - } - private boolean check(int k) { - int[] d = new int[n + 1]; - for (int i = 0; i < k; ++i) { - int l = queries[i][0], r = queries[i][1], val = queries[i][2]; - d[l] += val; - d[r + 1] -= val; - } - for (int i = 0, s = 0; i < n; ++i) { - s += d[i]; - if (nums[i] > s) { - return false; + while (left <= right) { + int mid = left + (right - left) / 2; + if (isValid(mid)) { + result = mid; + right = mid - 1; + } else { + left = mid + 1; } } - return true; + + System.out.println("Optimal pair: x=" + x + ", y=" + y); + return result; } } diff --git a/solution/3300-3399/3356.Zero Array Transformation II/Solution.py b/solution/3300-3399/3356.Zero Array Transformation II/Solution.py index 570af93df7448..fdb64055c9f9c 100644 --- a/solution/3300-3399/3356.Zero Array Transformation II/Solution.py +++ b/solution/3300-3399/3356.Zero Array Transformation II/Solution.py @@ -1,17 +1,33 @@ class Solution: - def minZeroArray(self, nums: List[int], queries: List[List[int]]) -> int: - def check(k: int) -> bool: - d = [0] * (len(nums) + 1) - for l, r, val in queries[:k]: - d[l] += val - d[r + 1] -= val - s = 0 - for x, y in zip(nums, d): - s += y - if x > s: - return False + def minimizeMaxDifference(self, nums: List[int]) -> int: + left, right, result = 0, int(1e9), int(1e9) + x, y = 0, 0 + + def isValid(maxDiff): + nonlocal x, y + prev = nums[0] + minVal, maxVal = 1, int(1e9) + for i in range(1, len(nums)): + if nums[i] == -1: + minVal = max(prev - maxDiff, 1) + maxVal = min(prev + maxDiff, int(1e9)) + if minVal > maxVal: + return False + prev = (minVal + maxVal) // 2 + else: + if prev != -1 and abs(nums[i] - prev) > maxDiff: + return False + prev = nums[i] + x, y = minVal, maxVal return True - m = len(queries) - l = bisect_left(range(m + 1), True, key=check) - return -1 if l > m else l + while left <= right: + mid = left + (right - left) // 2 + if isValid(mid): + result = mid + right = mid - 1 + else: + left = mid + 1 + + print(f"Optimal pair: x={x}, y={y}") + return result diff --git a/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.cpp b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.cpp new file mode 100644 index 0000000000000..2cb7e5691cbb6 --- /dev/null +++ b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.cpp @@ -0,0 +1,53 @@ +class Solution { +public: + int minimizeMaxDifference(vector& nums) { + int n = nums.size(); + int minVal = INT_MAX, maxVal = INT_MIN; + + for (int i = 0; i < n; ++i) { + if (nums[i] != -1) { + minVal = min(minVal, nums[i]); + maxVal = max(maxVal, nums[i]); + } + } + + if (minVal == INT_MAX) { + return 0; + } + + auto isPossible = [&](int maxDiff) -> bool { + int prev = -1; + + for (int i = 0; i < n; ++i) { + if (nums[i] != -1) { + prev = nums[i]; + } else { + if (prev != -1) { + if (abs(prev - minVal) > maxDiff && abs(prev - maxVal) > maxDiff) { + return false; + } + prev = (abs(prev - minVal) <= abs(prev - maxVal)) ? minVal : maxVal; + } else { + prev = minVal; + } + } + } + + return true; + }; + + int left = 0, right = maxVal - minVal, result = right; + + while (left <= right) { + int mid = left + (right - left) / 2; + if (isPossible(mid)) { + result = mid; + right = mid - 1; + } else { + left = mid + 1; + } + } + + return result; + } +}; diff --git a/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.java b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.java new file mode 100644 index 0000000000000..99cc4a6afee34 --- /dev/null +++ b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.java @@ -0,0 +1,51 @@ +public class Solution { + + public int minimizeMaxDiff(int[] nums) { + int left = 0, right = (int) 1e9, result = (int) 1e9; + + while (left <= right) { + int mid = left + (right - left) / 2; + if (isValid(nums, mid)) { + result = mid; + right = mid - 1; + } else { + left = mid + 1; + } + } + + return result; + } + + private boolean isValid(int[] nums, int maxDiff) { + int prev = nums[0] != -1 ? nums[0] : -1; + + for (int i = 1; i < nums.length; i++) { + int current = nums[i]; + if (current == -1) { + if (prev != -1) { + current = Math.max(prev - maxDiff, 1); + } else { + current = 1; + } + } + if (prev != -1 && Math.abs(current - prev) > maxDiff) { + return false; + } + prev = current; + } + return true; + } + + public static void main(String[] args) { + Solution solver = new Solution(); + + int[] nums1 = {1, 2, -1, 10, 8}; + System.out.println(solver.minimizeMaxDiff(nums1)); + + int[] nums2 = {-1, -1, -1}; + System.out.println(solver.minimizeMaxDiff(nums2)); + + int[] nums3 = {-1, 10, -1, 8}; + System.out.println(solver.minimizeMaxDiff(nums3)); + } +} diff --git a/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.py b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.py new file mode 100644 index 0000000000000..598290d699932 --- /dev/null +++ b/solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.py @@ -0,0 +1,21 @@ +class Solution: + def minimizeMaxDifference(self, nums: List[int], k: int) -> int: + nums.sort() + l, r = 0, nums[-1] - nums[0] + + def can_minimize(target): + ops = 0 + for i in range(1, len(nums)): + if nums[i] - nums[i - 1] > target: + ops += (nums[i] - nums[i - 1] - 1) // target + if ops > k: + return False + return True + + while l < r: + mid = (l + r) // 2 + if can_minimize(mid): + r = mid + else: + l = mid + 1 + return l