Added tasks 3612-3615

Author: javadev

src/main/java/g3601_3700/s3609_minimum_moves_to_reach_target_in_grid/Solution.java

@@ -7,7 +7,6 @@ public int minMoves(int sx, int sy, int tx, int ty) {
         if (sx == 0 && sy == 0) {
             return tx == 0 && ty == 0 ? 0 : -1;
         }
-
         int res = 0;
         while (sx != tx || sy != ty) {
             if (sx > tx || sy > ty) {

src/main/java/g3601_3700/s3612_process_string_with_special_operations_i/Solution.java

@@ -0,0 +1,23 @@
+package g3601_3700.s3612_process_string_with_special_operations_i;
+
+// #Medium #String #Simulation #2025_07_14_Time_3_ms_(100.00%)_Space_54.53_MB_(100.00%)
+
+public class Solution {
+    public String processStr(String s) {
+        StringBuilder res = new StringBuilder();
+        for (char c : 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/java/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/java/g3601_3700/s3613_minimize_maximum_component_cost/Solution.java

@@ -0,0 +1,58 @@
+package g3601_3700.s3613_minimize_maximum_component_cost;
+
+// #Medium #Binary_Search #Graph #Union_Find #Sort
+// #2025_07_14_Time_37_ms_(100.00%)_Space_88.50_MB_(98.52%)
+
+public class Solution {
+    public int minCost(int ui, int[][] pl, int zx) {
+        int rt = 0;
+        int gh = 0;
+        int i = 0;
+        while (i < pl.length) {
+            gh = Math.max(gh, pl[i][2]);
+            i++;
+        }
+        while (rt < gh) {
+            int ty = rt + (gh - rt) / 2;
+            if (dfgh(ui, pl, ty, zx)) {
+                gh = ty;
+            } else {
+                rt = ty + 1;
+            }
+        }
+        return rt;
+    }
+
+    private boolean dfgh(int ui, int[][] pl, int jk, int zx) {
+        int[] wt = new int[ui];
+        int i = 0;
+        while (i < ui) {
+            wt[i] = i;
+            i++;
+        }
+        int er = ui;
+        i = 0;
+        while (i < pl.length) {
+            int[] df = pl[i];
+            if (df[2] > jk) {
+                i++;
+                continue;
+            }
+            int u = cvb(wt, df[0]);
+            int v = cvb(wt, df[1]);
+            if (u != v) {
+                wt[u] = v;
+                er--;
+            }
+            i++;
+        }
+        return er <= zx;
+    }
+
+    private int cvb(int[] wt, int i) {
+        for (; wt[i] != i; i = wt[i]) {
+            wt[i] = wt[wt[i]];
+        }
+        return i;
+    }
+}

src/main/java/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/java/g3601_3700/s3614_process_string_with_special_operations_ii/Solution.java

@@ -0,0 +1,40 @@
+package g3601_3700.s3614_process_string_with_special_operations_ii;
+
+// #Hard #String #Simulation #2025_07_14_Time_33_ms_(100.00%)_Space_50.49_MB_(100.00%)
+
+public class Solution {
+    public char processStr(String s, long k) {
+        long len = 0;
+        for (char c : s.toCharArray()) {
+            if (Character.isLowerCase(c)) {
+                len++;
+            } else if (c == '*' && len > 0) {
+                len--;
+            } else if (c == '#') {
+                len *= 2;
+            }
+        }
+        if (k >= len) {
+            return '.';
+        }
+        for (int i = s.length() - 1; i >= 0; i--) {
+            char c = s.charAt(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/java/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>.