DeleteAndEarn

Signed-off-by: Gopal S Akshintala <[email protected]>

Author: overfullstack

ds-algo/src/main/java/practice/binarysearch/LongestSubsequenceWithLimitedSum.java

@@ -10,7 +10,7 @@
  */
 public class LongestSubsequenceWithLimitedSum {
 	public int[] answerQueries(int[] nums, int[] queries) {
-		Arrays.sort(nums);
+		Arrays.sort(nums); // ! Subsequence, so it's ok to lose order of elements
 		var prefix = new int[nums.length];
 		prefix[0] = nums[0];
 		for (var i = 1; i < nums.length; i++) {

ds-algo/src/main/java/practice/dp/CombinationSum4.java

@@ -8,12 +8,10 @@ public int combinationSum4(int[] nums, int target) {
 		var dp = new int[target + 1];
 		dp[0] = 1;
 		for (var sum = 1; sum <= target; sum++) {
-			// !!! Layers multiple nums for same target
-			// ! we consider all possible numbers that could be the "last" number in the sequence
-			// ! Unlike Combination Sum 2
 			for (var num : nums) {
+        // ! Borrow from all previous sums, to add up to combinations
 				if (num <= sum) {
-					dp[sum] += dp[sum - num]; // ! Count multiple combinations for the same sum
+					dp[sum] += dp[sum - num];
 				}
 			}
 		}

ds-algo/src/main/java/practice/dp/DeleteAndEarn.java

@@ -0,0 +1,30 @@
+package practice.dp;
+
+/* 26 Oct 2025 08:23 */
+
+import static java.lang.IO.println;
+
+/**
+ * [740. Delete and Earn](https://leetcode.com/problems/delete-and-earn/)
+ */
+public class DeleteAndEarn {
+  public int deleteAndEarn(int[] nums) {
+    var buckets = new int[1 + (int) Math.pow(10, 4)];
+    for (var num : nums) {
+      buckets[num] += num;
+    }
+    var dp = new int[buckets.length];
+    dp[0] = 0; // ! or buckets[0], which is 0
+    dp[1] = buckets[1]; // ! No need of `maxOf` as it's either 0 or positive
+    for (var i = 2; i < dp.length; i++) {
+      dp[i] = Math.max(dp[i - 1], buckets[i] + dp[i - 2]);
+    }
+    return dp[dp.length - 1];
+  }
+
+  static void main() {
+    var obj = new DeleteAndEarn();
+    println(obj.deleteAndEarn(new int[] {3, 4, 2})); // 6
+    println(obj.deleteAndEarn(new int[] {2, 2, 3, 3, 3, 4})); // 9
+  }
+}

ds-algo/src/main/kotlin/educative/dp/CoinChange.kt

@@ -3,24 +3,24 @@ package educative.dp
 /* 24/7/25 17:38 */
 
 /** [322. Coin Change](https://leetcode.com/problems/coin-change/) */
-fun coinChange(coins: IntArray, sum: Int): Int =
-  // ! minOf exclude and include
+fun coinChange(coins: IntArray, targetSum: Int): Int =
   // ! Forward iteration as we allow the same coin to be used multiple times
   when {
-    sum == 0 -> 0
-    sum < 0 || coins.isEmpty() -> -1
+    targetSum == 0 -> 0
+    targetSum < 0 || coins.isEmpty() -> -1
     else -> {
-      val dp = IntArray(sum + 1) { Int.MAX_VALUE - 1 } // ! `-1` as we do `dp[i-coin]+1` below
+      val dp = IntArray(targetSum + 1) { Int.MAX_VALUE - 1 } // ! `-1` as we do `dp[i-coin]+1` below
       dp[0] = 0
       // * Building the entire sum introducing one coin type at a time
       for (coin in coins) {
+        // ! `dp[i]` holds the fewest number of coins to make sum `i`
         // ! Forward iteration as we allow the same coin to be used multiple times
-        for (i in coin..sum) {
-          // ! minOf exclude and include
-          dp[i] = minOf(dp[i], dp[i - coin] + 1)
+        for (sum in coin..targetSum) {
+          // ! `minOf` exclude and include, for fewest number of coins
+          dp[sum] = minOf(dp[sum], dp[sum - coin] + 1)
         }
       }
-      if (dp[sum] == Int.MAX_VALUE - 1) -1 else dp[sum]
+      if (dp[targetSum] == Int.MAX_VALUE - 1) -1 else dp[targetSum]
     }
   }
 

ds-algo/src/main/kotlin/educative/dp/CoinChange2.kt

@@ -3,17 +3,18 @@ package educative.dp
 /* 24/7/25 17:38 */
 
 /** [518. Coin Change II](https://leetcode.com/problems/coin-change-ii/) */
-fun change(amount: Int, coins: IntArray): Int {
-  val dp = IntArray(amount + 1)
+fun change(targetAmount: Int, coins: IntArray): Int {
+  val dp = IntArray(targetAmount + 1)
   dp[0] = 1
   // * Building the entire sum introducing one coin type at a time
   for (coin in coins) {
+    // ! No.of ways => Borrow from previous indices and add-up
     // ! Forward iteration as we allow the same coin to be used multiple times
-    for (i in coin..amount) {
-      dp[i] += dp[i - coin]
+    for (amount in coin..targetAmount) {
+      dp[amount] += dp[amount - coin]
     }
   }
-  return dp[amount]
+  return dp[targetAmount]
 }
 
 fun main() {

ds-algo/src/main/kotlin/leetcode/dp/CombinationSum/CombinationSum.kt renamed to ds-algo/src/main/kotlin/leetcode/dp/CombinationSum.kt

@@ -1,5 +1,5 @@
 /* gakshintala created on 12/7/19 */
-package leetcode.dp.CombinationSum
+package leetcode.dp
 
 /** https://leetcode.com/problems/combination-sum/ */
 fun combinationSumDP(coins: IntArray, target: Int): Set<List<Int>> {

ds-algo/src/main/kotlin/leetcode/dp/CombinationSum/CombinationSum2.kt renamed to ds-algo/src/main/kotlin/leetcode/dp/CombinationSum2.kt

@@ -1,5 +1,5 @@
 /* gakshintala created on 12/7/19 */
-package leetcode.dp.CombinationSum
+package leetcode.dp
 
 /** [40. Combination Sum II](https://leetcode.com/problems/combination-sum-ii/) */
 fun combinationSum(arr: IntArray, targetSum: Int): List<IntArray> =

ds-algo/src/main/kotlin/leetcode/dp/HouseRobber.kt

@@ -1,14 +1,45 @@
 package leetcode.dp
 
 /** [198. House Robber](https://leetcode.com/problems/house-robber) */
-fun rob1(nums: IntArray): Int {
-  var cur = 0
+fun robBottomUp(nums: IntArray): Int {
+  if (nums.size == 1) {
+    return nums[0]
+  }
+  val dp = IntArray(nums.size) { -1 }
+  dp[0] = nums[0]
+  dp[1] = maxOf(nums[0], nums[1])
+  for (i in 2..nums.lastIndex) {
+    dp[i] = maxOf(dp[i-1], nums[i] + dp[i - 2])
+  }
+  return dp.last();
+}
+
+fun robTopDown(nums: IntArray, idx: Int = 0, memo: IntArray = IntArray(nums.size) { -1 }): Int =
+  when {
+    idx >= nums.lastIndex + 1 -> 0
+    memo[idx] != -1 -> memo[idx]
+    else -> {
+      val include = nums[idx] + robTopDown(nums, idx + 2, memo)
+      val exclude = robTopDown(nums, idx + 1, memo)
+      maxOf(include, exclude).also { memo[idx] = it }
+    }
+  }
+
+fun rob(nums: IntArray): Int {
   var prev = 0
+  var prevPrev = 0
   for (num in nums) {
-    val tmp = cur
-    cur = maxOf(cur, num + prev)
-    prev = tmp
+    val tmp = prev
+    prev = maxOf(prev, num + prevPrev)
+    prevPrev = tmp
   }
+  return prev
+}
 
-  return cur
+fun main() {
+  println(robBottomUp(intArrayOf(1, 2, 3, 1))) // 4
+  println(robBottomUp(intArrayOf(2,7,9,3,1))) // 12
+  
+  println(robTopDown(intArrayOf(1, 2, 3, 1))) // 4
+  println(robTopDown(intArrayOf(2,7,9,3,1))) // 12
 }

ds-algo/src/main/kotlin/leetcode/dp/HouseRobber2.kt

@@ -9,12 +9,12 @@ fun rob2(nums: IntArray): Int {
 }
 
 private fun robUtil(nums: List<Int>): Int {
-  var cur = 0
   var prev = 0
+  var prevPrev = 0
   for (num in nums) {
-    val tmp = cur
-    cur = maxOf(cur, num + prev)
-    prev = tmp
+    val tmp = prev
+    prev = maxOf(prev, num + prevPrev)
+    prevPrev = tmp
   }
-  return cur
+  return prev
 }

ds-algo/src/main/kotlin/leetcode/dp/UniqueBSTs.kt

@@ -9,7 +9,7 @@ fun numTrees(n: Int): Int {
     // Only `nodeCount - 1` elements are shuffled both sides `(it - 1) + (nodeCount - it)`. The
     // missing one is for root.
     // Increasing left side * Decreasing right side
-    table[nodeCount] = (1..nodeCount).map { table[it - 1] * table[nodeCount - it] }.sum()
+    table[nodeCount] = (1..nodeCount).sumOf { table[it - 1] * table[nodeCount - it] }
   }
   return table[n]
 }