Merge pull request ByteByteGoHq#43 from marttp/kotlin-dynamic-programming

Kotlin - Chapter 15: Dynamic Programming

Author: Destiny-02

kotlin/Dynamic Programming/ClimbingStairsBottomUp.kt

@@ -0,0 +1,15 @@
+fun climbingStairsBottomUp(n: Int): Int {
+    if (n <= 2) {
+        return n
+    }
+    val dp = IntArray(n + 1)
+    // Base cases.
+    dp[1] = 1
+    dp[2] = 2
+    // Starting from step 3, calculate the number of ways to reach each
+    // step until the n-th step.
+    for (i in 3..n) {
+        dp[i] = dp[i - 1] + dp[i - 2]
+    }
+    return dp[n]
+}

kotlin/Dynamic Programming/ClimbingStairsBottomUpOptimize.kt

@@ -0,0 +1,16 @@
+fun climbingStairsBottomUpOptimized(n: Int): Int {
+    if (n <= 2) {
+        return n
+    }
+    // Set 'oneStepBefore' and 'twoStepsBefore' as the base cases.
+    var oneStepBefore = 2
+    var twoStepsBefore = 1
+    for (i in 3..n) {
+        // Calculate the number of ways to reach the current step.
+        val current = oneStepBefore + twoStepsBefore
+        // Update the values for the next iteration.
+        twoStepsBefore = oneStepBefore
+        oneStepBefore = current
+    }
+    return oneStepBefore
+}

kotlin/Dynamic Programming/ClimbingStairsTopDown.kt

@@ -0,0 +1,19 @@
+fun climbingStairsTopDown(n: Int): Int {
+    val memo = hashMapOf<Int, Int>()
+    return climbingStairsTopDownHelper(n, memo)
+}
+
+fun climbingStairsTopDownHelper(n: Int, memo: HashMap<Int, Int>): Int {
+    // Base cases: With a 1-step staircase, there's only one way to
+    // climb it. With a 2-step staircase, there are two ways to climb it.
+    if (n <= 2) {
+        return n
+    }
+    if (memo[n] != 0) {
+        return memo[n]!!
+    }
+    // The number of ways to climb to the n-th step is equal to the sum
+    // of the number of ways to climb to step n - 1 and to n - 2.
+    memo[n] = climbingStairsTopDownHelper(n - 1, memo) + climbingStairsTopDownHelper(n - 2, memo)
+    return memo[n]!!
+}

kotlin/Dynamic Programming/Knapsack.kt

@@ -0,0 +1,22 @@
+fun knapsack(cap: Int, weights: List<Int>, values: List<Int>): Int {
+    val n = values.size
+    // Base case: Set the first column and last row to 0 by
+    // initializing the entire DP table to 0.
+    val dp = Array(n + 1) { IntArray(cap + 1) }
+    // Populate the DP table.
+    for (i in n - 1 downTo 0) {
+        for (c in 1..cap) {
+            // If the item 'i' fits in the current knapsack capacity,
+            // the maximum value at 'dp[i][c]' is the largest of either:
+            // 1. The maximum value if we include item 'i'.
+            // 2. The maximum value if we exclude item 'i'.
+            if (weights[i] <= c) {
+                dp[i][c] = Math.max(values[i] + dp[i + 1][c - weights[i]], dp[i + 1][c])
+            } else {
+                // If it doesn't fit, we have to exclude it.
+                dp[i][c] = dp[i + 1][c]
+            }
+        }
+    }
+    return dp[0][cap]
+}

kotlin/Dynamic Programming/KnapsackOptimized.kt

