Added tasks 3612-3615

Author: javadev

src/main/kotlin/g3601_3700/s3612_process_string_with_special_operations_i/Solution.kt

@@ -0,0 +1,23 @@
+package g3601_3700.s3612_process_string_with_special_operations_i
+
+// #Medium #String #Simulation #2025_07_14_Time_5_ms_(100.00%)_Space_54.27_MB_(100.00%)
+
+class Solution {
+    fun processStr(s: String): String {
+        val res = StringBuilder()
+        for (c in s.toCharArray()) {
+            if (c != '*' && c != '#' && c != '%') {
+                res.append(c)
+            } else if (c == '#') {
+                res.append(res)
+            } else if (c == '%') {
+                res.reverse()
+            } else {
+                if (!res.isEmpty()) {
+                    res.deleteCharAt(res.length - 1)
+                }
+            }
+        }
+        return res.toString()
+    }
+}

src/main/kotlin/g3601_3700/s3612_process_string_with_special_operations_i/readme.md

@@ -0,0 +1,119 @@
+3612\. Process String with Special Operations I
+
+Medium
+
+You are given a string `s` consisting of lowercase English letters and the special characters: `*`, `#`, and `%`.
+
+Build a new string `result` by processing `s` according to the following rules from left to right:
+
+*   If the letter is a **lowercase** English letter append it to `result`.
+*   A `'*'` **removes** the last character from `result`, if it exists.
+*   A `'#'` **duplicates** the current `result` and **appends** it to itself.
+*   A `'%'` **reverses** the current `result`.
+
+Return the final string `result` after processing all characters in `s`.
+
+**Example 1:**
+
+**Input:** s = "a#b%\*"
+
+**Output:** "ba"
+
+**Explanation:**
+
+`i`
+
+`s[i]`
+
+Operation
+
+Current `result`
+
+0
+
+`'a'`
+
+Append `'a'`
+
+`"a"`
+
+1
+
+`'#'`
+
+Duplicate `result`
+
+`"aa"`
+
+2
+
+`'b'`
+
+Append `'b'`
+
+`"aab"`
+
+3
+
+`'%'`
+
+Reverse `result`
+
+`"baa"`
+
+4
+
+`'*'`
+
+Remove the last character
+
+`"ba"`
+
+Thus, the final `result` is `"ba"`.
+
+**Example 2:**
+
+**Input:** s = "z\*#"
+
+**Output:** ""
+
+**Explanation:**
+
+`i`
+
+`s[i]`
+
+Operation
+
+Current `result`
+
+0
+
+`'z'`
+
+Append `'z'`
+
+`"z"`
+
+1
+
+`'*'`
+
+Remove the last character
+
+`""`
+
+2
+
+`'#'`
+
+Duplicate the string
+
+`""`
+
+Thus, the final `result` is `""`.
+
+**Constraints:**
+
+*   `1 <= s.length <= 20`
+*   `s` consists of only lowercase English letters and special characters `*`, `#`, and `%`.

src/main/kotlin/g3601_3700/s3613_minimize_maximum_component_cost/Solution.kt

@@ -0,0 +1,61 @@
+package g3601_3700.s3613_minimize_maximum_component_cost
+
+// #Medium #2025_07_14_Time_34_ms_(100.00%)_Space_134.64_MB_(44.44%)
+
+import kotlin.math.max
+
+class Solution {
+    fun minCost(ui: Int, pl: Array<IntArray>, zx: Int): Int {
+        var rt = 0
+        var gh = 0
+        var i = 0
+        while (i < pl.size) {
+            gh = max(gh, pl[i][2])
+            i++
+        }
+        while (rt < gh) {
+            val ty = rt + (gh - rt) / 2
+            if (dfgh(ui, pl, ty, zx)) {
+                gh = ty
+            } else {
+                rt = ty + 1
+            }
+        }
+        return rt
+    }
+
+    private fun dfgh(ui: Int, pl: Array<IntArray>, jk: Int, zx: Int): Boolean {
+        val wt = IntArray(ui)
+        var i = 0
+        while (i < ui) {
+            wt[i] = i
+            i++
+        }
+        var er = ui
+        i = 0
+        while (i < pl.size) {
+            val df = pl[i]
+            if (df[2] > jk) {
+                i++
+                continue
+            }
+            val u = cvb(wt, df[0])
+            val v = cvb(wt, df[1])
+            if (u != v) {
+                wt[u] = v
+                er--
+            }
+            i++
+        }
+        return er <= zx
+    }
+
+    private fun cvb(wt: IntArray, i: Int): Int {
+        var i = i
+        while (wt[i] != i) {
+            wt[i] = wt[wt[i]]
+            i = wt[i]
+        }
+        return i
+    }
+}

src/main/kotlin/g3601_3700/s3613_minimize_maximum_component_cost/readme.md

