Added tasks 3483-3490

Author: javadev

Diff for: src/main/kotlin/g3401_3500/s3483_unique_3_digit_even_numbers/Solution.kt

@@ -0,0 +1,31 @@
+package g3401_3500.s3483_unique_3_digit_even_numbers
+
+// #Easy #Array #Hash_Table #Recursion #Enumeration
+// #2025_03_16_Time_6_ms_(100.00%)_Space_44.99_MB_(100.00%)
+
+class Solution {
+    fun totalNumbers(digits: IntArray): Int {
+        val set = HashSet<Int>()
+        val n = digits.size
+        for (i in 0..<n) {
+            if (digits[i] == 0) {
+                continue
+            }
+            for (j in 0..<n) {
+                if (j == i) {
+                    continue
+                }
+                for (k in 0..<n) {
+                    if (k == i || k == j) {
+                        continue
+                    }
+                    if (digits[k] % 2 == 0) {
+                        val number = digits[i] * 100 + digits[j] * 10 + digits[k]
+                        set.add(number)
+                    }
+                }
+            }
+        }
+        return set.size
+    }
+}

Diff for: src/main/kotlin/g3401_3500/s3483_unique_3_digit_even_numbers/readme.md

@@ -0,0 +1,44 @@
+3483\. Unique 3-Digit Even Numbers
+
+Easy
+
+You are given an array of digits called `digits`. Your task is to determine the number of **distinct** three-digit even numbers that can be formed using these digits.
+
+**Note**: Each _copy_ of a digit can only be used **once per number**, and there may **not** be leading zeros.
+
+**Example 1:**
+
+**Input:** digits = [1,2,3,4]
+
+**Output:** 12
+
+**Explanation:** The 12 distinct 3-digit even numbers that can be formed are 124, 132, 134, 142, 214, 234, 312, 314, 324, 342, 412, and 432. Note that 222 cannot be formed because there is only 1 copy of the digit 2.
+
+**Example 2:**
+
+**Input:** digits = [0,2,2]
+
+**Output:** 2
+
+**Explanation:** The only 3-digit even numbers that can be formed are 202 and 220. Note that the digit 2 can be used twice because it appears twice in the array.
+
+**Example 3:**
+
+**Input:** digits = [6,6,6]
+
+**Output:** 1
+
+**Explanation:** Only 666 can be formed.
+
+**Example 4:**
+
+**Input:** digits = [1,3,5]
+
+**Output:** 0
+
+**Explanation:** No even 3-digit numbers can be formed.
+
+**Constraints:**
+
+*   `3 <= digits.length <= 10`
+*   `0 <= digits[i] <= 9`

Diff for: src/main/kotlin/g3401_3500/s3484_design_spreadsheet/Spreadsheet.kt

@@ -0,0 +1,44 @@
+package g3401_3500.s3484_design_spreadsheet
+
+// #Medium #Array #String #Hash_Table #Matrix #Design
+// #2025_03_16_Time_176_ms_(100.00%)_Space_79.62_MB_(100.00%)
+
+@Suppress("unused")
+class Spreadsheet(rows: Int) {
+    private val data: MutableMap<String, Int> = HashMap<String, Int>()
+
+    fun setCell(cell: String, value: Int) {
+        data.put(cell, value)
+    }
+
+    fun resetCell(cell: String) {
+        data.put(cell, 0)
+    }
+
+    fun getValue(formula: String): Int {
+        val index = formula.indexOf('+')
+        val left = formula.substring(1, index)
+        val right = formula.substring(index + 1)
+        val x =
+            if (Character.isLetter(left[0])) {
+                data.getOrDefault(left, 0)
+            } else {
+                left.toInt()
+            }
+        val y =
+            if (Character.isLetter(right[0])) {
+                data.getOrDefault(right, 0)
+            } else {
+                right.toInt()
+            }
+        return x + y
+    }
+}
+
+/*
+ * Your Spreadsheet object will be instantiated and called as such:
+ * var obj = Spreadsheet(rows)
+ * obj.setCell(cell,value)
+ * obj.resetCell(cell)
+ * var param_3 = obj.getValue(formula)
+ */

Diff for: src/main/kotlin/g3401_3500/s3484_design_spreadsheet/readme.md