@@ -0,0 +1,27 @@
+fun knapsackOptimized(cap: Int, weights: List<Int>, values: List<Int>): Int {
+    val n = values.size
+    // Initialize 'prevRow' as the DP values of the row below the
+    // current row.
+    var prevRow = IntArray(cap + 1)
+    for (i in n - 1 downTo 0) {
+        // Set the first cell of the 'currRow' to 0 to set the base
+        // case for this row. This is done by initializing the entire
+        // row to 0.
+        val currRow = IntArray(cap + 1)
+        for (c in 1..cap) {
+            // If item 'i' fits in the current knapsack capacity, the
+            // maximum value at 'currRow[c]' is the largest of either:
+            // 1. The maximum value if we include item 'i'.
+            // 2. The maximum value if we exclude item 'i'.
+            if (weights[i] <= c) {
+                currRow[c] = Math.max(values[i] + prevRow[c - weights[i]], prevRow[c])
+            } else {
+                // If it doesn't fit, we have to exclude it.
+                currRow[c] = prevRow[c]
+            }
+        }
+        // Set 'prevRow' to 'currRow' values for the next iteration.
+        prevRow = currRow
+    }
+    return prevRow[cap]
+}

kotlin/Dynamic Programming/LargestSquareInAMatrix.kt

@@ -0,0 +1,38 @@
+fun largestSquareInAMatrix(matrix: List<List<Int>>): Int {
+    if (matrix.isEmpty()) {
+        return 0
+    }
+    val m = matrix.size
+    val n = matrix[0].size
+    val dp = Array(m) { IntArray(n) }
+    var maxLen = 0
+    // Base case: If a cell in row 0 is 1, the largest square ending there has a
+    // length of 1.
+    for (j in 0 until n) {
+        if (matrix[0][j] == 1) {
+            dp[0][j] = 1
+            maxLen = 1
+        }
+    }
+    // Base case: If a cell in column 0 is 1, the largest square ending there has
+    // a length of 1.
+    for (i in 0 until m) {
+        if (matrix[i][0] == 1) {
+            dp[i][0] = 1
+            maxLen = 1
+        }
+    }
+    // Populate the rest of the DP table.
+    for (i in 1 until m) {
+        for (j in 1 until n) {
+            if (matrix[i][j] == 1) {
+                // The length of the largest square ending here is determined by
+                // the smallest square ending at the neighboring cells (left,
+                // top-left, top), plus 1 to include this cell.
+                dp[i][j] = 1 + minOf(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1])
+            }
+            maxLen = maxOf(maxLen, dp[i][j])
+        }
+    }
+    return maxLen * maxLen
+}

kotlin/Dynamic Programming/LargestSquareInAMatrixOptimized.kt

@@ -0,0 +1,28 @@
+fun largestSquareInAMatrixOptimized(matrix: Array<IntArray>): Int {
+    if (matrix.isEmpty()) return 0
+    val m = matrix.size
+    val n = matrix[0].size
+    var prevRow = IntArray(n)
+    var maxLen = 0
+    // Iterate through the matrix.
+    for (i in 0 until m) {
+        val currRow = IntArray(n)
+        for (j in 0 until n) {
+            // Base cases: if we’re in row 0 or column 0, the largest square ending
+            // here has a length of 1. This can be set by using the value in the
+            // input matrix.
+            if (i == 0 || j == 0) {
+                currRow[j] = matrix[i][j]
+            } else {
+                if (matrix[i][j] == 1) {
+                    // curr_row[j] = 1 + min(left, top-left, top)
+                    currRow[j] = 1 + minOf(currRow[j - 1], prevRow[j - 1], prevRow[j])
+                }
+            }
+            maxLen = maxOf(maxLen, currRow[j])
+        }
+        // Update 'prevRow' with 'currRow' values for the next iteration.
+        prevRow = currRow.copyOf()
+    }
+    return maxLen * maxLen
+}

kotlin/Dynamic Programming/LongestCommonSubsequence.kt

@@ -0,0 +1,23 @@
+fun longestCommonSubsequence(s1: String, s2: String): Int {
+    // Base case: Set the last row and last column to 0 by
+    // initializing the entire DP table with 0s.
+    val dp = Array(s1.length + 1) { IntArray(s2.length + 1) }
+    // Populate the DP table.
+    for (i in s1.length - 1 downTo 0) {
+        for (j in s2.length - 1 downTo 0) {
+            // If the characters match, the length of the LCS at
+            // 'dp[i][j]' is 1 + the LCS length of the remaining
+            // substrings.
+            if (s1[i] == s2[j]) {
+                dp[i][j] = 1 + dp[i + 1][j + 1]
+            } else {
+                // If the characters don't match, the LCS length at
+                // 'dp[i][j]' can be found by either:
+                // 1. Excluding the current character of s1.
+                // 2. Excluding the current character of s2.
+                dp[i][j] = maxOf(dp[i + 1][j], dp[i][j + 1])
+            }
+        }
+    }
+    return dp[0][0]
+}

