Added tasks 3541-3548

Author: javadev

src/main/kotlin/g3501_3600/s3541_find_most_frequent_vowel_and_consonant/Solution.kt

@@ -0,0 +1,27 @@
+package g3501_3600.s3541_find_most_frequent_vowel_and_consonant
+
+// #Easy #2025_05_11_Time_8_ms_(100.00%)_Space_43.92_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxFreqSum(s: String): Int {
+        val freq = IntArray(26)
+        for (ch in s.toCharArray()) {
+            val index = ch.code - 'a'.code
+            freq[index]++
+        }
+        val si = "aeiou"
+        var max1 = 0
+        var max2 = 0
+        for (i in 0..25) {
+            val ch = (i + 'a'.code).toChar()
+            if (si.indexOf(ch) != -1) {
+                max1 = max(max1, freq[i])
+            } else {
+                max2 = max(max2, freq[i])
+            }
+        }
+        return max1 + max2
+    }
+}

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

@@ -0,0 +1,45 @@
+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.

src/main/kotlin/g3501_3600/s3542_minimum_operations_to_convert_all_elements_to_zero/Solution.kt

@@ -0,0 +1,24 @@
+package g3501_3600.s3542_minimum_operations_to_convert_all_elements_to_zero
+
+// #Medium #2025_05_11_Time_48_ms_(100.00%)_Space_78.24_MB_(100.00%)
+
+import java.util.ArrayDeque
+import java.util.Deque
+
+class Solution {
+    fun minOperations(nums: IntArray): Int {
+        val stack: Deque<Int> = ArrayDeque<Int>()
+        stack.push(0)
+        var res = 0
+        for (a in nums) {
+            while (!stack.isEmpty() && stack.peek()!! > a) {
+                stack.pop()
+            }
+            if (stack.isEmpty() || stack.peek()!! < a) {
+                res++
+                stack.push(a)
+            }
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,52 @@
+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>

src/main/kotlin/g3501_3600/s3543_maximum_weighted_k_edge_path/Solution.kt

@@ -0,0 +1,56 @@
+package g3501_3600.s3543_maximum_weighted_k_edge_path
+
+// #Medium #2025_05_11_Time_680_ms_(100.00%)_Space_308.89_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    private lateinit var dp: Array<Array<IntArray>>
+
+    private class Pair(var node: Int, var wt: Int)
+
+    fun maxWeight(n: Int, edges: Array<IntArray>, k: Int, t: Int): Int {
+        if (k == 0) {
+            return 0
+        }
+        dp = Array<Array<IntArray>>(n) { Array<IntArray>(k + 1) { IntArray(t + 1) } }
+        for (i in 0..<n) {
+            for (j in 0..k) {
+                dp[i][j].fill(Int.Companion.MIN_VALUE)
+            }
+        }
+        val adj: MutableList<MutableList<Pair>> = ArrayList<MutableList<Pair>>()
+        for (i in 0..<n) {
+            adj.add(ArrayList<Pair>())
+        }
+        for (edge in edges) {
+            adj.get(edge[0]).add(Pair(edge[1], edge[2]))
+        }
+        var ans = -1
+        for (start in 0..<n) {
+            val res = dfs(adj, start, k, t, 0)
+            ans = max(ans, res)
+        }
+        return ans
+    }
+
+    private fun dfs(adj: MutableList<MutableList<Pair>>, u: Int, stepsRemaining: Int, t: Int, currentSum: Int): Int {
+        if (currentSum >= t) {
+            return -1
+        }
+        if (stepsRemaining == 0) {
+            return currentSum
+        }
+        val memo = dp[u][stepsRemaining][currentSum]
+        if (memo != Int.Companion.MIN_VALUE) {
+            return memo
+        }
+        var best = -1
+        for (p in adj.get(u)) {
+            val res = dfs(adj, p.node, stepsRemaining - 1, t, currentSum + p.wt)
+            best = max(best, res)
+        }
+        dp[u][stepsRemaining][currentSum] = best
+        return best
+    }
+}

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

@@ -0,0 +1,70 @@
+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.

src/main/kotlin/g3501_3600/s3544_subtree_inversion_sum/Solution.kt

@@ -0,0 +1,80 @@
+package g3501_3600.s3544_subtree_inversion_sum
+
+// #Hard #2025_05_11_Time_114_ms_(100.00%)_Space_195.14_MB_(100.00%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    private lateinit var totalSum: LongArray
+    private lateinit var nums: IntArray
+    private lateinit var nei: MutableList<MutableList<Int>>
+    private var k = 0
+
+    private fun getTotalSum(p: Int, cur: Int): Long {
+        var res = nums[cur].toLong()
+        for (c in nei[cur]) {
+            if (c == p) {
+                continue
+            }
+            res += getTotalSum(cur, c)
+        }
+        totalSum[cur] = res
+        return res
+    }
+
+    private fun add(a: Array<LongArray>, b: Array<LongArray>) {
+        for (i in a.indices) {
+            for (j in a[0].indices) {
+                a[i][j] += b[i][j]
+            }
+        }
+    }
+
+    private fun getMaxInc(p: Int, cur: Int): Array<LongArray> {
+        val ret = Array<LongArray>(3) { LongArray(k) }
+        for (c in nei[cur]) {
+            if (c == p) {
+                continue
+            }
+            add(ret, getMaxInc(cur, c))
+        }
+        val maxCandWithoutInv = nums[cur] + ret[2][0]
+        val maxCandWithInv = -(totalSum[cur] - ret[0][k - 1]) - ret[1][k - 1]
+        val minCandWithoutInv = nums[cur] + ret[1][0]
+        val minCandWithInv = -(totalSum[cur] - ret[0][k - 1]) - ret[2][k - 1]
+        val res = Array<LongArray>(3) { LongArray(k) }
+        for (i in 0..<k - 1) {
+            res[0][i + 1] = ret[0][i]
+            res[1][i + 1] = ret[1][i]
+            res[2][i + 1] = ret[2][i]
+        }
+        res[0][0] = totalSum[cur]
+        res[1][0] = min(
+            min(maxCandWithoutInv, maxCandWithInv),
+            min(minCandWithoutInv, minCandWithInv)
+        )
+        res[2][0] = max(
+            max(maxCandWithoutInv, maxCandWithInv),
+            max(minCandWithoutInv, minCandWithInv)
+        )
+        return res
+    }
+
+    fun subtreeInversionSum(edges: Array<IntArray>, nums: IntArray, k: Int): Long {
+        totalSum = LongArray(nums.size)
+        this.nums = nums
+        nei = ArrayList<MutableList<Int>>()
+        this.k = k
+        for (i in nums.indices) {
+            nei.add(ArrayList<Int>())
+        }
+        for (e in edges) {
+            nei.get(e[0]).add(e[1])
+            nei.get(e[1]).add(e[0])
+        }
+        getTotalSum(-1, 0)
+        val res = getMaxInc(-1, 0)
+        return res[2][0]
+    }
+}