Added tasks 3541-3548

Author: javadev

README.md

@@ -2088,6 +2088,14 @@
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|--------
+| 3548 |[Equal Sum Grid Partition II](src/main/java/g3501_3600/s3548_equal_sum_grid_partition_ii)| Hard | Array, Hash_Table, Matrix, Prefix_Sum, Enumeration | 46 | 85.24
+| 3547 |[Maximum Sum of Edge Values in a Graph](src/main/java/g3501_3600/s3547_maximum_sum_of_edge_values_in_a_graph)| Hard | Sorting, Depth_First_Search, Greedy, Graph | 32 | 95.35
+| 3546 |[Equal Sum Grid Partition I](src/main/java/g3501_3600/s3546_equal_sum_grid_partition_i)| Medium | Array, Matrix, Prefix_Sum, Enumeration | 3 | 99.93
+| 3545 |[Minimum Deletions for At Most K Distinct Characters](src/main/java/g3501_3600/s3545_minimum_deletions_for_at_most_k_distinct_characters)| Easy | String, Hash_Table, Sorting, Greedy, Counting | 1 | 100.00
+| 3544 |[Subtree Inversion Sum](src/main/java/g3501_3600/s3544_subtree_inversion_sum)| Hard | Array, Dynamic_Programming, Depth_First_Search, Tree | 159 | 89.47
+| 3543 |[Maximum Weighted K-Edge Path](src/main/java/g3501_3600/s3543_maximum_weighted_k_edge_path)| Medium | Hash_Table, Dynamic_Programming, Graph | 12 | 100.00
+| 3542 |[Minimum Operations to Convert All Elements to Zero](src/main/java/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero)| Medium | Array, Hash_Table, Greedy, Stack, Monotonic_Stack | 11 | 100.00
+| 3541 |[Find Most Frequent Vowel and Consonant](src/main/java/g3501_3600/s3541_find_most_frequent_vowel_and_consonant)| Easy | String, Hash_Table, Counting | 1 | 100.00
 | 3539 |[Find Sum of Array Product of Magical Sequences](src/main/java/g3501_3600/s3539_find_sum_of_array_product_of_magical_sequences)| Hard | Array, Dynamic_Programming, Math, Bit_Manipulation, Bitmask, Combinatorics | 39 | 95.71
 | 3538 |[Merge Operations for Minimum Travel Time](src/main/java/g3501_3600/s3538_merge_operations_for_minimum_travel_time)| Hard | Array, Dynamic_Programming, Prefix_Sum | 7 | 99.32
 | 3537 |[Fill a Special Grid](src/main/java/g3501_3600/s3537_fill_a_special_grid)| Medium | Array, Matrix, Divide_and_Conquer | 2 | 100.00

src/main/java/g3501_3600/s3541_find_most_frequent_vowel_and_consonant/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3541\. Find Most Frequent Vowel and Consonant
+
+Easy
+
+You are given a string `s` consisting of lowercase English letters (`'a'` to `'z'`).
+
+Your task is to:
+
+*   Find the vowel (one of `'a'`, `'e'`, `'i'`, `'o'`, or `'u'`) with the **maximum** frequency.
+*   Find the consonant (all other letters excluding vowels) with the **maximum** frequency.
+
+Return the sum of the two frequencies.
+
+**Note**: If multiple vowels or consonants have the same maximum frequency, you may choose any one of them. If there are no vowels or no consonants in the string, consider their frequency as 0.
+
+The **frequency** of a letter `x` is the number of times it occurs in the string.
+
+**Example 1:**
+
+**Input:** s = "successes"
+
+**Output:** 6
+
+**Explanation:**
+
+*   The vowels are: `'u'` (frequency 1), `'e'` (frequency 2). The maximum frequency is 2.
+*   The consonants are: `'s'` (frequency 4), `'c'` (frequency 2). The maximum frequency is 4.
+*   The output is `2 + 4 = 6`.
+
+**Example 2:**
+
+**Input:** s = "aeiaeia"
+
+**Output:** 3
+
+**Explanation:**
+
+*   The vowels are: `'a'` (frequency 3), `'e'` ( frequency 2), `'i'` (frequency 2). The maximum frequency is 3.
+*   There are no consonants in `s`. Hence, maximum consonant frequency = 0.
+*   The output is `3 + 0 = 3`.
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists of lowercase English letters only.
+
+## Solution
+
+```java
+public class Solution {
+    public int maxFreqSum(String s) {
+        int[] freq = new int[26];
+        for (char ch : s.toCharArray()) {
+            int index = ch - 'a';
+            freq[index]++;
+        }
+        String si = "aeiou";
+        int max1 = 0;
+        int max2 = 0;
+        for (int i = 0; i < 26; i++) {
+            char ch = (char) (i + 'a');
+            if (si.indexOf(ch) != -1) {
+                max1 = Math.max(max1, freq[i]);
+            } else {
+                max2 = Math.max(max2, freq[i]);
+            }
+        }
+        return max1 + max2;
+    }
+}
+```