@@ -0,0 +1,44 @@
+3484\. Design Spreadsheet
+
+Medium
+
+A spreadsheet is a grid with 26 columns (labeled from `'A'` to `'Z'`) and a given number of `rows`. Each cell in the spreadsheet can hold an integer value between 0 and 10<sup>5</sup>.
+
+Implement the `Spreadsheet` class:
+
+*   `Spreadsheet(int rows)` Initializes a spreadsheet with 26 columns (labeled `'A'` to `'Z'`) and the specified number of rows. All cells are initially set to 0.
+*   `void setCell(String cell, int value)` Sets the value of the specified `cell`. The cell reference is provided in the format `"AX"` (e.g., `"A1"`, `"B10"`), where the letter represents the column (from `'A'` to `'Z'`) and the number represents a **1-indexed** row.
+*   `void resetCell(String cell)` Resets the specified cell to 0.
+*   `int getValue(String formula)` Evaluates a formula of the form `"=X+Y"`, where `X` and `Y` are **either** cell references or non-negative integers, and returns the computed sum.
+
+**Note:** If `getValue` references a cell that has not been explicitly set using `setCell`, its value is considered 0.
+
+**Example 1:**
+
+**Input:**
+    ["Spreadsheet", "getValue", "setCell", "getValue", "setCell", "getValue", "resetCell", "getValue"]
+    [[3], ["=5+7"], ["A1", 10], ["=A1+6"], ["B2", 15], ["=A1+B2"], ["A1"], ["=A1+B2"]]
+
+**Output:**
+    [null, 12, null, 16, null, 25, null, 15]
+
+**Explanation**
+
+```java
+Spreadsheet spreadsheet = new Spreadsheet(3); // Initializes a spreadsheet with 3 rows and 26 columns
+spreadsheet.getValue("=5+7"); // returns 12 (5+7)
+spreadsheet.setCell("A1", 10); // sets A1 to 10
+spreadsheet.getValue("=A1+6"); // returns 16 (10+6)
+spreadsheet.setCell("B2", 15); // sets B2 to 15
+spreadsheet.getValue("=A1+B2"); // returns 25 (10+15)
+spreadsheet.resetCell("A1"); // resets A1 to 0
+spreadsheet.getValue("=A1+B2"); // returns 15 (0+15)
+```
+
+**Constraints:**
+
+*   <code>1 <= rows <= 10<sup>3</sup></code>
+*   <code>0 <= value <= 10<sup>5</sup></code>
+*   The formula is always in the format `"=X+Y"`, where `X` and `Y` are either valid cell references or **non-negative** integers with values less than or equal to <code>10<sup>5</sup></code>.
+*   Each cell reference consists of a capital letter from `'A'` to `'Z'` followed by a row number between `1` and `rows`.
+*   At most <code>10<sup>4</sup></code> calls will be made in **total** to `setCell`, `resetCell`, and `getValue`.

Diff for: src/main/kotlin/g3401_3500/s3485_longest_common_prefix_of_k_strings_after_removal/Solution.kt

@@ -0,0 +1,69 @@
+package g3401_3500.s3485_longest_common_prefix_of_k_strings_after_removal
+
+// #Hard #Array #String #Trie #2025_03_16_Time_251_ms_(100.00%)_Space_86.10_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    private class TrieNode {
+        var children: Array<TrieNode?> = arrayOfNulls<TrieNode>(26)
+        var count: Int = 0
+        var bestPrefixLength: Int = -1
+    }
+
+    private var root: TrieNode? = null
+
+    fun longestCommonPrefix(words: Array<String>, k: Int): IntArray {
+        val totalWords = words.size
+        val result = IntArray(totalWords)
+        if (totalWords - 1 < k) {
+            return result
+        }
+        root = TrieNode()
+        for (word in words) {
+            // insert the word with increasing the count by 1 (prefix count)
+            updateTrie(word, 1, k)
+        }
+        for (i in 0..<totalWords) {
+            // temp deletion of the word with count decreased by 1
+            updateTrie(words[i], -1, k)
+            result[i] = root!!.bestPrefixLength
+            // re-insertion of the word
+            updateTrie(words[i], 1, k)
+        }
+        return result
+    }
+
+    private fun updateTrie(word: String, count: Int, k: Int) {
+        val wordLength = word.length
+        // used to store the path used during trie travesal to update the count and use the count
+        val nodePath: Array<TrieNode> = Array<TrieNode>(wordLength + 1) { TrieNode() }
+        val depths = IntArray(wordLength + 1)
+        nodePath[0] = root!!
+        depths[0] = 0
+        // trie insertion
+        for (i in 0..<wordLength) {
+            val letterIndex = word[i].code - 'a'.code
+            if (nodePath[i].children[letterIndex] == null) {
+                nodePath[i].children[letterIndex] = TrieNode()
+            }
+            nodePath[i + 1] = nodePath[i].children[letterIndex]!!
+            depths[i + 1] = depths[i] + 1
+        }
+        // increase the count of each prefix
+        for (node in nodePath) {
+            node.count += count
+        }
+        // find the best prefix
+        for (i in nodePath.indices.reversed()) {
+            val currentNode = nodePath[i]
+            var candidate = (if (currentNode.count >= k) depths[i] else -1)
+            for (childNode in currentNode.children) {
+                if (childNode != null) {
+                    candidate = max(candidate, childNode.bestPrefixLength)
+                }
+            }
+            currentNode.bestPrefixLength = candidate
+        }
+    }
+}

