Added tasks 2064-2076

Author: ThanhNIT

src/main/kotlin/g2001_2100/s2064_minimized_maximum_of_products_distributed_to_any_store/Solution.kt

@@ -0,0 +1,40 @@
+package g2001_2100.s2064_minimized_maximum_of_products_distributed_to_any_store
+
+// #Medium #Array #Binary_Search #2023_06_26_Time_609_ms_(100.00%)_Space_63.6_MB_(100.00%)
+
+class Solution {
+    fun minimizedMaximum(n: Int, q: IntArray): Int {
+        var min = 1
+        var max = maxi(q)
+        var ans = 0
+        while (min <= max) {
+            val mid = min + (max - min) / 2
+            if (condition(q, mid, n)) {
+                ans = mid
+                max = mid - 1
+            } else {
+                min = mid + 1
+            }
+        }
+        return ans
+    }
+
+    private fun condition(arr: IntArray, mid: Int, n: Int): Boolean {
+        var ans = 0
+        for (num in arr) {
+            ans += num / mid
+            if (num % mid != 0) {
+                ans++
+            }
+        }
+        return ans <= n
+    }
+
+    private fun maxi(arr: IntArray): Int {
+        var ans = 0
+        for (n in arr) {
+            ans = ans.coerceAtLeast(n)
+        }
+        return ans
+    }
+}

src/main/kotlin/g2001_2100/s2064_minimized_maximum_of_products_distributed_to_any_store/readme.md

@@ -0,0 +1,60 @@
+2064\. Minimized Maximum of Products Distributed to Any Store
+
+Medium
+
+You are given an integer `n` indicating there are `n` specialty retail stores. There are `m` product types of varying amounts, which are given as a **0-indexed** integer array `quantities`, where `quantities[i]` represents the number of products of the <code>i<sup>th</sup></code> product type.
+
+You need to distribute **all products** to the retail stores following these rules:
+
+*   A store can only be given **at most one product type** but can be given **any** amount of it.
+*   After distribution, each store will have been given some number of products (possibly `0`). Let `x` represent the maximum number of products given to any store. You want `x` to be as small as possible, i.e., you want to **minimize** the **maximum** number of products that are given to any store.
+
+Return _the minimum possible_ `x`.
+
+**Example 1:**
+
+**Input:** n = 6, quantities = [11,6]
+
+**Output:** 3
+
+**Explanation:** One optimal way is: 
+
+- The 11 products of type 0 are distributed to the first four stores in these amounts: 2, 3, 3, 3 
+
+- The 6 products of type 1 are distributed to the other two stores in these amounts: 3, 3 
+  
+The maximum number of products given to any store is max(2, 3, 3, 3, 3, 3) = 3.
+
+**Example 2:**
+
+**Input:** n = 7, quantities = [15,10,10]
+
+**Output:** 5
+
+**Explanation:** One optimal way is: 
+
+- The 15 products of type 0 are distributed to the first three stores in these amounts: 5, 5, 5 
+
+- The 10 products of type 1 are distributed to the next two stores in these amounts: 5, 5 
+
+- The 10 products of type 2 are distributed to the last two stores in these amounts: 5, 5 
+  
+The maximum number of products given to any store is max(5, 5, 5, 5, 5, 5, 5) = 5.
+
+**Example 3:**
+
+**Input:** n = 1, quantities = [100000]
+
+**Output:** 100000
+
+**Explanation:** The only optimal way is: 
+
+- The 100000 products of type 0 are distributed to the only store.
+  
+The maximum number of products given to any store is max(100000) = 100000.
+
+**Constraints:**
+
+*   `m == quantities.length`
+*   <code>1 <= m <= n <= 10<sup>5</sup></code>
+*   <code>1 <= quantities[i] <= 10<sup>5</sup></code>

src/main/kotlin/g2001_2100/s2065_maximum_path_quality_of_a_graph/Solution.kt

