Add Min Coin Combination

Author: marttp

kotlin/Dynamic Programming/MinCoinCombinationBottomUp.kt

@@ -0,0 +1,16 @@
+fun minCoinCombinationBottomUp(coins: List<Int>, target: Int): Int {
+    // The DP array will store the minimum number of coins needed for
+    // each amount. Set each element to a large number initially.
+    val dp = IntArray(target + 1) { Int.MAX_VALUE }
+    // Base case: if the target is 0, then 0 coins are needed.
+    dp[0] = 0
+    // Update the DP array for all target amounts greater than 0.
+    for (t in 1..target) {
+        for (coin in coins) {
+            if (coin <= t) {
+                dp[t] = minOf(dp[t], 1 + dp[t - coin])
+            }
+        }
+    }
+    return if (dp[target] != Int.MAX_VALUE) dp[target] else -1
+}

kotlin/Dynamic Programming/MinCoinCombinationTopDown.kt

@@ -0,0 +1,28 @@
+fun minCoinCombinationTopDown(coins: List<Int>, target: Int): Int {
+    val memo = hashMapOf<Int, Int>()
+    val result = topDownDp(coins, target, memo)
+    return if (result == Int.MAX_VALUE) -1 else result
+}
+
+fun topDownDp(coins: List<Int>, target: Int, memo: MutableMap<Int, Int>): Int {
+    // Base case: if the target is 0, then 0 coins are needed to reach
+    // it.
+    if (target == 0) {
+        return 0
+    }
+    if (target in memo) {
+        return memo[target]!!
+    }
+    // Initialize 'minCoins' to a large number.
+    var minCoins = Int.MAX_VALUE
+    for (coin in coins) {
+        // Avoid negative targets.
+        if (coin <= target) {
+            // Calculate the minimum number of coins needed if we use
+            // the current coin.
+            minCoins = minOf(minCoins, 1 + topDownDp(coins, target - coin, memo))
+        }
+    }
+    memo[target] = minCoins
+    return memo[target]!!
+}