Improved tasks 45-51.

Author: javadev

src/main/kotlin/g0001_0100/s0045_jump_game_ii/Solution.kt

@@ -2,20 +2,25 @@ package g0001_0100.s0045_jump_game_ii
 
 // #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Greedy
 // #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_4
-// #2022_08_27_Time_231_ms_(98.08%)_Space_36.8_MB_(100.00%)
+// #2022_08_29_Time_227_ms_(98.14%)_Space_37.3_MB_(100.00%)
 
 class Solution {
     fun jump(nums: IntArray): Int {
-        var jumps = 0
+        var length = 0
+        var maxLength = 0
         var minJump = 0
-        var maxJump = 0
-        while (maxJump < nums.lastIndex) {
-            var nextJump = 0
-            for (i in minJump..maxJump) { nextJump = maxOf(nextJump, i + nums[i]) }
-            minJump = maxJump + 1
-            maxJump = nextJump
-            jumps++
+        for (i in 0 until nums.size - 1) {
+            length--
+            maxLength--
+            maxLength = Math.max(maxLength, nums[i])
+            if (length <= 0) {
+                length = maxLength
+                minJump++
+            }
+            if (length >= nums.size - i - 1) {
+                return minJump
+            }
         }
-        return jumps
+        return minJump
     }
 }

src/main/kotlin/g0001_0100/s0046_permutations/Solution.kt

@@ -2,30 +2,37 @@ package g0001_0100.s0046_permutations
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Backtracking
 // #Algorithm_I_Day_11_Recursion_Backtracking #Level_2_Day_20_Brute_Force/Backtracking
-// #Udemy_Backtracking/Recursion #2022_08_28_Time_299_ms_(80.72%)_Space_39.8_MB_(85.67%)
+// #Udemy_Backtracking/Recursion #2022_08_29_Time_186_ms_(100.00%)_Space_36.9_MB_(98.90%)
 
 class Solution {
     fun permute(nums: IntArray): List<List<Int>> {
-        var result = mutableListOf<MutableList<Int>>()
-        val subResult = mutableListOf<Int>()
-        subResult.add(nums[0])
-        result.add(subResult)
-        for (i in 1 until nums.size) {
-            result = insert(nums[i], result)
+        if (nums.isEmpty()) {
+            return ArrayList()
         }
-        return result
+        val finalResult: MutableList<List<Int>> = ArrayList()
+        permuteRecur(nums, finalResult, ArrayList(), BooleanArray(nums.size))
+        return finalResult
     }
 
-    private fun insert(n: Int, arr: MutableList<MutableList<Int>>): MutableList<MutableList<Int>> {
-        val result = mutableListOf<MutableList<Int>>()
-        arr.forEach { p ->
-            for (i in 0..p.size) {
-                val subResult = mutableListOf<Int>()
-                subResult.addAll(p)
-                subResult.add(i, n)
-                result.add(subResult)
+    private fun permuteRecur(
+        nums: IntArray,
+        finalResult: MutableList<List<Int>>,
+        currResult: MutableList<Int>,
+        used: BooleanArray
+    ) {
+        if (currResult.size == nums.size) {
+            finalResult.add(ArrayList(currResult))
+            return
+        }
+        for (i in nums.indices) {
+            if (used[i]) {
+                continue
             }
+            currResult.add(nums[i])
+            used[i] = true
+            permuteRecur(nums, finalResult, currResult, used)
+            used[i] = false
+            currResult.removeAt(currResult.size - 1)
         }
-        return result
     }
 }

src/main/kotlin/g0001_0100/s0048_rotate_image/Solution.kt

@@ -2,57 +2,27 @@ package g0001_0100.s0048_rotate_image
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Matrix
 // #Data_Structure_II_Day_3_Array #Programming_Skills_II_Day_7 #Udemy_2D_Arrays/Matrix
-// #2022_08_28_Time_197_ms_(89.14%)_Space_35.5_MB_(83.90%)
+// #2022_08_29_Time_287_ms_(46.50%)_Space_35.9_MB_(45.39%)
 
 class Solution {
     fun rotate(matrix: Array<IntArray>) {
-        val q = Queue()
-        var l = 0
-        var r = matrix.size - 1
-        var u = 0
-        var d = matrix.size - 1
-        while (true) {
-            if (l >= r) {
-                break
+        val n: Int = matrix.size
+        for (i in 0 until n / 2) {
+            for (j in i until n - i - 1) {
+                val pos = arrayOf(
+                    intArrayOf(i, j),
+                    intArrayOf(j, n - 1 - i),
+                    intArrayOf(n - 1 - i, n - 1 - j),
+                    intArrayOf(n - 1 - j, i)
+                )
+                var t = matrix[pos[0][0]][pos[0][1]]
+                for (k in 1 until pos.size) {
+                    val temp = matrix[pos[k][0]][pos[k][1]]
+                    matrix[pos[k][0]][pos[k][1]] = t
+                    t = temp
+                }
+                matrix[pos[0][0]][pos[0][1]] = t
             }
-            q.initialize()
-            for (i in l until r) {
-                q.enq(matrix[u][i])
-            }
-            for (i in u until d) {
-                q.enq(matrix[i][r])
-                matrix[i][r] = q.deq()
-            }
-            for (i in r downTo l + 1) {
-                q.enq(matrix[d][i])
-                matrix[d][i] = q.deq()
-            }
-            for (i in d downTo u + 1) {
-                q.enq(matrix[i][l])
-                matrix[i][l] = q.deq()
-            }
-            for (i in l until r) {
-                matrix[u][i] = q.deq()
-            }
-            l += 1
-            r -= 1
-            u += 1
-            d -= 1
-        }
-    }
-
-    class Queue {
-        var queue = MutableList(0) { 0 }
-        fun initialize() {
-            this.queue = MutableList(0) { 0 }
-        }
-        fun enq(i: Int) {
-            this.queue.add(i)
-        }
-        fun deq(): Int {
-            val r = this.queue[0]
-            this.queue.removeAt(0)
-            return r
         }
     }
 }

src/main/kotlin/g0001_0100/s0049_group_anagrams/Solution.kt

@@ -2,33 +2,22 @@ package g0001_0100.s0049_group_anagrams
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #String #Hash_Table #Sorting
 // #Data_Structure_II_Day_8_String #Programming_Skills_II_Day_11 #Udemy_Strings
-// #2022_08_28_Time_554_ms_(82.47%)_Space_74.6_MB_(66.07%)
+// #2022_08_29_Time_506_ms_(86.55%)_Space_72.5_MB_(81.04%)
+
+import java.util.Arrays
 
 class Solution {
     fun groupAnagrams(strs: Array<String>): List<List<String>> {
-        if (strs.isEmpty()) {
-            return emptyList()
-        }
-        val hashMap = hashMapOf<String, MutableList<String>>()
-        for (i in strs.indices) {
-            val charArray = strs[i].toCharArray()
-            charArray.sort()
-            val sortedWord = String(charArray)
-            if (hashMap.containsKey(sortedWord)) {
-                hashMap[sortedWord]?.let {
-                    it.add(strs[i])
-                    hashMap[sortedWord] = it
-                }
-            } else {
-                val list = mutableListOf<String>()
-                list.add(strs[i])
-                hashMap[sortedWord] = list
-            }
-        }
-        val list = mutableListOf<List<String>>()
-        hashMap.values.forEach {
-            list.add(it)
+        val hm: MutableMap<String, MutableList<String>> = HashMap()
+        for (s in strs) {
+            val ch = s.toCharArray()
+            Arrays.sort(ch)
+            val temp = String(ch)
+            hm.computeIfAbsent(
+                temp
+            ) { _: String? -> ArrayList() }
+            hm[temp]!!.add(s)
         }
-        return list
+        return ArrayList<List<String>>(hm.values)
     }
 }

src/main/kotlin/g0001_0100/s0051_n_queens/Solution.kt

@@ -1,55 +1,48 @@
 package g0001_0100.s0051_n_queens
 
 // #Hard #Top_100_Liked_Questions #Array #Backtracking
-// #2022_08_28_Time_280_ms_(88.35%)_Space_41.3_MB_(81.55%)
+// #2022_08_29_Time_243_ms_(95.10%)_Space_39.7_MB_(91.18%)
+
+import java.util.Arrays
 
 class Solution {
     fun solveNQueens(n: Int): List<List<String>> {
-        val result = mutableListOf<List<String>>()
-        val board = Array(n) { CharArray(n) { '.' } }
-        // check only top rows and cols
-        fun isValid(row: Int, col: Int): Boolean {
-            for (i in 0 until row) {
-                if (board[i][col] == 'Q')
-                    return false
-            }
-            // top right
-            var (i, j) = row - 1 to col + 1
-            while (i >= 0 && j < n) {
-                if (board[i--][j++] == 'Q')
-                    return false
-            }
-            // top left
-            i = row - 1
-            j = col - 1
-            while (i >= 0 && j >= 0) {
-                if (board[i--][j--] == 'Q') {
-                    return false
-                }
-            }
-            return true
-        }
+        val pos = BooleanArray(n + 2 * n - 1 + 2 * n - 1)
+        val pos2 = IntArray(n)
+        val ans: MutableList<List<String>> = ArrayList()
+        helper(n, 0, pos, pos2, ans)
+        return ans
+    }
 
-        fun construct() {
-            val list = mutableListOf<String>()
-            for (row in board) list.add(String(row))
-            result.add(list)
+    private fun helper(n: Int, row: Int, pos: BooleanArray, pos2: IntArray, ans: MutableList<List<String>>) {
+        if (row == n) {
+            construct(n, pos2, ans)
+            return
         }
-
-        fun backtrack(row: Int) {
-            if (row == n) {
-                construct()
-                return
-            }
-            for (col in 0 until n) {
-                if (isValid(row, col)) {
-                    board[row][col] = 'Q'
-                    backtrack(row + 1)
-                    board[row][col] = '.'
-                }
+        for (i in 0 until n) {
+            val index = n + 2 * n - 1 + n - 1 + i - row
+            if (pos[i] || pos[n + i + row] || pos[index]) {
+                continue
             }
+            pos[i] = true
+            pos[n + i + row] = true
+            pos[index] = true
+            pos2[row] = i
+            helper(n, row + 1, pos, pos2, ans)
+            pos[i] = false
+            pos[n + i + row] = false
+            pos[index] = false
+        }
+    }
+
+    private fun construct(n: Int, pos: IntArray, ans: MutableList<List<String>>) {
+        val sol: MutableList<String> = ArrayList()
+        for (r in 0 until n) {
+            val queenRow = CharArray(n)
+            Arrays.fill(queenRow, '.')
+            queenRow[pos[r]] = 'Q'
+            sol.add(String(queenRow))
         }
-        backtrack(0)
-        return result
+        ans.add(sol)
     }
 }

src/test/kotlin/g0001_0100/s0039_combination_sum/SolutionTest.kt

@@ -7,12 +7,24 @@ import org.junit.jupiter.api.Test
 internal class SolutionTest {
     @Test
     fun combinationSum() {
-        assertThat(Solution().combinationSum(intArrayOf(2, 3, 6, 7), 7), equalTo(arrayOf(intArrayOf(2, 2, 3).toList(), intArrayOf(7).toList()).toList()))
+        assertThat(
+            Solution().combinationSum(intArrayOf(2, 3, 6, 7), 7),
+            equalTo(arrayOf(intArrayOf(2, 2, 3).toList(), intArrayOf(7).toList()).toList())
+        )
     }
 
     @Test
     fun combinationSum2() {
-        assertThat(Solution().combinationSum(intArrayOf(2, 3, 5), 8), equalTo(arrayOf(intArrayOf(2, 2, 2, 2).toList(), intArrayOf(2, 3, 3).toList(), intArrayOf(3, 5).toList()).toList()))
+        assertThat(
+            Solution().combinationSum(intArrayOf(2, 3, 5), 8),
+            equalTo(
+                arrayOf(
+                    intArrayOf(2, 2, 2, 2).toList(),
+                    intArrayOf(2, 3, 3).toList(),
+                    intArrayOf(3, 5).toList()
+                ).toList()
+            )
+        )
     }
 
     @Test

src/test/kotlin/g0001_0100/s0046_permutations/SolutionTest.kt

@@ -1,22 +1,38 @@
 package g0001_0100.s0046_permutations
 
+import com_github_leetcode.ArrayUtils.getLists
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.MatcherAssert.assertThat
 import org.junit.jupiter.api.Test
 
 internal class SolutionTest {
     @Test
     fun permute() {
-        assertThat(Solution().permute(intArrayOf(1, 2, 3)), equalTo(arrayOf(intArrayOf(3, 2, 1).toList(), intArrayOf(2, 3, 1).toList(), intArrayOf(2, 1, 3).toList(), intArrayOf(3, 1, 2).toList(), intArrayOf(1, 3, 2).toList(), intArrayOf(1, 2, 3).toList()).toList()))
+        val expected = arrayOf(
+            intArrayOf(1, 2, 3),
+            intArrayOf(1, 3, 2),
+            intArrayOf(2, 1, 3),
+            intArrayOf(2, 3, 1),
+            intArrayOf(3, 1, 2),
+            intArrayOf(3, 2, 1)
+        )
+        assertThat(
+            Solution().permute(intArrayOf(1, 2, 3)),
+            equalTo(getLists(expected))
+        )
     }
 
     @Test
     fun permute2() {
-        assertThat(Solution().permute(intArrayOf(0, 1)), equalTo(arrayOf(intArrayOf(1, 0).toList(), intArrayOf(0, 1).toList()).toList()))
+        val expected = arrayOf(intArrayOf(0, 1), intArrayOf(1, 0))
+        assertThat(
+            Solution().permute(intArrayOf(0, 1)), equalTo(getLists(expected))
+        )
     }
 
     @Test
     fun permute3() {
-        assertThat(Solution().permute(intArrayOf(1)), equalTo(arrayOf(intArrayOf(1).toList()).toList()))
+        val expected = arrayOf(intArrayOf(1))
+        assertThat(Solution().permute(intArrayOf(1)), equalTo(getLists(expected)))
     }
 }