Improved tasks 3360-3373

javadev · javadev · commit 17af23450906 · 2024-12-03T02:58:54.000+02:00
diff --git a/src/main/java/g3301_3400/s3360_stone_removal_game/Solution.java b/src/main/java/g3301_3400/s3360_stone_removal_game/Solution.java
@@ -1,6 +1,6 @@
 package g3301_3400.s3360_stone_removal_game;
 
-// #Easy #2024_11_24_Time_0_ms_(100.00%)_Space_40.5_MB_(100.00%)
+// #Easy #Math #Simulation #2024_12_03_Time_0_ms_(100.00%)_Space_40.3_MB_(80.86%)
 
 public class Solution {
     public boolean canAliceWin(int n) {
diff --git a/src/main/java/g3301_3400/s3361_shift_distance_between_two_strings/Solution.java b/src/main/java/g3301_3400/s3361_shift_distance_between_two_strings/Solution.java
@@ -1,26 +1,36 @@
 package g3301_3400.s3361_shift_distance_between_two_strings;
 
-// #Medium #2024_11_24_Time_57_ms_(100.00%)_Space_45.7_MB_(100.00%)
+// #Medium #Array #String #Prefix_Sum #2024_12_03_Time_9_ms_(100.00%)_Space_45.8_MB_(36.02%)
 
 public class Solution {
     public long shiftDistance(String s, String t, int[] nextCost, int[] previousCost) {
-        long sum = 0;
-        int n = s.length();
-        for (int i = 0; i < n; i++) {
-            int ch1 = s.charAt(i) - 'a';
-            int ch2 = t.charAt(i) - 'a';
-            int forwardDiff = (ch2 - ch1 + 26) % 26;
-            long forwardCost = 0;
-            for (int j = 0; j < forwardDiff; j++) {
-                forwardCost += nextCost[(ch1 + j) % 26];
+        long[][] costs = new long[26][26];
+        long cost;
+        for (int i = 0; i < 26; i++) {
+            cost = nextCost[i];
+            for (int j = (i == 25 ? 0 : i + 1); j != i; j++) {
+                costs[i][j] = cost;
+                cost += nextCost[j];
+                if (j == 25) {
+                    j = -1;
+                }
             }
-            int reverseDiff = (26 + ch1 - ch2) % 26;
-            long backwardCost = 0;
-            for (int j = 0; j < reverseDiff; j++) {
-                backwardCost += previousCost[(ch1 - j + 26) % 26];
+        }
+        for (int i = 0; i < 26; i++) {
+            cost = previousCost[i];
+            for (int j = (i == 0 ? 25 : i - 1); j != i; j--) {
+                costs[i][j] = Math.min(costs[i][j], cost);
+                cost += previousCost[j];
+                if (j == 0) {
+                    j = 26;
+                }
             }
-            sum += Math.min(forwardCost, backwardCost);
         }
-        return sum;
+        int n = s.length();
+        long ans = 0;
+        for (int i = 0; i < n; i++) {
+            ans += costs[s.charAt(i) - 'a'][t.charAt(i) - 'a'];
+        }
+        return ans;
     }
 }
diff --git a/src/main/java/g3301_3400/s3362_zero_array_transformation_iii/Solution.java b/src/main/java/g3301_3400/s3362_zero_array_transformation_iii/Solution.java
@@ -1,6 +1,7 @@
 package g3301_3400.s3362_zero_array_transformation_iii;
 
-// #Medium #2024_11_24_Time_67_ms_(100.00%)_Space_89.9_MB_(66.67%)
+// #Medium #Array #Sorting #Greedy #Heap_Priority_Queue #Prefix_Sum
+// #2024_12_03_Time_68_ms_(91.99%)_Space_93.6_MB_(45.88%)
 
 import java.util.Arrays;
 import java.util.PriorityQueue;
diff --git a/src/main/java/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/Solution.java b/src/main/java/g3301_3400/s3363_find_the_maximum_number_of_fruits_collected/Solution.java
@@ -1,6 +1,6 @@
 package g3301_3400.s3363_find_the_maximum_number_of_fruits_collected;
 
-// #Hard #2024_11_24_Time_13_ms_(100.00%)_Space_142.3_MB_(33.33%)
+// #Hard #Array #Dynamic_Programming #Matrix #2024_12_03_Time_12_ms_(91.34%)_Space_142.1_MB_(88.96%)
 
 public class Solution {
     public int maxCollectedFruits(int[][] fruits) {
diff --git a/src/main/java/g3301_3400/s3364_minimum_positive_sum_subarray/Solution.java b/src/main/java/g3301_3400/s3364_minimum_positive_sum_subarray/Solution.java
@@ -1,24 +1,25 @@
 package g3301_3400.s3364_minimum_positive_sum_subarray;
 
-// #Easy #2024_11_24_Time_28_ms_(100.00%)_Space_44.7_MB_(100.00%)
+// #Easy #Array #Prefix_Sum #Sliding_Window #2024_12_03_Time_1_ms_(100.00%)_Space_44.5_MB_(38.75%)
 
 import java.util.List;
 
 public class Solution {
-    public int minimumSumSubarray(List<Integer> nums, int l, int r) {
-        int size = nums.size();
-        int res = -1;
-        for (int s = l; s <= r; s++) {
-            for (int i = 0; i <= size - s; i++) {
-                int sum = 0;
-                for (int j = i; j < i + s; j++) {
-                    sum += nums.get(j);
-                }
-                if (sum > 0 && (res == -1 || res > sum)) {
-                    res = sum;
+    public int minimumSumSubarray(List<Integer> li, int l, int r) {
+        int n = li.size();
+        int min = Integer.MAX_VALUE;
+        int[] a = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            a[i] = a[i - 1] + li.get(i - 1);
+        }
+        for (int size = l; size <= r; size++) {
+            for (int i = size - 1; i < n; i++) {
+                int sum = a[i + 1] - a[i + 1 - size];
+                if (sum > 0) {
+                    min = Math.min(min, sum);
                 }
             }
         }
-        return res;
+        return min == Integer.MAX_VALUE ? -1 : min;
     }
 }
diff --git a/src/main/java/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/Solution.java b/src/main/java/g3301_3400/s3365_rearrange_k_substrings_to_form_target_string/Solution.java
@@ -1,6 +1,6 @@
 package g3301_3400.s3365_rearrange_k_substrings_to_form_target_string;
 
-// #Medium #2024_11_24_Time_61_ms_(100.00%)_Space_49.3_MB_(100.00%)
+// #Medium #String #Hash_Table #Sorting #2024_12_03_Time_59_ms_(94.24%)_Space_49.2_MB_(97.33%)
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/src/main/java/g3301_3400/s3366_minimum_array_sum/Solution.java b/src/main/java/g3301_3400/s3366_minimum_array_sum/Solution.java
@@ -1,38 +1,75 @@
 package g3301_3400.s3366_minimum_array_sum;
 
-// #Medium #2024_11_24_Time_66_ms_(100.00%)_Space_55_MB_(100.00%)
+// #Medium #Array #Dynamic_Programming #2024_12_03_Time_4_ms_(99.77%)_Space_43_MB_(99.69%)
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 public class Solution {
     public int minArraySum(int[] nums, int k, int op1, int op2) {
-        Integer[][][] dp = new Integer[nums.length][op1 + 1][op2 + 1];
-        return sub(dp, nums, 0, k, op1, op2);
-    }
-
-    private int sub(Integer[][][] dp, int[] nums, int i, int k, int op1, int op2) {
-        if (i == nums.length) {
-            return 0;
-        }
-        if (dp[i][op1][op2] != null) {
-            return dp[i][op1][op2];
+        Arrays.sort(nums);
+        int high = lowerBound(nums, k * 2 - 1);
+        int low = lowerBound(nums, k);
+        int n = nums.length;
+        for (int i = n - 1; i >= high; i--) {
+            if (op1 > 0) {
+                nums[i] = (nums[i] + 1) / 2;
+                op1--;
+            }
+            if (op2 > 0) {
+                nums[i] -= k;
+                op2--;
+            }
         }
-        int res = sub(dp, nums, i + 1, k, op1, op2) + nums[i];
-        if (nums[i] >= k && op2 > 0) {
-            res = Math.min(res, sub(dp, nums, i + 1, k, op1, op2 - 1) + nums[i] - k);
-            int v = (int) Math.ceil(nums[i] / 2.0);
-            if (v < k) {
-                v = (int) Math.ceil((nums[i] - k) / 2.0);
+        Map<Integer, Integer> count = new HashMap<>();
+        int odd = 0;
+        for (int i = low; i < high; i++) {
+            if (op2 > 0) {
+                nums[i] -= k;
+                if (k % 2 > 0 && nums[i] % 2 > 0) {
+                    count.merge(nums[i], 1, Integer::sum);
+                }
+                op2--;
             } else {
-                v -= k;
+                odd += nums[i] % 2;
             }
-            if (op1 > 0) {
-                res = Math.min(res, sub(dp, nums, i + 1, k, op1 - 1, op2 - 1) + v);
+        }
+        Arrays.sort(nums, 0, high);
+        int ans = 0;
+        if (k % 2 > 0) {
+            for (int i = high - op1; i < high && odd > 0; i++) {
+                int x = nums[i];
+                if (count.containsKey(x)) {
+                    if (count.merge(x, -1, Integer::sum) == 0) {
+                        count.remove(x);
+                    }
+                    odd--;
+                    ans--;
+                }
             }
         }
-        if (op1 > 0) {
-            int v = (int) Math.ceil(nums[i] / 2.0);
-            res = Math.min(res, sub(dp, nums, i + 1, k, op1 - 1, op2) + v);
+        for (int i = high - 1; i >= 0 && op1 > 0; i--) {
+            nums[i] = (nums[i] + 1) / 2;
+            op1--;
+        }
+        for (int x : nums) {
+            ans += x;
+        }
+        return ans;
+    }
+
+    private int lowerBound(int[] nums, int target) {
+        int left = -1;
+        int right = nums.length;
+        while (left + 1 < right) {
+            int mid = (left + right) >>> 1;
+            if (nums[mid] >= target) {
+                right = mid;
+            } else {
+                left = mid;
+            }
         }
-        dp[i][op1][op2] = res;
-        return res;
+        return right;
     }
 }
diff --git a/src/main/java/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.java b/src/main/java/g3301_3400/s3367_maximize_sum_of_weights_after_edge_removals/Solution.java
@@ -1,6 +1,7 @@
 package g3301_3400.s3367_maximize_sum_of_weights_after_edge_removals;
 
-// #Hard #2024_11_27_Time_87_ms_(98.35%)_Space_152.7_MB_(18.13%)
+// #Hard #Dynamic_Programming #Tree #Depth_First_Search
+// #2024_12_03_Time_104_ms_(91.49%)_Space_147.1_MB_(58.51%)
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/src/main/java/g3301_3400/s3370_smallest_number_with_all_set_bits/Solution.java b/src/main/java/g3301_3400/s3370_smallest_number_with_all_set_bits/Solution.java
@@ -1,6 +1,6 @@
 package g3301_3400.s3370_smallest_number_with_all_set_bits;
 
-// #Easy #2024_12_01_Time_0_ms_(100.00%)_Space_40.7_MB_(100.00%)
+// #Easy #Math #Bit_Manipulation #2024_12_03_Time_0_ms_(100.00%)_Space_41.1_MB_(45.50%)
 
 public class Solution {
     public int smallestNumber(int n) {
diff --git a/src/main/java/g3301_3400/s3371_identify_the_largest_outlier_in_an_array/Solution.java b/src/main/java/g3301_3400/s3371_identify_the_largest_outlier_in_an_array/Solution.java
@@ -1,33 +1,30 @@
 package g3301_3400.s3371_identify_the_largest_outlier_in_an_array;
 
-// #Medium #2024_12_01_Time_633_ms_(100.00%)_Space_64.5_MB_(100.00%)
-
-import java.util.TreeMap;
+// #Medium #Array #Hash_Table #Counting #Enumeration
+// #2024_12_03_Time_5_ms_(100.00%)_Space_60.6_MB_(33.40%)
 
 public class Solution {
     public int getLargestOutlier(int[] nums) {
+        int[] cnt = new int[2001];
         int sum = 0;
-        for (int num : nums) {
-            sum += num;
-        }
-        TreeMap<Integer, Integer> frequencyMap = new TreeMap<>();
-        for (int num : nums) {
-            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        for (int i : nums) {
+            sum += i;
+            cnt[i + 1000]++;
         }
-        int ans = Integer.MIN_VALUE;
-        for (int num : nums) {
-            if ((sum - num) % 2 == 0) {
-                int target = (sum - num) / 2;
-                frequencyMap.put(num, frequencyMap.get(num) - 1);
-                if (frequencyMap.get(num) == 0) {
-                    frequencyMap.remove(num);
-                }
-                if (frequencyMap.containsKey(target)) {
-                    ans = Math.max(ans, num);
-                }
-                frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        for (int i = cnt.length - 1; i >= 0; --i) {
+            int j = i - 1000;
+            if (cnt[i] == 0) {
+                continue;
+            }
+            sum -= j;
+            int csum = (sum >> 1) + 1000;
+            cnt[i]--;
+            if (sum % 2 == 0 && csum >= 0 && csum < cnt.length && cnt[csum] > 0) {
+                return j;
             }
+            sum += j;
+            cnt[i]++;
         }
-        return ans == Integer.MIN_VALUE ? -1 : ans;
+        return 0;
     }
 }
diff --git a/src/main/java/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.java b/src/main/java/g3301_3400/s3372_maximize_the_number_of_target_nodes_after_connecting_trees_i/Solution.java
diff --git a/src/main/java/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.java b/src/main/java/g3301_3400/s3373_maximize_the_number_of_target_nodes_after_connecting_trees_ii/Solution.java