kotlin/Dynamic Programming/LongestCommonSubsequenceOptimized.kt

@@ -0,0 +1,26 @@
+fun longestCommonSubsequenceOptimized(s1: String, s2: String): Int {
+    // Initialize 'prevRow' as the DP values of the last row.
+    var prevRow = IntArray(s2.length + 1)
+    for (i in s1.length - 1 downTo 0) {
+        // Set the last cell of 'currRow' to 0 to set the base case for
+        // this row. This is done by initializing the entire row to 0.
+        val currRow = IntArray(s2.length + 1)
+        for (j in s2.length - 1 downTo 0) {
+            // If the characters match, the length of the LCS at
+            // 'currRow[j]' is 1 + the LCS length of the remaining
+            // substrings ('prevRow[j + 1]').
+            if (s1[i] == s2[j]) {
+                currRow[j] = 1 + prevRow[j + 1]
+            } else {
+                // If the characters don't match, the LCS length at
+                // 'currRow[j]' can be found by either:
+                // 1. Excluding the current character of s1 ('prevRow[j]').
+                // 2. Excluding the current character of s2 ('currRow[j + 1]').
+                currRow[j] = maxOf(prevRow[j], currRow[j + 1])
+            }
+        }
+        // Update 'prevRow' with 'currRow' values for the next iteration.
+        prevRow = currRow
+    }
+    return prevRow[0]
+}

kotlin/Dynamic Programming/LongestPalindromeInAString.kt

@@ -0,0 +1,38 @@
+fun longestPalindromeInAString(s: String): String {
+    val n = s.length
+    if (n == 0) {
+        return ""
+    }
+    val dp = Array(n) { BooleanArray(n) }
+    var maxLen = 1
+    var startIndex = 0
+    // Base case: a single character is always a palindrome.
+    for (i in 0 until n) {
+        dp[i][i] = true
+    }
+    // Base case: a substring of length two is a palindrome if both
+    // characters are the same.
+    for (i in 0 until n - 1) {
+        if (s[i] == s[i + 1]) {
+            dp[i][i + 1] = true
+            maxLen = 2
+            startIndex = i
+        }
+    }
+    // Find palindromic substrings of length 3 or greater.
+    for (substringLen in 3..n) {
+        // Iterate through each substring of length 'substringLen'.
+        for (i in 0 until n - substringLen + 1) {
+            val j = i + substringLen - 1
+            // If the first and last characters are the same, and the
+            // inner substring is a palindrome, then the current
+            // substring is a palindrome.
+            if (s[i] == s[j] && dp[i + 1][j - 1]) {
+                dp[i][j] = true
+                maxLen = substringLen
+                startIndex = i
+            }
+        }
+    }
+    return s.substring(startIndex, startIndex + maxLen)
+}

kotlin/Dynamic Programming/LongestPalindromeInAStringExpanding.kt

@@ -0,0 +1,35 @@
+fun longestPalindromeInAStringExpanding(s: String): String {
+    val n = s.length
+    var start = 0
+    var maxLen = 0
+    for (center in 0 until n) {
+        // Check for odd-length palindromes.
+        val (oddStart, oddLength) = expandPalindrome(center, center, s)
+        if (oddLength > maxLen) {
+            start = oddStart
+            maxLen = oddLength
+        }
+        // Check for even-length palindromes.
+        if (center < n - 1 && s[center] == s[center + 1]) {
+            val (evenStart, evenLength) = expandPalindrome(center, center + 1, s)
+            if (evenLength > maxLen) {
+                start = evenStart
+                maxLen = evenLength
+            }
+        }
+    }
+    return s.substring(start, start + maxLen)
+}
+
+// Expands outward from the center of a base case to identify the start
+// index and length of the longest palindrome that extends from this
+// base case.
+fun expandPalindrome(left: Int, right: Int, s: String): Pair<Int, Int> {
+    var l = left
+    var r = right
+    while (l > 0 && r < s.length - 1 && s[l - 1] == s[r + 1]) {
+        l--
+        r++
+    }
+    return l to r - l + 1
+}

