fix: MinCoinCombinationBottomUp and MinCoinCombinationTopDown back to using Integer.MAX_VALUE to fill the dp array for consistent with python solution

Author: Jer3myYu

java/Dynamic Programming/MinCoinCombinationBottomUp.java

@@ -4,19 +4,18 @@ public class MinCoinCombinationBottomUp {
     public int minCoinCombinationBottomUp(int[] coins, int target) {
         // The DP array will store the minimum number of coins needed for 
         // each amount. Set each element to a large number initially.
-        int max = target + 1;
         int[] dp = new int[target + 1];
-        Arrays.fill(dp, max);
+        Arrays.fill(dp, Integer.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 (int t = 1; t < target + 1; t++) {
             for (int coin : coins) {
-                if (coin <= t) {
+                if (coin <= t && dp[t - coin]!= Integer.MAX_VALUE) {
                     dp[t] = Math.min(dp[t], 1 + dp[t - coin]);
                 }
             }
         }
-        return dp[target] != max ? dp[target] : -1;
+        return dp[target] != Integer.MAX_VALUE ? dp[target] : -1;
     }
 }

java/Dynamic Programming/MinCoinCombinationTopDown.java

@@ -2,12 +2,9 @@
 import java.util.Map;
 
 public class MinCoinCombinationTopDown {
-    int max;
-
     public int minCoinCombinationTopDown(int[] coins, int target) {
-        max = target + 1;
         int res = topDownDp(coins, target, new HashMap<>());
-        return res == max ? -1 : res;
+        return res == Integer.MAX_VALUE ? -1 : res;
     }
 
     private int topDownDp(int[] coins, int target, Map<Integer, Integer> memo) {
@@ -20,13 +17,16 @@ private int topDownDp(int[] coins, int target, Map<Integer, Integer> memo) {
             return memo.get(target);
         }
         // Initialize 'minCoins' to a large number.
-        int minCoins = max;
+        int minCoins = Integer.MAX_VALUE;
         for (int coin : coins) {
             // Avoid negative targets.
             if (coin <= target) {
                 // Calculate the minimum number of coins needed if we use
                 // the current coin.
-                minCoins = Math.min(minCoins, 1 + topDownDp(coins, target - coin, memo));
+                int result = topDownDp(coins, target - coin, memo);
+                if (result!= Integer.MAX_VALUE) {
+                    minCoins = Math.min(minCoins, 1 + result);
+                }
             }
         }
         memo.put(target, minCoins);