Added tasks 2661-2666

Author: ThanhNIT

src/main/kotlin/g2601_2700/s2661_first_completely_painted_row_or_column/Solution.kt

@@ -0,0 +1,28 @@
+package g2601_2700.s2661_first_completely_painted_row_or_column
+
+// #Medium #Array #Hash_Table #Matrix #2023_07_25_Time_901_ms_(100.00%)_Space_73.6_MB_(83.33%)
+
+class Solution {
+    fun firstCompleteIndex(arr: IntArray, mat: Array<IntArray>): Int {
+        val map: HashMap<Int, Int> = HashMap()
+        var ans = mat.size * mat[0].size
+        for (i in arr.indices) {
+            map.put(arr[i], i)
+        }
+        for (i in mat.indices) {
+            var maxV = 0
+            for (j in mat[0].indices) {
+                maxV = maxV.coerceAtLeast(map[mat[i][j]]!!)
+            }
+            ans = ans.coerceAtMost(maxV)
+        }
+        for (i in mat[0].indices) {
+            var maxV = 0
+            for (j in mat.indices) {
+                maxV = maxV.coerceAtLeast(map[mat[j][i]]!!)
+            }
+            ans = ans.coerceAtMost(maxV)
+        }
+        return ans
+    }
+}

src/main/kotlin/g2601_2700/s2661_first_completely_painted_row_or_column/readme.md