@@ -0,0 +1,47 @@
+3613\. Minimize Maximum Component Cost
+
+Medium
+
+You are given an undirected connected graph with `n` nodes labeled from 0 to `n - 1` and a 2D integer array `edges` where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> denotes an undirected edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with weight <code>w<sub>i</sub></code>, and an integer `k`.
+
+You are allowed to remove any number of edges from the graph such that the resulting graph has **at most** `k` connected components.
+
+The **cost** of a component is defined as the **maximum** edge weight in that component. If a component has no edges, its cost is 0.
+
+Return the **minimum** possible value of the **maximum** cost among all components **after such removals**.
+
+**Example 1:**
+
+**Input:** n = 5, edges = [[0,1,4],[1,2,3],[1,3,2],[3,4,6]], k = 2
+
+**Output:** 4
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/19/minimizemaximumm.jpg)
+
+*   Remove the edge between nodes 3 and 4 (weight 6).
+*   The resulting components have costs of 0 and 4, so the overall maximum cost is 4.
+
+**Example 2:**
+
+**Input:** n = 4, edges = [[0,1,5],[1,2,5],[2,3,5]], k = 1
+
+**Output:** 5
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/04/19/minmax2.jpg)
+
+*   No edge can be removed, since allowing only one component (`k = 1`) requires the graph to stay fully connected.
+*   That single component’s cost equals its largest edge weight, which is 5.
+
+**Constraints:**
+
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>0 <= edges.length <= 10<sup>5</sup></code>
+*   `edges[i].length == 3`
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>1 <= w<sub>i</sub> <= 10<sup>6</sup></code>
+*   `1 <= k <= n`
+*   The input graph is connected.

src/main/kotlin/g3601_3700/s3614_process_string_with_special_operations_ii/Solution.kt

@@ -0,0 +1,41 @@
+package g3601_3700.s3614_process_string_with_special_operations_ii
+
+// #Hard #2025_07_14_Time_37_ms_(100.00%)_Space_50.21_MB_(100.00%)
+
+class Solution {
+    fun processStr(s: String, k: Long): Char {
+        var k = k
+        var len: Long = 0
+        for (c in s.toCharArray()) {
+            if (Character.isLowerCase(c)) {
+                len++
+            } else if (c == '*' && len > 0) {
+                len--
+            } else if (c == '#') {
+                len *= 2
+            }
+        }
+        if (k >= len) {
+            return '.'
+        }
+        for (i in s.length - 1 downTo 0) {
+            val c = s[i]
+            if (Character.isLowerCase(c)) {
+                if (k == len - 1) {
+                    return c
+                }
+                len--
+            } else if (c == '*') {
+                len++
+            } else if (c == '#') {
+                len /= 2
+                if (k >= len) {
+                    k -= len
+                }
+            } else if (c == '%') {
+                k = len - 1 - k
+            }
+        }
+        return '.'
+    }
+}

src/main/kotlin/g3601_3700/s3614_process_string_with_special_operations_ii/readme.md

@@ -0,0 +1,76 @@
+3614\. Process String with Special Operations II
+
+Hard
+
+You are given a string `s` consisting of lowercase English letters and the special characters: `'*'`, `'#'`, and `'%'`.
+
+You are also given an integer `k`.
+
+Build a new string `result` by processing `s` according to the following rules from left to right:
+
+*   If the letter is a **lowercase** English letter append it to `result`.
+*   A `'*'` **removes** the last character from `result`, if it exists.
+*   A `'#'` **duplicates** the current `result` and **appends** it to itself.
+*   A `'%'` **reverses** the current `result`.
+
+Return the <code>k<sup>th</sup></code> character of the final string `result`. If `k` is out of the bounds of `result`, return `'.'`.
+
+**Example 1:**
+
+**Input:** s = "a#b%\*", k = 1
+
+**Output:** "a"
+
+**Explanation:**
+
+| i | s[i]  | Operation                  | Current `result` |
+|---|-------|----------------------------|------------------|
+| 0 | `'a'` | Append `'a'`               | `"a"`            |
+| 1 | `'#'` | Duplicate `result`         | `"aa"`           |
+| 2 | `'b'` | Append `'b'`               | `"aab"`          |
+| 3 | `'%'` | Reverse `result`           | `"baa"`          |
+| 4 | `'*'` | Remove the last character  | `"ba"`           |
+
+The final `result` is `"ba"`. The character at index `k = 1` is `'a'`.
+
+**Example 2:**
+
+**Input:** s = "cd%#\*#", k = 3
+
+**Output:** "d"
+
+**Explanation:**
+
+| i | s[i]  | Operation                  | Current `result` |
+|---|-------|----------------------------|------------------|
+| 0 | `'c'` | Append `'c'`               | `"c"`            |
+| 1 | `'d'` | Append `'d'`               | `"cd"`           |
+| 2 | `'%'` | Reverse `result`           | `"dc"`           |
+| 3 | `'#'` | Duplicate `result`         | `"dcdc"`         |
+| 4 | `'*'` | Remove the last character  | `"dcd"`          |
+| 5 | `'#'` | Duplicate `result`         | `"dcddcd"`       |
+
+The final `result` is `"dcddcd"`. The character at index `k = 3` is `'d'`.
+
+**Example 3:**
+
+**Input:** s = "z\*#", k = 0
+
+**Output:** "."
+
+**Explanation:**
+
+| i | s[i]  | Operation                 | Current `result` |
+|---|-------|---------------------------|------------------|
+| 0 | `'z'` | Append `'z'`              | `"z"`            |
+| 1 | `'*'` | Remove the last character | `""`             |
+| 2 | `'#'` | Duplicate the string      | `""`             |
+
+The final `result` is `""`. Since index `k = 0` is out of bounds, the output is `'.'`.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only lowercase English letters and special characters `'*'`, `'#'`, and `'%'`.
+*   <code>0 <= k <= 10<sup>15</sup></code>
+*   The length of `result` after processing `s` will not exceed <code>10<sup>15</sup></code>.