kotlin/Dynamic Programming/MatrixPathways.kt

@@ -0,0 +1,14 @@
+fun matrixPathways(m: Int, n: Int): Int {
+    // Base cases: Set all cells in row 0 and column 0 to 1. We can
+    // do this by initializing all cells in the DP table to 1.
+    val dp = Array(m) { IntArray(n) { 1 } }
+    // Fill in the rest of the DP table.
+    for (r in 1 until m) {
+        for (c in 1 until n) {
+            // Paths to current cell = paths from above + paths from
+            // left.
+            dp[r][c] = dp[r - 1][c] + dp[r][c - 1]
+        }
+    }
+    return dp[m - 1][n - 1]
+}

kotlin/Dynamic Programming/MatrixPathwaysOptimized.kt

@@ -0,0 +1,22 @@
+fun matrixPathwaysOptimized(m: Int, n: Int): Int {
+    // Initialize 'prevRow' as the DP values of row 0, which are all 1s.
+    var prevRow = IntArray(n) { 1 }
+    // Iterate through the matrix starting from row 1.
+    for (r in 1 until m) {
+        // Set the first cell of 'currRow' to 1. This is done by
+        // setting the entire row to 1.
+        val currRow = IntArray(n) { 1 }
+        for (c in 1 until n) {
+            // The number of unique paths to the current cell is the sum
+            // of the paths from the cell above it ('prevRow[c]') and
+            // the cell to the left ('currRow[c - 1]').
+            currRow[c] = prevRow[c] + currRow[c - 1]
+        }
+        // Update 'prevRow' with 'currRow' values for the next
+        // iteration.
+        prevRow = currRow
+    }
+    // The last element in 'prevRow' stores the result for the
+    // bottom-right cell.
+    return prevRow[n - 1]
+}

kotlin/Dynamic Programming/MaximumSubarraySum.kt

@@ -0,0 +1,17 @@
+fun maximumSubarraySum(nums: List<Int>): Int {
+    if (nums.isEmpty()) {
+        return 0
+    }
+    // Set the sum variables to negative infinity to ensure negative
+    // sums can be considered.
+    var maxSum = Int.MIN_VALUE
+    var currentSum = Int.MIN_VALUE
+    // Iterate through the array to find the maximum subarray sum.
+    for (num in nums) {
+        // Either add the current number to the existing running sum, or
+        // start a new subarray at the current number.
+        currentSum = maxOf(currentSum + num, num)
+        maxSum = maxOf(maxSum, currentSum)
+    }
+    return maxSum
+}

kotlin/Dynamic Programming/MaximumSubarraySumDP.kt

@@ -0,0 +1,19 @@
+fun maximumSubarraySumDP(nums: IntArray): Int {
+    val n = nums.size
+    if (n == 0) {
+        return 0
+    }
+    val dp = IntArray(n)
+    // Base case: the maximum subarray sum of an array with just one
+    // element is that element.
+    dp[0] = nums[0]
+    var maxSum = dp[0]
+    // Populate the rest of the DP array.
+    for (i in 1 until n) {
+        // Determine the maximum subarray sum ending at the current
+        // index.
+        dp[i] = maxOf(dp[i - 1] + nums[i], nums[i])
+        maxSum = maxOf(maxSum, dp[i])
+    }
+    return maxSum
+}

kotlin/Dynamic Programming/MaximumSubarraySumDPOptimized.kt

@@ -0,0 +1,13 @@
+fun maximumSubarraySumDPOptimized(nums: IntArray): Int {
+    val n = nums.size
+    if (n == 0) {
+        return 0
+    }
+    var currentSum = nums[0]
+    var maxSum = nums[0]
+    for (i in 1 until n) {
+        currentSum = maxOf(nums[i], currentSum + nums[i])
+        maxSum = maxOf(maxSum, currentSum)
+    }
+    return maxSum
+}