@@ -0,0 +1,66 @@
+package g2001_2100.s2065_maximum_path_quality_of_a_graph
+
+// #Hard #Array #Graph #Backtracking #2023_06_26_Time_429_ms_(100.00%)_Space_46.7_MB_(100.00%)
+
+class Solution {
+    private var maxQuality = 0
+
+    internal class Node(var i: Int, var time: Int)
+
+    fun maximalPathQuality(values: IntArray, edges: Array<IntArray>, maxTime: Int): Int {
+        val graph: MutableList<MutableList<Node>> = ArrayList()
+        for (i in values.indices) {
+            graph.add(ArrayList())
+        }
+        for (edge in edges) {
+            val u = edge[0]
+            val v = edge[1]
+            val time = edge[2]
+            val node1 = Node(u, time)
+            val node2 = Node(v, time)
+            graph[u].add(node2)
+            graph[v].add(node1)
+        }
+        maxQuality = 0
+        dfs(graph, 0, 0, maxTime, values[0], values)
+        return maxQuality
+    }
+
+    private fun dfs(
+        graph: List<MutableList<Node>>,
+        start: Int,
+        curTime: Int,
+        maxTime: Int,
+        curValue: Int,
+        values: IntArray
+    ) {
+        if (curTime > maxTime) {
+            return
+        }
+        if (curTime == maxTime && start != 0) {
+            return
+        }
+        if (start == 0) {
+            maxQuality = maxQuality.coerceAtLeast(curValue)
+        }
+        val tmp = values[start]
+        if (tmp != 0) {
+            values[start] = 0
+        }
+        for (node in graph[start]) {
+            val v = node.i
+            val time = node.time
+            val value = values[v]
+            if (value != 0) {
+                values[v] = 0
+            }
+            dfs(graph, v, curTime + time, maxTime, curValue + value, values)
+            if (value != 0) {
+                values[v] = value
+            }
+        }
+        if (tmp != 0) {
+            values[start] = tmp
+        }
+    }
+}

src/main/kotlin/g2001_2100/s2065_maximum_path_quality_of_a_graph/readme.md

@@ -0,0 +1,72 @@
+2065\. Maximum Path Quality of a Graph
+
+Hard
+
+There is an **undirected** graph with `n` nodes numbered from `0` to `n - 1` (**inclusive**). You are given a **0-indexed** integer array `values` where `values[i]` is the **value** of the <code>i<sup>th</sup></code> node. You are also given a **0-indexed** 2D integer array `edges`, where each <code>edges[j] = [u<sub>j</sub>, v<sub>j</sub>, time<sub>j</sub>]</code> indicates that there is an undirected edge between the nodes <code>u<sub>j</sub></code> and <code>v<sub>j</sub></code>, and it takes <code>time<sub>j</sub></code> seconds to travel between the two nodes. Finally, you are given an integer `maxTime`.
+
+A **valid** **path** in the graph is any path that starts at node `0`, ends at node `0`, and takes **at most** `maxTime` seconds to complete. You may visit the same node multiple times. The **quality** of a valid path is the **sum** of the values of the **unique nodes** visited in the path (each node's value is added **at most once** to the sum).
+
+Return _the **maximum** quality of a valid path_.
+
+**Note:** There are **at most four** edges connected to each node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/10/19/ex1drawio.png)
+
+**Input:** values = [0,32,10,43], edges = [[0,1,10],[1,2,15],[0,3,10]], maxTime = 49
+
+**Output:** 75
+
+**Explanation:** 
+
+One possible path is 0 -> 1 -> 0 -> 3 -> 0.
+
+The total time taken is 10 + 10 + 10 + 10 = 40 <= 49. 
+
+The nodes visited are 0, 1, and 3, giving a maximal path quality of 0 + 32 + 43 = 75.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/10/19/ex2drawio.png)
+
+**Input:** values = [5,10,15,20], edges = [[0,1,10],[1,2,10],[0,3,10]], maxTime = 30
+
+**Output:** 25
+
+**Explanation:**
+
+One possible path is 0 -> 3 -> 0. 
+
+The total time taken is 10 + 10 = 20 <= 30.
+
+The nodes visited are 0 and 3, giving a maximal path quality of 5 + 20 = 25.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/10/19/ex31drawio.png)
+
+**Input:** values = [1,2,3,4], edges = [[0,1,10],[1,2,11],[2,3,12],[1,3,13]], maxTime = 50
+
+**Output:** 7
+
+**Explanation:** 
+
+One possible path is 0 -> 1 -> 3 -> 1 -> 0. 
+
+The total time taken is 10 + 13 + 13 + 10 = 46 <= 50. 
+
+The nodes visited are 0, 1, and 3, giving a maximal path quality of 1 + 2 + 4 = 7.
+
+**Constraints:**
+
+*   `n == values.length`
+*   `1 <= n <= 1000`
+*   <code>0 <= values[i] <= 10<sup>8</sup></code>
+*   `0 <= edges.length <= 2000`
+*   `edges[j].length == 3`
+*   <code>0 <= u<sub>j</sub> < v<sub>j</sub> <= n - 1</code>
+*   <code>10 <= time<sub>j</sub>, maxTime <= 100</code>
+*   All the pairs <code>[u<sub>j</sub>, v<sub>j</sub>]</code> are **unique**.
+*   There are **at most four** edges connected to each node.
+*   The graph may not be connected.

src/main/kotlin/g2001_2100/s2068_check_whether_two_strings_are_almost_equivalent/Solution.kt

