Added tasks 3602-3609

Author: javadev

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

@@ -0,0 +1,39 @@
+package g3601_3700.s3602_hexadecimal_and_hexatrigesimal_conversion
+
+// #Easy #String #Math #2025_07_07_Time_2_ms_(100.00%)_Space_41.91_MB_(100.00%)
+
+class Solution {
+    fun concatHex36(n: Int): String {
+        var t = n * n
+        var k: Int
+        val st = StringBuilder()
+        var tmp = StringBuilder()
+        while (t > 0) {
+            k = t % 16
+            t = t / 16
+            if (k <= 9) {
+                tmp.append(('0'.code + k).toChar())
+            } else {
+                tmp.append(('A'.code + (k - 10)).toChar())
+            }
+        }
+        for (i in tmp.length - 1 downTo 0) {
+            st.append(tmp[i])
+        }
+        tmp = StringBuilder()
+        t = n * n * n
+        while (t > 0) {
+            k = t % 36
+            t = t / 36
+            if (k <= 9) {
+                tmp.append(('0'.code + k).toChar())
+            } else {
+                tmp.append(('A'.code + (k - 10)).toChar())
+            }
+        }
+        for (i in tmp.length - 1 downTo 0) {
+            st.append(tmp[i])
+        }
+        return st.toString()
+    }
+}

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

@@ -0,0 +1,39 @@
+3602\. Hexadecimal and Hexatrigesimal Conversion
+
+Easy
+
+You are given an integer `n`.
+
+Return the concatenation of the **hexadecimal** representation of <code>n<sup>2</sup></code> and the **hexatrigesimal** representation of <code>n<sup>3</sup></code>.
+
+A **hexadecimal** number is defined as a base-16 numeral system that uses the digits `0 – 9` and the uppercase letters `A - F` to represent values from 0 to 15.
+
+A **hexatrigesimal** number is defined as a base-36 numeral system that uses the digits `0 – 9` and the uppercase letters `A - Z` to represent values from 0 to 35.
+
+**Example 1:**
+
+**Input:** n = 13
+
+**Output:** "A91P1"
+
+**Explanation:**
+
+*   <code>n<sup>2</sup> = 13 * 13 = 169</code>. In hexadecimal, it converts to `(10 * 16) + 9 = 169`, which corresponds to `"A9"`.
+*   <code>n<sup>3</sup> = 13 * 13 * 13 = 2197</code>. In hexatrigesimal, it converts to <code>(1 * 36<sup>2</sup>) + (25 * 36) + 1 = 2197</code>, which corresponds to `"1P1"`.
+*   Concatenating both results gives `"A9" + "1P1" = "A91P1"`.
+
+**Example 2:**
+
+**Input:** n = 36
+
+**Output:** "5101000"
+
+**Explanation:**
+
+*   <code>n<sup>2</sup> = 36 * 36 = 1296</code>. In hexadecimal, it converts to <code>(5 * 16<sup>2</sup>) + (1 * 16) + 0 = 1296</code>, which corresponds to `"510"`.
+*   <code>n<sup>3</sup> = 36 * 36 * 36 = 46656</code>. In hexatrigesimal, it converts to <code>(1 * 36<sup>3</sup>) + (0 * 36<sup>2</sup>) + (0 * 36) + 0 = 46656</code>, which corresponds to `"1000"`.
+*   Concatenating both results gives `"510" + "1000" = "5101000"`.
+
+**Constraints:**
+
+*   `1 <= n <= 1000`

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

@@ -0,0 +1,31 @@
+package g3601_3700.s3603_minimum_cost_path_with_alternating_directions_ii
+
+// #Medium #Array #Dynamic_Programming #Matrix
+// #2025_07_07_Time_12_ms_(100.00%)_Space_84.57_MB_(100.00%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minCost(m: Int, n: Int, waitCost: Array<IntArray>): Long {
+        val dp = LongArray(n)
+        dp[0] = 1L
+        for (j in 1..<n) {
+            val entry = j + 1L
+            val wait = waitCost[0][j].toLong()
+            dp[j] = dp[j - 1] + entry + wait
+        }
+        for (i in 1..<m) {
+            val entry00 = i + 1L
+            val wait00 = waitCost[i][0].toLong()
+            dp[0] = dp[0] + entry00 + wait00
+            for (j in 1..<n) {
+                val entry = (i + 1).toLong() * (j + 1)
+                val wait = waitCost[i][j].toLong()
+                val fromAbove = dp[j]
+                val fromLeft = dp[j - 1]
+                dp[j] = min(fromAbove, fromLeft) + entry + wait
+            }
+        }
+        return dp[n - 1] - waitCost[m - 1][n - 1]
+    }
+}

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

