Improved task 3515

Author: javadev

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

@@ -1,7 +1,7 @@
 package g3501_3600.s3515_shortest_path_in_a_weighted_tree
 
 // #Hard #Array #Depth_First_Search #Tree #Segment_Tree #Binary_Indexed_Tree
-// #2025_04_13_Time_72_ms_(100.00%)_Space_188.48_MB_(100.00%)
+// #2025_04_14_Time_65_ms_(100.00%)_Space_179.96_MB_(100.00%)
 
 class Solution {
     private lateinit var `in`: IntArray

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

@@ -1,47 +1,74 @@
-3512\. Minimum Operations to Make Array Sum Divisible by K
+3515\. Shortest Path in a Weighted Tree
 
-Easy
+Hard
 
-You are given an integer array `nums` and an integer `k`. You can perform the following operation any number of times:
+You are given an integer `n` and an undirected, weighted tree rooted at node 1 with `n` nodes numbered from 1 to `n`. This is represented by a 2D array `edges` of length `n - 1`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code> indicates an undirected edge from node <code>u<sub>i</sub></code> to <code>v<sub>i</sub></code> with weight <code>w<sub>i</sub></code>.
 
-*   Select an index `i` and replace `nums[i]` with `nums[i] - 1`.
+You are also given a 2D integer array `queries` of length `q`, where each `queries[i]` is either:
 
-Return the **minimum** number of operations required to make the sum of the array divisible by `k`.
+*   `[1, u, v, w']` – **Update** the weight of the edge between nodes `u` and `v` to `w'`, where `(u, v)` is guaranteed to be an edge present in `edges`.
+*   `[2, x]` – **Compute** the **shortest** path distance from the root node 1 to node `x`.
+
+Return an integer array `answer`, where `answer[i]` is the **shortest** path distance from node 1 to `x` for the <code>i<sup>th</sup></code> query of `[2, x]`.
 
 **Example 1:**
 
-**Input:** nums = [3,9,7], k = 5
+**Input:** n = 2, edges = [[1,2,7]], queries = [[2,2],[1,1,2,4],[2,2]]
 
-**Output:** 4
+**Output:** [7,4]
 
 **Explanation:**
 
-*   Perform 4 operations on `nums[1] = 9`. Now, `nums = [3, 5, 7]`.
-*   The sum is 15, which is divisible by 5.
+![](https://assets.leetcode.com/uploads/2025/03/13/screenshot-2025-03-13-at-133524.png)
+
+*   Query `[2,2]`: The shortest path from root node 1 to node 2 is 7.
+*   Query `[1,1,2,4]`: The weight of edge `(1,2)` changes from 7 to 4.
+*   Query `[2,2]`: The shortest path from root node 1 to node 2 is 4.
 
 **Example 2:**
 
-**Input:** nums = [4,1,3], k = 4
+**Input:** n = 3, edges = [[1,2,2],[1,3,4]], queries = [[2,1],[2,3],[1,1,3,7],[2,2],[2,3]]
 
-**Output:** 0
+**Output:** [0,4,2,7]
 
 **Explanation:**
 
-*   The sum is 8, which is already divisible by 4. Hence, no operations are needed.
+![](https://assets.leetcode.com/uploads/2025/03/13/screenshot-2025-03-13-at-132247.png)
+
+*   Query `[2,1]`: The shortest path from root node 1 to node 1 is 0.
+*   Query `[2,3]`: The shortest path from root node 1 to node 3 is 4.
+*   Query `[1,1,3,7]`: The weight of edge `(1,3)` changes from 4 to 7.
+*   Query `[2,2]`: The shortest path from root node 1 to node 2 is 2.
+*   Query `[2,3]`: The shortest path from root node 1 to node 3 is 7.
 
 **Example 3:**
 
-**Input:** nums = [3,2], k = 6
+**Input:** n = 4, edges = [[1,2,2],[2,3,1],[3,4,5]], queries = [[2,4],[2,3],[1,2,3,3],[2,2],[2,3]]
 
-**Output:** 5
+**Output:** [8,3,2,5]
 
 **Explanation:**
 
-*   Perform 3 operations on `nums[0] = 3` and 2 operations on `nums[1] = 2`. Now, `nums = [0, 0]`.
-*   The sum is 0, which is divisible by 6.
+![](https://assets.leetcode.com/uploads/2025/03/13/screenshot-2025-03-13-at-133306.png)
+
+*   Query `[2,4]`: The shortest path from root node 1 to node 4 consists of edges `(1,2)`, `(2,3)`, and `(3,4)` with weights `2 + 1 + 5 = 8`.
+*   Query `[2,3]`: The shortest path from root node 1 to node 3 consists of edges `(1,2)` and `(2,3)` with weights `2 + 1 = 3`.
+*   Query `[1,2,3,3]`: The weight of edge `(2,3)` changes from 1 to 3.
+*   Query `[2,2]`: The shortest path from root node 1 to node 2 is 2.
+*   Query `[2,3]`: The shortest path from root node 1 to node 3 consists of edges `(1,2)` and `(2,3)` with updated weights `2 + 3 = 5`.
 
 **Constraints:**
 
-*   `1 <= nums.length <= 1000`
-*   `1 <= nums[i] <= 1000`
-*   `1 <= k <= 100`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `edges.length == n - 1`
+*   <code>edges[i] == [u<sub>i</sub>, v<sub>i</sub>, w<sub>i</sub>]</code>
+*   <code>1 <= u<sub>i</sub>, v<sub>i</sub> <= n</code>
+*   <code>1 <= w<sub>i</sub> <= 10<sup>4</sup></code>
+*   The input is generated such that `edges` represents a valid tree.
+*   <code>1 <= queries.length == q <= 10<sup>5</sup></code>
+*   `queries[i].length == 2` or `4`
+    *   `queries[i] == [1, u, v, w']` or,
+    *   `queries[i] == [2, x]`
+    *   `1 <= u, v, x <= n`
+    *   `(u, v)` is always an edge from `edges`.
+    *   <code>1 <= w' <= 10<sup>4</sup></code>