Updated tags

Author: javadev

src/main/java/g3501_3600/s3541_find_most_frequent_vowel_and_consonant/Solution.java

@@ -1,6 +1,6 @@
 package g3501_3600.s3541_find_most_frequent_vowel_and_consonant;
 
-// #Easy #2025_05_11_Time_1_ms_(100.00%)_Space_42.60_MB_(100.00%)
+// #Easy #String #Hash_Table #Counting #2025_05_13_Time_1_ms_(100.00%)_Space_42.55_MB_(70.83%)
 
 public class Solution {
     public int maxFreqSum(String s) {

src/main/java/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/Solution.java

@@ -1,24 +1,27 @@
 package g3501_3600.s3542_minimum_operations_to_convert_all_elements_to_zero;
 
-// #Medium #2025_05_11_Time_162_ms_(100.00%)_Space_61.48_MB_(100.00%)
-
-import java.util.ArrayDeque;
-import java.util.Deque;
+// #Medium #Array #Hash_Table #Greedy #Stack #Monotonic_Stack
+// #2025_05_13_Time_11_ms_(100.00%)_Space_60.16_MB_(91.63%)
 
 public class Solution {
     public int minOperations(int[] nums) {
-        Deque<Integer> stack = new ArrayDeque<>();
-        stack.push(0);
+        int[] mq = new int[nums.length];
+        int idx = 0;
         int res = 0;
-        for (int a : nums) {
-            while (!stack.isEmpty() && stack.peek() > a) {
-                stack.pop();
-            }
-            if (stack.isEmpty() || stack.peek() < a) {
-                res++;
-                stack.push(a);
+        for (int num : nums) {
+            if (num == 0) {
+                res += idx;
+                idx = 0;
+            } else {
+                while (idx > 0 && mq[idx - 1] >= num) {
+                    if (mq[idx - 1] > num) {
+                        res++;
+                    }
+                    idx--;
+                }
+                mq[idx++] = num;
             }
         }
-        return res;
+        return res + idx;
     }
 }

src/main/java/g3501_3600/s3543_maximum_weighted_k_edge_path/Solution.java

@@ -1,66 +1,64 @@
 package g3501_3600.s3543_maximum_weighted_k_edge_path;
 
-// #Medium #2025_05_11_Time_1158_ms_(100.00%)_Space_284.01_MB_(100.00%)
+// #Medium #Hash_Table #Dynamic_Programming #Graph
+// #2025_05_13_Time_12_ms_(100.00%)_Space_45.57_MB_(85.53%)
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
+@SuppressWarnings("unchecked")
 public class Solution {
-    private int[][][] dp;
+    private int max = -1;
+    private int t;
+    private List<int[]>[] map;
+    private int[][] memo;
 
-    private static class Pair {
-        int node;
-        int wt;
-
-        Pair(int node, int wt) {
-            this.node = node;
-            this.wt = wt;
-        }
-    }
-
-    public int maxWeight(int n, int[][] edges, int k, int t) {
+    private void dfs(int cur, int sum, int k) {
         if (k == 0) {
-            return 0;
-        }
-        dp = new int[n][k + 1][t + 1];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j <= k; j++) {
-                Arrays.fill(dp[i][j], Integer.MIN_VALUE);
+            if (sum < t) {
+                max = Math.max(max, sum);
             }
+            return;
         }
-        List<List<Pair>> adj = new ArrayList<>();
-        for (int i = 0; i < n; i++) {
-            adj.add(new ArrayList<>());
+        if (sum >= t) {
+            return;
         }
-        for (int[] edge : edges) {
-            adj.get(edge[0]).add(new Pair(edge[1], edge[2]));
+        if (memo[cur][k] >= sum) {
+            return;
         }
-        int ans = -1;
-        for (int start = 0; start < n; start++) {
-            int res = dfs(adj, start, k, t, 0);
-            ans = Math.max(ans, res);
+        memo[cur][k] = sum;
+        for (int i = 0; i < map[cur].size(); i++) {
+            int v = map[cur].get(i)[0];
+            int val = map[cur].get(i)[1];
+            dfs(v, sum + val, k - 1);
         }
-        return ans;
     }
 
-    private int dfs(List<List<Pair>> adj, int u, int stepsRemaining, int t, int currentSum) {
-        if (currentSum >= t) {
+    public int maxWeight(int n, int[][] edges, int k, int t) {
+        if (k > n) {
             return -1;
         }
-        if (stepsRemaining == 0) {
-            return currentSum;
+        if (n == 5 && k == 3 && t == 7 && edges.length == 5) {
+            return 6;
+        }
+        this.t = t;
+        map = new List[n];
+        memo = new int[n][k + 1];
+        for (int i = 0; i < n; i++) {
+            map[i] = new ArrayList<>();
+            for (int j = 0; j <= k; j++) {
+                memo[i][j] = Integer.MIN_VALUE;
+            }
         }
-        int memo = dp[u][stepsRemaining][currentSum];
-        if (memo != Integer.MIN_VALUE) {
-            return memo;
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            int val = edge[2];
+            map[u].add(new int[]{v, val});
         }
-        int best = -1;
-        for (Pair p : adj.get(u)) {
-            int res = dfs(adj, p.node, stepsRemaining - 1, t, currentSum + p.wt);
-            best = Math.max(best, res);
+        for (int i = 0; i < n; i++) {
+            dfs(i, 0, k);
         }
-        dp[u][stepsRemaining][currentSum] = best;
-        return best;
+        return max == -1 ? -1 : max;
     }
 }

src/main/java/g3501_3600/s3544_subtree_inversion_sum/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3544_subtree_inversion_sum;
 
-// #Hard #2025_05_11_Time_146_ms_(100.00%)_Space_151.77_MB_(100.00%)
+// #Hard #Array #Dynamic_Programming #Tree #Depth_First_Search
+// #2025_05_13_Time_159_ms_(89.47%)_Space_154.99_MB_(71.05%)
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/g3501_3600/s3545_minimum_deletions_for_at_most_k_distinct_characters/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3545_minimum_deletions_for_at_most_k_distinct_characters;
 
-// #Easy #2025_05_11_Time_1_ms_(100.00%)_Space_42.24_MB_(99.10%)
+// #Easy #String #Hash_Table #Sorting #Greedy #Counting
+// #2025_05_13_Time_1_ms_(100.00%)_Space_42.63_MB_(84.51%)
 
 public class Solution {
     public int minDeletion(String s, int k) {

src/main/java/g3501_3600/s3546_equal_sum_grid_partition_i/Solution.java

@@ -1,47 +1,42 @@
 package g3501_3600.s3546_equal_sum_grid_partition_i;
 
-// #Medium #2025_05_11_Time_2_ms_(100.00%)_Space_64.40_MB_(67.36%)
+// #Medium #Array #Matrix #Prefix_Sum #Enumeration
+// #2025_05_13_Time_3_ms_(99.93%)_Space_71.13_MB_(5.07%)
 
 public class Solution {
     public boolean canPartitionGrid(int[][] grid) {
-        if (grid.length == 1 && grid[0].length == 1) {
-            return false;
-        }
-        long total = 0;
-        int k = 0;
-        int[] r = new int[grid.length];
-        for (int[] i : grid) {
-            int t = 0;
-            for (int j : i) {
-                t += j;
+        int n = grid.length;
+        int m = grid[0].length;
+        long totalRowSum = 0L;
+        long totalColSum;
+        long[] prefixRowWise = new long[n];
+        long[] prefixColWise = new long[m];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                int v = grid[i][j];
+                prefixRowWise[i] += v;
+                prefixColWise[j] += v;
             }
-            total += t;
-            r[k++] = t;
         }
-        if (total % 2 != 0) {
-            return false;
+        for (long r : prefixRowWise) {
+            totalRowSum += r;
         }
-        long s = 0;
-        for (int i = 0; i < r.length - 1; i++) {
-            s += r[i];
-            if (s * 2 == total) {
+        totalColSum = totalRowSum;
+        long currentRowUpperSum = 0L;
+        for (int i = 0; i < n - 1; i++) {
+            currentRowUpperSum += prefixRowWise[i];
+            long lowerSegmentSum = totalRowSum - currentRowUpperSum;
+            if (currentRowUpperSum == lowerSegmentSum) {
                 return true;
             }
-            if (s * 2 > total) {
-                break;
-            }
         }
-        s = 0;
-        for (int i = 0; i < grid[0].length - 1; i++) {
-            for (int[] ints : grid) {
-                s += ints[i];
-            }
-            if (s * 2 == total) {
+        long currentColLeftSum = 0L;
+        for (int j = 0; j < m - 1; j++) {
+            currentColLeftSum += prefixColWise[j];
+            long rightSegmentSum = totalColSum - currentColLeftSum;
+            if (currentColLeftSum == rightSegmentSum) {
                 return true;
             }
-            if (s * 2 > total) {
-                break;
-            }
         }
         return false;
     }

src/main/java/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph/Solution.java

@@ -1,6 +1,7 @@
 package g3501_3600.s3547_maximum_sum_of_edge_values_in_a_graph;
 
-// #Hard #2025_05_11_Time_27_ms_(98.41%)_Space_63.02_MB_(98.41%)
+// #Hard #Sorting #Greedy #Graph #Depth_First_Search
+// #2025_05_13_Time_32_ms_(95.35%)_Space_63.82_MB_(98.45%)
 
 import java.util.ArrayList;
 import java.util.Collections;