Diff for: src/main/kotlin/g3401_3500/s3485_longest_common_prefix_of_k_strings_after_removal/readme.md

@@ -0,0 +1,45 @@
+3485\. Longest Common Prefix of K Strings After Removal
+
+Hard
+
+You are given an array of strings `words` and an integer `k`.
+
+For each index `i` in the range `[0, words.length - 1]`, find the **length** of the **longest common prefix** among any `k` strings (selected at **distinct indices**) from the remaining array after removing the <code>i<sup>th</sup></code> element.
+
+Return an array `answer`, where `answer[i]` is the answer for <code>i<sup>th</sup></code> element. If removing the <code>i<sup>th</sup></code> element leaves the array with fewer than `k` strings, `answer[i]` is 0.
+
+**Example 1:**
+
+**Input:** words = ["jump","run","run","jump","run"], k = 2
+
+**Output:** [3,4,4,3,4]
+
+**Explanation:**
+
+*   Removing index 0 (`"jump"`):
+    *   `words` becomes: `["run", "run", "jump", "run"]`. `"run"` occurs 3 times. Choosing any two gives the longest common prefix `"run"` (length 3).
+*   Removing index 1 (`"run"`):
+    *   `words` becomes: `["jump", "run", "jump", "run"]`. `"jump"` occurs twice. Choosing these two gives the longest common prefix `"jump"` (length 4).
+*   Removing index 2 (`"run"`):
+    *   `words` becomes: `["jump", "run", "jump", "run"]`. `"jump"` occurs twice. Choosing these two gives the longest common prefix `"jump"` (length 4).
+*   Removing index 3 (`"jump"`):
+    *   `words` becomes: `["jump", "run", "run", "run"]`. `"run"` occurs 3 times. Choosing any two gives the longest common prefix `"run"` (length 3).
+*   Removing index 4 ("run"):
+    *   `words` becomes: `["jump", "run", "run", "jump"]`. `"jump"` occurs twice. Choosing these two gives the longest common prefix `"jump"` (length 4).
+
+**Example 2:**
+
+**Input:** words = ["dog","racer","car"], k = 2
+
+**Output:** [0,0,0]
+
+**Explanation:**
+
+*   Removing any index results in an answer of 0.
+
+**Constraints:**
+
+*   <code>1 <= k <= words.length <= 10<sup>5</sup></code>
+*   <code>1 <= words[i].length <= 10<sup>4</sup></code>
+*   `words[i]` consists of lowercase English letters.
+*   The sum of `words[i].length` is smaller than or equal <code>10<sup>5</sup></code>.

Diff for: src/main/kotlin/g3401_3500/s3486_longest_special_path_ii/Solution.kt

