LeetCode | 518. Coin Change II, 377. Combination Sum IV

518. Coin Change II

Link: https://leetcode.com/problems/coin-change-ii/

Description

You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.

Return the number of combinations that make up that amount. If that amount of money cannot be made up by any combination of the coins, return 0.

You may assume that you have an infinite number of each kind of coin.

The answer is guaranteed to fit into a signed 32-bit integer.

Approach

• Initialize a dp array with size amount+ 1 to keep track of the number of possible combinations for each possible sum.
• Initialize dp[0] to 1.
• Loop through each coin in the coins array.
  • For each coin value coins[i], iterate through the dp array from coins[i] to amount:
    • Update dp[j] by adding the value of dp[j - coins[i]] to it.

Solution

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int i = 0; i < coins.length; i++)
            for (int j = coins[i]; j <= amount; j++)
                dp[j] += dp[j - coins[i]];
        
        return dp[amount];
    }
}

377. Combination Sum IV

Link: https://leetcode.com/problems/combination-sum-iv/

Description

Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target.

The test cases are generated so that the answer can fit in a 32-bit integer.

Approach

• Initialize a dp array with size target + 1 to keep track of the number of possible combinations for each possible sum.
• Initialize dp[0] to 1.
• Loop through each sum value from 1 to target:
  • If i - nums[j] >= 0, update dp[i] by adding the value of dp[i - nums[j]] to it.

Solution

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target + 1];
        dp[0] = 1;
        for (int i = 0; i <= target; i++) {
            for (int j = 0; j < nums.length; j++) {
                if (i - nums[j] >= 0)
                    dp[i] += dp[i - nums[j]];
            }
        }
        return dp[target];
    }
}