Fix 3357 solution

solution/3300-3399/3356.Zero Array Transformation II/Solution.cpp

@@ -1,33 +1,34 @@
 class Solution {
 public:
-    int minZeroArray(vector<int>& nums, vector<vector<int>>& 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<int>& 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;
     }
 };

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;
     }
 }

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

solution/3300-3399/3357.Minimize the Maximum Adjacent Element Difference/Solution.cpp

@@ -0,0 +1,53 @@
+class Solution {
+public:
+    int minimizeMaxDifference(vector<int>& 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;
+    }
+};

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));
+    }
+}

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