Welcome to Subscribe On Youtube
322. Coin Change
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 fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return 1
.
You may assume that you have an infinite number of each kind of coin.
Example 1:
Input: coins = [1,2,5], amount = 11 Output: 3 Explanation: 11 = 5 + 5 + 1
Example 2:
Input: coins = [2], amount = 3 Output: 1
Example 3:
Input: coins = [1], amount = 0 Output: 0
Constraints:
1 <= coins.length <= 12
1 <= coins[i] <= 2^{31}  1
0 <= amount <= 10^{4}
Solutions
We maintain a onedimensional dynamic array dp, where dp[i]
represents the change of the smallest number of coins when the amount of money is i. Note that since the array starts from 0, one more bit must be applied. The size of the array is amount +1
, so the final result can be saved in dp[amount]
.
Initialize dp[0] = 0
, because if the target value is 0, no coins are needed. Other values can be initialized as amount+1
, why? Because the smallest coin is 1, so amount requires at most amount
coins, and amount+1
is equivalent to the current maximum.
 Note that the integer maximum value cannot be used for initialization here, because there is an operation of adding 1 to the subsequent state transition equation, which may cause overflow.
The next step is to find the state transition equation. Example 1, suppose I take a coin with a value of 5, then since the target value is 11, so if we know dp[6], then we know the dp of 11 Worth it?
So the way to update dp[i] is to traverse each coin. If the value of the traversed coin is less than the value of i (for example, a coin with a value of 5 cannot be used to update dp[3]), use dp[icoins[j ]] + 1
to update dp[i]
, so the state transition equation is:
dp[i] = min(dp[i], dp[icoins[j]] + 1);
among them
coins[j]
is the jth coinicoins[j]
is the amount of money i minus the value of one of the coins, the remaining amount of money is found in the dp array
Then add 1 and compare the value in the current dp array, and update the dp array with the smaller one.

class Solution { public int coinChange(int[] coins, int amount) { final int inf = 1 << 30; int n = amount; int[] f = new int[n + 1]; Arrays.fill(f, inf); f[0] = 0; for (int x : coins) { for (int j = x; j <= n; ++j) { f[j] = Math.min(f[j], f[j  x] + 1); } } return f[n] >= inf ? 1 : f[n]; } }

class Solution { public: int coinChange(vector<int>& coins, int amount) { int n = amount; int f[n + 1]; memset(f, 0x3f, sizeof(f)); f[0] = 0; for (int x : coins) { for (int j = x; j <= n; ++j) { f[j] = min(f[j], f[j  x] + 1); } } return f[n] > n ? 1 : f[n]; } };

''' >>> float("inf") inf >>> float("inf") + 1 inf ''' class Solution(object): def coinChange(self, coins, amount): """ :type coins: List[int] :type amount: int :rtype: int """ dp = [float("inf")] * (amount + 1) dp[0] = 0 for i in range(1, amount + 1): for coin in coins: if i  coin >= 0: dp[i] = min(dp[i], dp[i  coin] + 1) return dp[1] if dp[1] != float("inf") else 1 ############ class Solution: def coinChange(self, coins: List[int], amount: int) > int: dp = [amount + 1] * (amount + 1) dp[0] = 0 for coin in coins: for j in range(coin, amount + 1): dp[j] = min(dp[j], dp[j  coin] + 1) return 1 if dp[1] > amount else dp[1]

func coinChange(coins []int, amount int) int { n := amount f := make([]int, n+1) for i := range f { f[i] = 1 << 30 } f[0] = 0 for _, x := range coins { for j := x; j <= n; j++ { f[j] = min(f[j], f[jx]+1) } } if f[n] > n { return 1 } return f[n] }

function coinChange(coins: number[], amount: number): number { const n = amount; const f: number[] = Array(n + 1).fill(1 << 30); f[0] = 0; for (const x of coins) { for (let j = x; j <= n; ++j) { f[j] = Math.min(f[j], f[j  x] + 1); } } return f[n] > n ? 1 : f[n]; }

/** * @param {number[]} coins * @param {number} amount * @return {number} */ var coinChange = function (coins, amount) { const n = amount; const f = Array(n + 1).fill(1 << 30); f[0] = 0; for (const x of coins) { for (let j = x; j <= n; ++j) { f[j] = Math.min(f[j], f[j  x] + 1); } } return f[n] > n ? 1 : f[n]; };

impl Solution { pub fn coin_change(coins: Vec<i32>, amount: i32) > i32 { let n = amount as usize; let mut f = vec![n + 1; n + 1]; f[0] = 0; for &x in &coins { for j in x as usize..=n { f[j] = f[j].min(f[j  (x as usize)] + 1); } } if f[n] > n { 1 } else { f[n] as i32 } } }