Kotlin - Chapter 14: Backtracking

marttp · marttp · commit a152000c1237 · 2025-01-18T10:04:50.000+09:00
* Combinations of Sum K
* Find All Permutations
* Find All Subsets
* N Queens
* Phone Keypad Combinations
diff --git a/kotlin/Backtracking/CombinationsOfSumK.kt b/kotlin/Backtracking/CombinationsOfSumK.kt
@@ -0,0 +1,34 @@
+fun combinationsOfSumK(nums: List<Int>, target: Int): List<List<Int>> {
+    val res = mutableListOf<List<Int>>()
+    dfs(mutableListOf(), 0, nums, target, res)
+    return res
+}
+
+fun dfs(
+        combination: MutableList<Int>,
+        startIndex: Int,
+        nums: List<Int>,
+        target: Int,
+        res: MutableList<List<Int>>
+) {
+    // Termination condition: If the target is equal to 0, we found a combination
+    // that sums to 'k'.
+    if (target == 0) {
+        res.add(ArrayList(combination))
+        return
+    }
+    // Termination condition: If the target is less than 0, no more valid
+    // combinations can be created by adding it to the current combination.
+    if (target < 0) {
+        return
+    }
+    // Starting from start_index, explore all combinations after adding nums[i].
+    for (i in startIndex until nums.size) {
+        // Add the current number to create a new combination.
+        combination.add(nums[i])
+        // Recursively explore all paths that branch from this new combination.
+        dfs(combination, i, nums, target - nums[i], res)
+        // Backtrack by removing the number we just added.
+        combination.removeAt(combination.size - 1)
+    }
+}
diff --git a/kotlin/Backtracking/FindAllPermutations.kt b/kotlin/Backtracking/FindAllPermutations.kt
@@ -0,0 +1,32 @@
+fun findAllPermutations(nums: List<Int>): List<List<Int>> {
+    val res = mutableListOf<List<Int>>()
+    backtrack(nums, mutableListOf(), mutableSetOf(), res)
+    return res
+}
+
+fun backtrack(
+        nums: List<Int>,
+        candidate: MutableList<Int>,
+        used: MutableSet<Int>,
+        res: MutableList<List<Int>>
+) {
+    // If the current candidate is a complete permutation, add it to the
+    // result.
+    if (candidate.size == nums.size) {
+        res.add(candidate.toList())
+        return
+    }
+    for (num in nums) {
+        if (num !in used) {
+            // Add 'num' to the current permutation and mark it as used.
+            candidate.add(num)
+            used.add(num)
+            // Recursively explore all branches using the updated
+            // permutation candidate.
+            backtrack(nums, candidate, used, res)
+            // Backtrack by reversing the changes made.
+            candidate.removeAt(candidate.size - 1)
+            used.remove(num)
+        }
+    }
+}
diff --git a/kotlin/Backtracking/FindAllSubsets.kt b/kotlin/Backtracking/FindAllSubsets.kt
@@ -0,0 +1,22 @@
+fun findAllSubsets(nums: List<Int>): List<List<Int>> {
+    val res = mutableListOf<List<Int>>()
+    backtrack(0, mutableListOf(), nums, res)
+    return res
+}
+
+fun backtrack(i: Int, currSubset: MutableList<Int>, nums: List<Int>, res: MutableList<List<Int>>) {
+    // Base case: if all elements have been considered, add the
+    // current subset to the output.
+    if (i == nums.size) {
+        res.add(currSubset.toList())
+        return
+    }
+    // Include the current element and recursively explore all paths
+    // that branch from this subset.
+    currSubset.add(nums[i])
+    backtrack(i + 1, currSubset, nums, res)
+    // Exclude the current element and recursively explore all paths
+    // that branch from this subset.
+    currSubset.removeAt(currSubset.size - 1)
+    backtrack(i + 1, currSubset, nums, res)
+}
diff --git a/kotlin/Backtracking/NQueens.kt b/kotlin/Backtracking/NQueens.kt
@@ -0,0 +1,43 @@
+fun nQueens(n: Int): Int {
+    // In Kotlin, Global variable is anti-pattern
+    var res = mutableListOf<Int>()
+    dfs(0, mutableSetOf(), mutableSetOf(), mutableSetOf(), n, res)
+    return res[0]
+}
+
+fun dfs(
+        r: Int,
+        diagonalsSet: MutableSet<Int>,
+        antiDiagonalsSet: MutableSet<Int>,
+        colsSet: MutableSet<Int>,
+        n: Int,
+        res: MutableList<Int>
+) {
+    // Termination condition: If we have reached the end of the rows,
+    // we've placed all 'n' queens.
+    if (r == n) {
+        res[0] = res[0] + 1
+        return
+    }
+    for (c in 0 until n) {
+        val currDiagonal = r - c
+        val currAntiDiagonal = r + c
+        // If there are queens on the current column, diagonal or
+        // anti−diagonal, skip this square.
+        if (c in colsSet || currDiagonal in diagonalsSet || currAntiDiagonal in antiDiagonalsSet) {
+            continue
+        }
+        // Place the queen by marking the current column, diagonal, and
+        // anti −diagonal as occupied.
+        colsSet.add(c)
+        diagonalsSet.add(currDiagonal)
+        antiDiagonalsSet.add(currAntiDiagonal)
+        // Recursively move to the next row to continue placing queens.
+        dfs(r + 1, diagonalsSet, antiDiagonalsSet, colsSet, n, res)
+        // Backtrack by removing the current column, diagonal, and
+        // anti −diagonal from the hash sets.
+        colsSet.remove(c)
+        diagonalsSet.remove(currDiagonal)
+        antiDiagonalsSet.remove(currAntiDiagonal)
+    }
+}
diff --git a/kotlin/Backtracking/PhoneKeypadCombinations.kt b/kotlin/Backtracking/PhoneKeypadCombinations.kt
@@ -0,0 +1,39 @@
+fun phoneKeypadCombinations(digits: String): List<String> {
+    val keypadMap = mapOf(
+        '2' to "abc", 
+        '3' to "def", 
+        '4' to "ghi", 
+        '5' to "jkl",
+        '6' to "mno", 
+        '7' to "pqrs", 
+        '8' to "tuv", 
+        '9' to "wxyz"
+    )
+    val res = mutableListOf<String>()
+    backtrack(0, mutableListOf(), digits, keypadMap, res)
+    return res
+}
+
+fun backtrack(
+    i: Int, 
+    currCombination: MutableList<Char>, 
+    digits: String, 
+    keypadMap: Map<Char, String>, 
+    res: MutableList<String>
+) {
+    // Termination condition: if all digits have been considered, add the
+    // current combination to the output list.
+    if (currCombination.size == digits.length) {
+        res.add(currCombination.joinToString(""))
+        return
+    }
+    for (letter in keypadMap[digits[i]]!!) {
+        // Add the current letter.
+        currCombination.add(letter)
+        // Recursively explore all paths that branch from this combination.
+        backtrack(i + 1, currCombination, digits, keypadMap, res)
+        // Backtrack by removing the letter we just added.
+        currCombination.removeAt(currCombination.size - 1)
+    }
+}
+