@@ -0,0 +1,77 @@
+3603\. Minimum Cost Path with Alternating Directions II
+
+Medium
+
+You are given two integers `m` and `n` representing the number of rows and columns of a grid, respectively.
+
+The cost to enter cell `(i, j)` is defined as `(i + 1) * (j + 1)`.
+
+You are also given a 2D integer array `waitCost` where `waitCost[i][j]` defines the cost to **wait** on that cell.
+
+You start at cell `(0, 0)` at second 1.
+
+At each step, you follow an alternating pattern:
+
+*   On **odd-numbered** seconds, you must move **right** or **down** to an **adjacent** cell, paying its entry cost.
+*   On **even-numbered** seconds, you must **wait** in place, paying `waitCost[i][j]`.
+
+Return the **minimum** total cost required to reach `(m - 1, n - 1)`.
+
+**Example 1:**
+
+**Input:** m = 1, n = 2, waitCost = [[1,2]]
+
+**Output:** 3
+
+**Explanation:**
+
+The optimal path is:
+
+*   Start at cell `(0, 0)` at second 1 with entry cost `(0 + 1) * (0 + 1) = 1`.
+*   **Second 1**: Move right to cell `(0, 1)` with entry cost `(0 + 1) * (1 + 1) = 2`.
+
+Thus, the total cost is `1 + 2 = 3`.
+
+**Example 2:**
+
+**Input:** m = 2, n = 2, waitCost = [[3,5],[2,4]]
+
+**Output:** 9
+
+**Explanation:**
+
+The optimal path is:
+
+*   Start at cell `(0, 0)` at second 1 with entry cost `(0 + 1) * (0 + 1) = 1`.
+*   **Second 1**: Move down to cell `(1, 0)` with entry cost `(1 + 1) * (0 + 1) = 2`.
+*   **Second 2**: Wait at cell `(1, 0)`, paying `waitCost[1][0] = 2`.
+*   **Second 3**: Move right to cell `(1, 1)` with entry cost `(1 + 1) * (1 + 1) = 4`.
+
+Thus, the total cost is `1 + 2 + 2 + 4 = 9`.
+
+**Example 3:**
+
+**Input:** m = 2, n = 3, waitCost = [[6,1,4],[3,2,5]]
+
+**Output:** 16
+
+**Explanation:**
+
+The optimal path is:
+
+*   Start at cell `(0, 0)` at second 1 with entry cost `(0 + 1) * (0 + 1) = 1`.
+*   **Second 1**: Move right to cell `(0, 1)` with entry cost `(0 + 1) * (1 + 1) = 2`.
+*   **Second 2**: Wait at cell `(0, 1)`, paying `waitCost[0][1] = 1`.
+*   **Second 3**: Move down to cell `(1, 1)` with entry cost `(1 + 1) * (1 + 1) = 4`.
+*   **Second 4**: Wait at cell `(1, 1)`, paying `waitCost[1][1] = 2`.
+*   **Second 5**: Move right to cell `(1, 2)` with entry cost `(1 + 1) * (2 + 1) = 6`.
+
+Thus, the total cost is `1 + 2 + 1 + 4 + 2 + 6 = 16`.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>2 <= m * n <= 10<sup>5</sup></code>
+*   `waitCost.length == m`
+*   `waitCost[0].length == n`
+*   <code>0 <= waitCost[i][j] <= 10<sup>5</sup></code>

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