@@ -0,0 +1,21 @@
+package g2001_2100.s2068_check_whether_two_strings_are_almost_equivalent
+
+// #Easy #String #Hash_Table #Counting #2023_06_26_Time_131_ms_(100.00%)_Space_34.1_MB_(100.00%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun checkAlmostEquivalent(word1: String, word2: String): Boolean {
+        val freq = IntArray(26)
+        for (i in word1.indices) {
+            ++freq[word1[i].code - 'a'.code]
+            --freq[word2[i].code - 'a'.code]
+        }
+        for (i in freq) {
+            if (abs(i) > 3) {
+                return false
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g2001_2100/s2068_check_whether_two_strings_are_almost_equivalent/readme.md

@@ -0,0 +1,61 @@
+2068\. Check Whether Two Strings are Almost Equivalent
+
+Easy
+
+Two strings `word1` and `word2` are considered **almost equivalent** if the differences between the frequencies of each letter from `'a'` to `'z'` between `word1` and `word2` is **at most** `3`.
+
+Given two strings `word1` and `word2`, each of length `n`, return `true` _if_ `word1` _and_ `word2` _are **almost equivalent**, or_ `false` _otherwise_.
+
+The **frequency** of a letter `x` is the number of times it occurs in the string.
+
+**Example 1:**
+
+**Input:** word1 = "aaaa", word2 = "bccb"
+
+**Output:** false
+
+**Explanation:** There are 4 'a's in "aaaa" but 0 'a's in "bccb". 
+
+The difference is 4, which is more than the allowed 3. 
+
+**Example 2:**
+
+**Input:** word1 = "abcdeef", word2 = "abaaacc"
+
+**Output:** true
+
+**Explanation:** The differences between the frequencies of each letter in word1 and word2 are at most 3:
+ 
+- 'a' appears 1 time in word1 and 4 times in word2. The difference is 3.
+
+- 'b' appears 1 time in word1 and 1 time in word2. The difference is 0.
+
+- 'c' appears 1 time in word1 and 2 times in word2. The difference is 1.
+
+- 'd' appears 1 time in word1 and 0 times in word2. The difference is 1.
+
+- 'e' appears 2 times in word1 and 0 times in word2. The difference is 2.
+
+- 'f' appears 1 time in word1 and 0 times in word2. The difference is 1. 
+
+**Example 3:**
+
+**Input:** word1 = "cccddabba", word2 = "babababab"
+
+**Output:** true
+
+**Explanation:** The differences between the frequencies of each letter in word1 and word2 are at most 3:
+
+- 'a' appears 2 times in word1 and 4 times in word2. The difference is 2.
+
+- 'b' appears 2 times in word1 and 5 times in word2. The difference is 3.
+
+- 'c' appears 3 times in word1 and 0 times in word2. The difference is 3.
+
+- 'd' appears 2 times in word1 and 0 times in word2. The difference is 2. 
+
+**Constraints:**
+
+*   `n == word1.length == word2.length`
+*   `1 <= n <= 100`
+*   `word1` and `word2` consist only of lowercase English letters.

src/main/kotlin/g2001_2100/s2069_walking_robot_simulation_ii/Robot.kt

@@ -0,0 +1,57 @@
+package g2001_2100.s2069_walking_robot_simulation_ii
+
+// #Medium #Design #Simulation #2023_06_26_Time_636_ms_(100.00%)_Space_66.2_MB_(100.00%)
+
+class Robot(width: Int, height: Int) {
+    private var p: Int
+    private val w: Int
+    private val h: Int
+
+    init {
+        w = width - 1
+        h = height - 1
+        p = 0
+    }
+
+    fun step(num: Int) {
+        p += num
+    }
+
+    fun getPos(): IntArray {
+        var remain = p % (2 * (w + h))
+        if (remain <= w) {
+            return intArrayOf(remain, 0)
+        }
+        remain -= w
+        if (remain <= h) {
+            return intArrayOf(w, remain)
+        }
+        remain -= h
+        if (remain <= w) {
+            return intArrayOf(w - remain, h)
+        }
+        remain -= w
+        return intArrayOf(0, h - remain)
+    }
+
+    fun getDir(): String {
+        val pos = getPos()
+        return if (p == 0 || pos[1] == 0 && pos[0] > 0) {
+            "East"
+        } else if (pos[0] == w && pos[1] > 0) {
+            "North"
+        } else if (pos[1] == h && pos[0] < w) {
+            "West"
+        } else {
+            "South"
+        }
+    }
+}
+
+/*
+ * Your Robot object will be instantiated and called as such:
+ * var obj = Robot(width, height)
+ * obj.step(num)
+ * var param_2 = obj.getPos()
+ * var param_3 = obj.getDir()
+ */