@@ -0,0 +1,65 @@
+package g3401_3500.s3486_longest_special_path_ii
+
+// #Hard #Array #Hash_Table #Depth_First_Search #Tree #Prefix_Sum
+// #2025_03_16_Time_255_ms_(100.00%)_Space_125.42_MB_(100.00%)
+
+@Suppress("kotlin:S107")
+class Solution {
+    fun longestSpecialPath(edges: Array<IntArray>, nums: IntArray): IntArray {
+        val ans = intArrayOf(0, 1)
+        val graph: MutableMap<Int, MutableList<IntArray>> = HashMap<Int, MutableList<IntArray>>()
+        for (edge in edges) {
+            val a = edge[0]
+            val b = edge[1]
+            val c = edge[2]
+            graph.computeIfAbsent(a) { _: Int -> ArrayList<IntArray>() }
+                .add(intArrayOf(b, c))
+            graph.computeIfAbsent(b) { _: Int -> ArrayList<IntArray>() }
+                .add(intArrayOf(a, c))
+        }
+        val costs: MutableList<Int> = ArrayList<Int>()
+        val last: MutableMap<Int, Int> = HashMap<Int, Int>()
+        dfs(0, 0, -1, ArrayList<Int>(mutableListOf<Int>(0, 0)), nums, graph, costs, last, ans)
+        return ans
+    }
+
+    private fun dfs(
+        node: Int,
+        currCost: Int,
+        prev: Int,
+        left: MutableList<Int>,
+        nums: IntArray,
+        graph: MutableMap<Int, MutableList<IntArray>>,
+        costs: MutableList<Int>,
+        last: MutableMap<Int, Int>,
+        ans: IntArray,
+    ) {
+        val nodeColorIndexPrev: Int = last.getOrDefault(nums[node], -1)
+        last.put(nums[node], costs.size)
+        costs.add(currCost)
+        val diff = currCost - costs[left[0]]
+        val length = costs.size - left[0]
+        if (diff > ans[0] || (diff == ans[0] && length < ans[1])) {
+            ans[0] = diff
+            ans[1] = length
+        }
+        for (next in graph.getOrDefault(node, ArrayList<IntArray>())) {
+            val nextNode = next[0]
+            val nextCost = next[1]
+            if (nextNode == prev) {
+                continue
+            }
+            val nextLeft: MutableList<Int> = ArrayList<Int>(left)
+            if (last.containsKey(nums[nextNode])) {
+                nextLeft.add(last[nums[nextNode]]!! + 1)
+            }
+            nextLeft.sortWith(Comparator.naturalOrder<Int?>())
+            while (nextLeft.size > 2) {
+                nextLeft.removeAt(0)
+            }
+            dfs(nextNode, currCost + nextCost, node, nextLeft, nums, graph, costs, last, ans)
+        }
+        last.put(nums[node], nodeColorIndexPrev)
+        costs.removeAt(costs.size - 1)
+    }
+}

Diff for: src/main/kotlin/g3401_3500/s3486_longest_special_path_ii/readme.md

@@ -0,0 +1,46 @@
+3486\. Longest Special Path II
+
+Hard
+
+You are given an undirected tree rooted at node `0`, with `n` nodes numbered from `0` to `n - 1`. This is represented by a 2D array `edges` of length `n - 1`, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> indicates an edge between nodes <code>u<sub>i</sub></code> and <code>v<sub>i</sub></code> with length <code>length<sub>i</sub></code>. You are also given an integer array `nums`, where `nums[i]` represents the value at node `i`.
+
+A **special path** is defined as a **downward** path from an ancestor node to a descendant node in which all node values are **distinct**, except for **at most** one value that may appear twice.
+
+Return an array `result` of size 2, where `result[0]` is the **length** of the **longest** special path, and `result[1]` is the **minimum** number of nodes in all _possible_ **longest** special paths.
+
+**Example 1:**
+
+**Input:** edges = [[0,1,1],[1,2,3],[1,3,1],[2,4,6],[4,7,2],[3,5,2],[3,6,5],[6,8,3]], nums = [1,1,0,3,1,2,1,1,0]
+
+**Output:** [9,3]
+
+**Explanation:**
+
+In the image below, nodes are colored by their corresponding values in `nums`.
+
+![](https://assets.leetcode.com/uploads/2025/02/18/e1.png)
+
+The longest special paths are `1 -> 2 -> 4` and `1 -> 3 -> 6 -> 8`, both having a length of 9. The minimum number of nodes across all longest special paths is 3.
+
+**Example 2:**
+
+**Input:** edges = [[1,0,3],[0,2,4],[0,3,5]], nums = [1,1,0,2]
+
+**Output:** [5,2]
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2025/02/18/e2.png)
+
+The longest path is `0 -> 3` consisting of 2 nodes with a length of 5.
+
+**Constraints:**
+
+*   <code>2 <= n <= 5 * 10<sup>4</sup></code>
+*   `edges.length == n - 1`
+*   `edges[i].length == 3`
+*   <code>0 <= u<sub>i</sub>, v<sub>i</sub> < n</code>
+*   <code>1 <= length<sub>i</sub> <= 10<sup>3</sup></code>
+*   `nums.length == n`
+*   <code>0 <= nums[i] <= 5 * 10<sup>4</sup></code>
+*   The input is generated such that `edges` represents a valid tree.