@@ -0,0 +1,113 @@
+package g3601_3700.s3604_minimum_time_to_reach_destination_in_directed_graph
+
+// #Medium #Heap_Priority_Queue #Graph #Shortest_Path
+// #2025_07_07_Time_18_ms_(100.00%)_Space_132.61_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun minTime(n: Int, edges: Array<IntArray>): Int {
+        val head = IntArray(n)
+        val to = IntArray(edges.size)
+        val start = IntArray(edges.size)
+        val end = IntArray(edges.size)
+        val next = IntArray(edges.size)
+        head.fill(-1)
+        for (i in edges.indices) {
+            val u = edges[i][0]
+            to[i] = edges[i][1]
+            start[i] = edges[i][2]
+            end[i] = edges[i][3]
+            next[i] = head[u]
+            head[u] = i
+        }
+        val heap = IntArray(n)
+        val time = IntArray(n)
+        val pos = IntArray(n)
+        val visited = BooleanArray(n)
+        var size = 0
+        for (i in 0..<n) {
+            time[i] = INF
+            pos[i] = -1
+        }
+        time[0] = 0
+        heap[size] = 0
+        pos[0] = 0
+        size++
+        while (size > 0) {
+            val u = heap[0]
+            heap[0] = heap[--size]
+            pos[heap[0]] = 0
+            heapifyDown(heap, time, pos, size, 0)
+            if (visited[u]) {
+                continue
+            }
+            visited[u] = true
+            if (u == n - 1) {
+                return time[u]
+            }
+            var e = head[u]
+            while (e != -1) {
+                val v = to[e]
+                val t0 = time[u]
+                if (t0 > end[e]) {
+                    e = next[e]
+                    continue
+                }
+                val arrival = max(t0, start[e]) + 1
+                if (arrival < time[v]) {
+                    time[v] = arrival
+                    if (pos[v] == -1) {
+                        heap[size] = v
+                        pos[v] = size
+                        heapifyUp(heap, time, pos, size)
+                        size++
+                    } else {
+                        heapifyUp(heap, time, pos, pos[v])
+                    }
+                }
+                e = next[e]
+            }
+        }
+        return -1
+    }
+
+    private fun heapifyUp(heap: IntArray, time: IntArray, pos: IntArray, i: Int) {
+        var i = i
+        while (i > 0) {
+            val p = (i - 1) / 2
+            if (time[heap[p]] <= time[heap[i]]) {
+                break
+            }
+            swap(heap, pos, i, p)
+            i = p
+        }
+    }
+
+    private fun heapifyDown(heap: IntArray, time: IntArray, pos: IntArray, size: Int, i: Int) {
+        var i = i
+        while (2 * i + 1 < size) {
+            var j = 2 * i + 1
+            if (j + 1 < size && time[heap[j + 1]] < time[heap[j]]) {
+                j++
+            }
+            if (time[heap[i]] <= time[heap[j]]) {
+                break
+            }
+            swap(heap, pos, i, j)
+            i = j
+        }
+    }
+
+    private fun swap(heap: IntArray, pos: IntArray, i: Int, j: Int) {
+        val tmp = heap[i]
+        heap[i] = heap[j]
+        heap[j] = tmp
+        pos[heap[i]] = i
+        pos[heap[j]] = j
+    }
+
+    companion object {
+        private const val INF = Int.Companion.MAX_VALUE
+    }
+}

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

@@ -0,0 +1,69 @@
+3604\. Minimum Time to Reach Destination in Directed Graph
+
+Medium
+
+You are given an integer `n` and a **directed** graph 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>, start<sub>i</sub>, end<sub>i</sub>]</code> indicates an edge from node <code>u<sub>i</sub></code> to <code>v<sub>i</sub></code> that can **only** be used at any integer time `t` such that <code>start<sub>i</sub> <= t <= end<sub>i</sub></code>.
+
+You start at node 0 at time 0.
+
+In one unit of time, you can either:
+
+*   Wait at your current node without moving, or
+*   Travel along an outgoing edge from your current node if the current time `t` satisfies <code>start<sub>i</sub> <= t <= end<sub>i</sub></code>.
+
+Return the **minimum** time required to reach node `n - 1`. If it is impossible, return `-1`.
+
+**Example 1:**
+
+**Input:** n = 3, edges = [[0,1,0,1],[1,2,2,5]]
+
+**Output:** 3
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/06/05/screenshot-2025-06-06-at-004535.png)
+
+The optimal path is:
+
+*   At time `t = 0`, take the edge `(0 → 1)` which is available from 0 to 1. You arrive at node 1 at time `t = 1`, then wait until `t = 2`.
+*   At time ```t = `2` ```, take the edge `(1 → 2)` which is available from 2 to 5. You arrive at node 2 at time 3.
+
+Hence, the minimum time to reach node 2 is 3.
+
+**Example 2:**
+
+**Input:** n = 4, edges = [[0,1,0,3],[1,3,7,8],[0,2,1,5],[2,3,4,7]]
+
+**Output:** 5
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/06/05/screenshot-2025-06-06-at-004757.png)
+
+The optimal path is:
+
+*   Wait at node 0 until time `t = 1`, then take the edge `(0 → 2)` which is available from 1 to 5. You arrive at node 2 at `t = 2`.
+*   Wait at node 2 until time `t = 4`, then take the edge `(2 → 3)` which is available from 4 to 7. You arrive at node 3 at `t = 5`.
+
+Hence, the minimum time to reach node 3 is 5.
+
+**Example 3:**
+
+**Input:** n = 3, edges = [[1,0,1,3],[1,2,3,5]]
+
+**Output:** \-1
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/06/05/screenshot-2025-06-06-at-004914.png)
+
+*   Since there is no outgoing edge from node 0, it is impossible to reach node 2. Hence, the output is -1.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= edges.length <= 10<sup>5</sup></code>
+*   <code>edges[i] == [u<sub>i</sub>, v<sub>i</sub>, start<sub>i</sub>, end<sub>i</sub>]</code>
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> <= n - 1</code>
+*   <code>u<sub>i</sub> != v<sub>i</sub></code>
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>9</sup></code>