src/main/java/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/readme.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3542\. Minimum Operations to Convert All Elements to Zero
+
+Medium
+
+You are given an array `nums` of size `n`, consisting of **non-negative** integers. Your task is to apply some (possibly zero) operations on the array so that **all** elements become 0.
+
+In one operation, you can select a subarray `[i, j]` (where `0 <= i <= j < n`) and set all occurrences of the **minimum** **non-negative** integer in that subarray to 0.
+
+Return the **minimum** number of operations required to make all elements in the array 0.
+
+**Example 1:**
+
+**Input:** nums = [0,2]
+
+**Output:** 1
+
+**Explanation:**
+
+*   Select the subarray `[1,1]` (which is `[2]`), where the minimum non-negative integer is 2. Setting all occurrences of 2 to 0 results in `[0,0]`.
+*   Thus, the minimum number of operations required is 1.
+
+**Example 2:**
+
+**Input:** nums = [3,1,2,1]
+
+**Output:** 3
+
+**Explanation:**
+
+*   Select subarray `[1,3]` (which is `[1,2,1]`), where the minimum non-negative integer is 1. Setting all occurrences of 1 to 0 results in `[3,0,2,0]`.
+*   Select subarray `[2,2]` (which is `[2]`), where the minimum non-negative integer is 2. Setting all occurrences of 2 to 0 results in `[3,0,0,0]`.
+*   Select subarray `[0,0]` (which is `[3]`), where the minimum non-negative integer is 3. Setting all occurrences of 3 to 0 results in `[0,0,0,0]`.
+*   Thus, the minimum number of operations required is 3.
+
+**Example 3:**
+
+**Input:** nums = [1,2,1,2,1,2]
+
+**Output:** 4
+
+**Explanation:**
+
+*   Select subarray `[0,5]` (which is `[1,2,1,2,1,2]`), where the minimum non-negative integer is 1. Setting all occurrences of 1 to 0 results in `[0,2,0,2,0,2]`.
+*   Select subarray `[1,1]` (which is `[2]`), where the minimum non-negative integer is 2. Setting all occurrences of 2 to 0 results in `[0,0,0,2,0,2]`.
+*   Select subarray `[3,3]` (which is `[2]`), where the minimum non-negative integer is 2. Setting all occurrences of 2 to 0 results in `[0,0,0,0,0,2]`.
+*   Select subarray `[5,5]` (which is `[2]`), where the minimum non-negative integer is 2. Setting all occurrences of 2 to 0 results in `[0,0,0,0,0,0]`.
+*   Thus, the minimum number of operations required is 4.
+
+**Constraints:**
+
+*   <code>1 <= n == nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>
+
+## Solution
+
+```java
+public class Solution {
+    public int minOperations(int[] nums) {
+        int[] mq = new int[nums.length];
+        int idx = 0;
+        int res = 0;
+        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 + idx;
+    }
+}
+```

src/main/java/g3501_3600/s3543_maximum_weighted_k_edge_path/readme.md

@@ -0,0 +1,134 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Java?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Java)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Java?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Java/fork)
+
+## 3543\. Maximum Weighted K-Edge Path
+
+Medium
+
+You are given an integer `n` and a **Directed Acyclic Graph (DAG)** with `n` nodes labeled from 0 to `n - 1`. This is represented by a 2D array `edges`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> indicates a directed edge from node <code>u<sub>i</sub></code> to <code>v<sub>i</sub></code> with weight <code>w<sub>i</sub></code>.
+
+You are also given two integers, `k` and `t`.
+
+Your task is to determine the **maximum** possible sum of edge weights for any path in the graph such that:
+
+*   The path contains **exactly** `k` edges.
+*   The total sum of edge weights in the path is **strictly** less than `t`.
+
+Return the **maximum** possible sum of weights for such a path. If no such path exists, return `-1`.
+
+**Example 1:**
+
+**Input:** n = 3, edges = \[\[0,1,1],[1,2,2]], k = 2, t = 4
+
+**Output:** 3
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/09/screenshot-2025-04-10-at-061326.png)
+
+*   The only path with `k = 2` edges is `0 -> 1 -> 2` with weight `1 + 2 = 3 < t`.
+*   Thus, the maximum possible sum of weights less than `t` is 3.
+
+**Example 2:**
+
+**Input:** n = 3, edges = \[\[0,1,2],[0,2,3]], k = 1, t = 3
+
+**Output:** 2
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/09/screenshot-2025-04-10-at-061406.png)
+
+*   There are two paths with `k = 1` edge:
+    *   `0 -> 1` with weight `2 < t`.
+    *   `0 -> 2` with weight `3 = t`, which is not strictly less than `t`.
+*   Thus, the maximum possible sum of weights less than `t` is 2.
+
+**Example 3:**
+
+**Input:** n = 3, edges = \[\[0,1,6],[1,2,8]], k = 1, t = 6
+
+**Output:** \-1
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/09/screenshot-2025-04-10-at-061442.png)
+
+*   There are two paths with k = 1 edge:
+    *   `0 -> 1` with weight `6 = t`, which is not strictly less than `t`.
+    *   `1 -> 2` with weight `8 > t`, which is not strictly less than `t`.
+*   Since there is no path with sum of weights strictly less than `t`, the answer is -1.
+
+**Constraints:**
+
+*   `1 <= n <= 300`
+*   `0 <= edges.length <= 300`
+*   <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code>
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   <code>1 <= w<sub>i</sub> <= 10</code>
+*   `0 <= k <= 300`
+*   `1 <= t <= 600`
+*   The input graph is **guaranteed** to be a **DAG**.
+*   There are no duplicate edges.
+
+## Solution
+
+```java
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("unchecked")
+public class Solution {
+    private int max = -1;
+    private int t;
+    private List<int[]>[] map;
+    private int[][] memo;
+
+    private void dfs(int cur, int sum, int k) {
+        if (k == 0) {
+            if (sum < t) {
+                max = Math.max(max, sum);
+            }
+            return;
+        }
+        if (sum >= t) {
+            return;
+        }
+        if (memo[cur][k] >= sum) {
+            return;
+        }
+        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);
+        }
+    }
+
+    public int maxWeight(int n, int[][] edges, int k, int t) {
+        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;
+            }
+        }
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            int val = edge[2];
+            map[u].add(new int[] {v, val});
+        }
+        for (int i = 0; i < n; i++) {
+            dfs(i, 0, k);
+        }
+        return max == -1 ? -1 : max;
+    }
+}
+```