@@ -0,0 +1,40 @@
+2661\. First Completely Painted Row or Column
+
+Medium
+
+You are given a **0-indexed** integer array `arr`, and an `m x n` integer **matrix** `mat`. `arr` and `mat` both contain **all** the integers in the range `[1, m * n]`.
+
+Go through each index `i` in `arr` starting from index `0` and paint the cell in `mat` containing the integer `arr[i]`.
+
+Return _the smallest index_ `i` _at which either a row or a column will be completely painted in_ `mat`.
+
+**Example 1:**
+
+![](image explanation for example 1)![image explanation for example 1](https://assets.leetcode.com/uploads/2023/01/18/grid1.jpg)
+
+**Input:** arr = [1,3,4,2], mat = [[1,4],[2,3]]
+
+**Output:** 2
+
+**Explanation:** The moves are shown in order, and both the first row and second column of the matrix become fully painted at arr[2].
+
+**Example 2:**
+
+![image explanation for example 2](https://assets.leetcode.com/uploads/2023/01/18/grid2.jpg)
+
+**Input:** arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
+
+**Output:** 3
+
+**Explanation:** The second column becomes fully painted at arr[3].
+
+**Constraints:**
+
+*   `m == mat.length`
+*   `n = mat[i].length`
+*   `arr.length == m * n`
+*   <code>1 <= m, n <= 10<sup>5</sup></code>
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `1 <= arr[i], mat[r][c] <= m * n`
+*   All the integers of `arr` are **unique**.
+*   All the integers of `mat` are **unique**.

src/main/kotlin/g2601_2700/s2662_minimum_cost_of_a_path_with_special_roads/Solution.kt

@@ -0,0 +1,62 @@
+package g2601_2700.s2662_minimum_cost_of_a_path_with_special_roads
+
+// #Medium #Array #Heap_Priority_Queue #Graph #Shortest_Path
+// #2023_07_25_Time_690_ms_(100.00%)_Space_59.5_MB_(50.00%)
+
+import java.util.PriorityQueue
+
+class Solution {
+    fun minimumCost(start: IntArray, target: IntArray, specialRoads: Array<IntArray>): Int {
+        val pointList = mutableListOf<Point>()
+        val costMap = HashMap<Pair<Point, Point>, Int>()
+        val distMap = HashMap<Point, Int>()
+        val sp = Point(start[0], start[1])
+        distMap[sp] = 0
+        for (road in specialRoads) {
+            val p = Point(road[0], road[1])
+            val q = Point(road[2], road[3])
+            val cost = road[4]
+            if (costMap.getOrDefault(Pair(p, q), Int.MAX_VALUE) > cost) {
+                costMap[Pair(p, q)] = cost
+            }
+            pointList.add(p)
+            pointList.add(q)
+            distMap[p] = Int.MAX_VALUE
+            distMap[q] = Int.MAX_VALUE
+        }
+        val tp = Point(target[0], target[1])
+        pointList.add(tp)
+        distMap[tp] = Int.MAX_VALUE
+        val points = pointList.distinct()
+        val pq = PriorityQueue<PointWithCost>()
+        pq.offer(PointWithCost(sp, 0))
+        while (pq.isNotEmpty()) {
+            val curr = pq.poll()
+            val cost = curr.cost
+            val cp = curr.p
+            if (cp == tp) return cost
+            for (np in points) {
+                if (cp == np) continue
+                var nextCost = cost + dist(cp, np)
+                if (costMap.containsKey(Pair(cp, np))) {
+                    nextCost = nextCost.coerceAtMost(cost + costMap[Pair(cp, np)]!!)
+                }
+                if (nextCost < distMap[np]!!) {
+                    distMap[np] = nextCost
+                    pq.offer(PointWithCost(np, nextCost))
+                }
+            }
+        }
+        return -1
+    }
+
+    fun dist(sp: Point, tp: Point): Int {
+        return kotlin.math.abs(sp.x - tp.x) + kotlin.math.abs(sp.y - tp.y)
+    }
+}
+
+data class Point(val x: Int, val y: Int)
+
+data class PointWithCost(val p: Point, val cost: Int) : Comparable<PointWithCost> {
+    override fun compareTo(other: PointWithCost) = compareValuesBy(this, other) { it.cost }
+}

src/main/kotlin/g2601_2700/s2662_minimum_cost_of_a_path_with_special_roads/readme.md

@@ -0,0 +1,46 @@
+2662\. Minimum Cost of a Path With Special Roads
+
+Medium
+
+You are given an array `start` where `start = [startX, startY]` represents your initial position `(startX, startY)` in a 2D space. You are also given the array `target` where `target = [targetX, targetY]` represents your target position `(targetX, targetY)`.
+
+The cost of going from a position `(x1, y1)` to any other position in the space `(x2, y2)` is `|x2 - x1| + |y2 - y1|`.
+
+There are also some special roads. You are given a 2D array `specialRoads` where <code>specialRoads[i] = [x1<sub>i</sub>, y1<sub>i</sub>, x2<sub>i</sub>, y2<sub>i</sub>, cost<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> special road can take you from <code>(x1<sub>i</sub>, y1<sub>i</sub>)</code> to <code>(x2<sub>i</sub>, y2<sub>i</sub>)</code> with a cost equal to <code>cost<sub>i</sub></code>. You can use each special road any number of times.
+
+Return _the minimum cost required to go from_ `(startX, startY)` to `(targetX, targetY)`.
+
+**Example 1:**
+
+**Input:** start = [1,1], target = [4,5], specialRoads = [[1,2,3,3,2],[3,4,4,5,1]]
+
+**Output:** 5
+
+**Explanation:** The optimal path from (1,1) to (4,5) is the following: 
+- (1,1) -> (1,2). This move has a cost of |1 - 1| + |2 - 1| = 1. 
+- (1,2) -> (3,3). This move uses the first special edge, the cost is 2. 
+- (3,3) -> (3,4). This move has a cost of |3 - 3| + |4 - 3| = 1. 
+- (3,4) -> (4,5). This move uses the second special edge, the cost is 1. 
+
+So the total cost is 1 + 2 + 1 + 1 = 5. 
+
+It can be shown that we cannot achieve a smaller total cost than 5.
+
+**Example 2:**
+
+**Input:** start = [3,2], target = [5,7], specialRoads = [[3,2,3,4,4],[3,3,5,5,5],[3,4,5,6,6]]
+
+**Output:** 7
+
+**Explanation:** It is optimal to not use any special edges and go directly from the starting to the ending position with a cost |5 - 3| + |7 - 2| = 7.
+
+**Constraints:**
+
+*   `start.length == target.length == 2`
+*   <code>1 <= startX <= targetX <= 10<sup>5</sup></code>
+*   <code>1 <= startY <= targetY <= 10<sup>5</sup></code>
+*   `1 <= specialRoads.length <= 200`
+*   `specialRoads[i].length == 5`
+*   <code>startX <= x1<sub>i</sub>, x2<sub>i</sub> <= targetX</code>
+*   <code>startY <= y1<sub>i</sub>, y2<sub>i</sub> <= targetY</code>
+*   <code>1 <= cost<sub>i</sub> <= 10<sup>5</sup></code>

src/main/kotlin/g2601_2700/s2663_lexicographically_smallest_beautiful_string/Solution.kt

@@ -0,0 +1,37 @@
+package g2601_2700.s2663_lexicographically_smallest_beautiful_string
+
+// #Hard #String #Greedy #2023_07_25_Time_324_ms_(100.00%)_Space_40.6_MB_(100.00%)
+
+class Solution {
+    fun smallestBeautifulString(s: String, k: Int): String {
+        val n = s.length
+        val charr = s.toCharArray()
+        for (i in n - 1 downTo 0) {
+            ++charr[i]
+            var canbuild = true
+            if (charr[i] > 'a' + k - 1) continue
+            while (!isValid(charr, i)) {
+                ++charr[i]
+                if (charr[i] > 'a' + k - 1) {
+                    canbuild = false
+                    break
+                }
+            }
+            if (!canbuild) continue
+            for (j in i + 1 until n) {
+                charr[j] = 'a'
+                while (!isValid(charr, j)) {
+                    ++charr[j]
+                }
+            }
+            return StringBuilder().append(charr).toString()
+        }
+        return ""
+    }
+
+    private fun isValid(s: CharArray, i: Int): Boolean {
+        if (i - 1 >= 0 && s[i - 1] == s[i]) return false
+        if (i - 2 >= 0 && s[i - 2] == s[i]) return false
+        return true
+    }
+}

src/main/kotlin/g2601_2700/s2663_lexicographically_smallest_beautiful_string/readme.md

@@ -0,0 +1,42 @@
+2663\. Lexicographically Smallest Beautiful String
+
+Hard
+
+A string is **beautiful** if:
+
+*   It consists of the first `k` letters of the English lowercase alphabet.
+*   It does not contain any substring of length `2` or more which is a palindrome.
+
+You are given a beautiful string `s` of length `n` and a positive integer `k`.
+
+Return _the lexicographically smallest string of length_ `n`_, which is larger than_ `s` _and is **beautiful**_. If there is no such string, return an empty string.
+
+A string `a` is lexicographically larger than a string `b` (of the same length) if in the first position where `a` and `b` differ, `a` has a character strictly larger than the corresponding character in `b`.
+
+*   For example, `"abcd"` is lexicographically larger than `"abcc"` because the first position they differ is at the fourth character, and `d` is greater than `c`.
+
+**Example 1:**
+
+**Input:** s = "abcz", k = 26
+
+**Output:** "abda"
+
+**Explanation:**
+
+The string "abda" is beautiful and lexicographically larger than the string "abcz".
+
+It can be proven that there is no string that is lexicographically larger than the string "abcz", beautiful, and lexicographically smaller than the string "abda".
+
+**Example 2:**
+
+**Input:** s = "dc", k = 4
+
+**Output:** ""
+
+**Explanation:** It can be proven that there is no string that is lexicographically larger than the string "dc" and is beautiful.
+
+**Constraints:**
+
+*   <code>1 <= n == s.length <= 10<sup>5</sup></code>
+*   `4 <= k <= 26`
+*   `s` is a beautiful string.

src/main/kotlin/g2601_2700/s2665_counter_ii/readme.md

@@ -0,0 +1,44 @@
+2665\. Counter II
+
+Easy
+
+Write a function `createCounter`. It should accept an initial integer `init`. It should return an object with three functions.
+
+The three functions are:
+
+*   `increment()` increases the current value by 1 and then returns it.
+*   `decrement()` reduces the current value by 1 and then returns it.
+*   `reset()` sets the current value to `init` and then returns it.
+
+**Example 1:**
+
+**Input:** init = 5, calls = ["increment","reset","decrement"]
+
+**Output:** [6,5,4]
+
+**Explanation:** 
+
+    const counter = createCounter(5); 
+    counter.increment(); // 6 
+    counter.reset(); // 5 
+    counter.decrement(); // 4
+
+**Example 2:**
+
+**Input:** init = 0, calls = ["increment","increment","decrement","reset","reset"]
+
+**Output:** [1,2,1,0,0]
+
+**Explanation:** 
+
+    const counter = createCounter(0); 
+    counter.increment(); // 1 
+    counter.increment(); // 2 
+    counter.decrement(); // 1 
+    counter.reset(); // 0 
+    counter.reset(); // 0
+
+**Constraints:**
+
+*   `-1000 <= init <= 1000`
+*   `total calls not to exceed 1000`

src/main/kotlin/g2601_2700/s2665_counter_ii/solution.ts

@@ -0,0 +1,34 @@
+// #Easy #2023_07_25_Time_65_ms_(86.59%)_Space_44.8_MB_(93.23%)
+
+type ReturnObj = {
+    increment: () => number,
+    decrement: () => number,
+    reset: () => number,
+}
+
+function createCounter(init: number): ReturnObj {
+    let n = init
+    return {
+        increment: () => {
+            n = n + 1
+            return n
+        },
+        decrement: () => {
+            n = n - 1
+            return n
+        },
+        reset: () => {
+            n = init
+            return n
+        }
+    }
+}
+
+/*
+ * const counter = createCounter(5)
+ * counter.increment(); // 6
+ * counter.reset(); // 5
+ * counter.decrement(); // 4
+ */
+
+export { createCounter }

src/main/kotlin/g2601_2700/s2666_allow_one_function_call/readme.md

@@ -0,0 +1,39 @@
+2666\. Allow One Function Call
+
+Easy
+
+Given a function `fn`, return a new function that is identical to the original function except that it ensures `fn` is called at most once.
+
+*   The first time the returned function is called, it should return the same result as `fn`.
+*   Every subsequent time it is called, it should return `undefined`.
+
+**Example 1:**
+
+**Input:** fn = (a,b,c) => (a + b + c), calls = [[1,2,3],[2,3,6]]
+
+**Output:** [{"calls":1,"value":6}]
+
+**Explanation:** 
+
+    const onceFn = once(fn); 
+    onceFn(1, 2, 3); // 6 
+    onceFn(2, 3, 6); // undefined, fn was not called
+
+**Example 2:**
+
+**Input:** fn = (a,b,c) => (a \* b \* c), calls = [[5,7,4],[2,3,6],[4,6,8]]
+
+**Output:** [{"calls":1,"value":140}]
+
+**Explanation:** 
+
+    const onceFn = once(fn); 
+    onceFn(5, 7, 4); // 140 
+    onceFn(2, 3, 6); // undefined, fn was not called 
+    onceFn(4, 6, 8); // undefined, fn was not called
+
+**Constraints:**
+
+*   `1 <= calls.length <= 10`
+*   `1 <= calls[i].length <= 100`
+*   `2 <= JSON.stringify(calls).length <= 1000`