力扣322题，零钱兑换_力扣钱币问题

力扣322题，零钱兑换

题目描述

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

输入输出样例

输入：coins = [1, 2, 5], amount = 11
输出：3 
解释：11 = 5 + 5 + 1
1
2
3

输入：coins = [2], amount = 3
输出：-1
1
2

输入：coins = [1], amount = 0
输出：0
1
2

解法一：使用递归

class Solution {
public:

//定义最少的次数
//使用递归进行完成
int res=INT_MAX;
    int coinChange(vector<int>& coins, int amount) {
        if(coins.empty())
        {
            return -1;
        }

        findWay(coins,amount,0);
        //判断次数的值是否发生改变
        if(res==INT_MAX)
        {
            return -1;
        }
        return res;
    }

    void findWay(vector<int>&coins,int amount,int count)
    {
        //定义递归终止条件
        if(amount<0)
        {
            return;
        }
        if(amount==0)
        {
            res=min(res,count);
        }

        //再次递归进行计算
        for(int i=0;i<coins.size();i++)
        {
            findWay(coins,amount-coins[i],count+1);
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

解法二，使用记忆化搜索

class Solution2 {
public:

//使用记忆化搜索
//memo数组表示钱币n可能被换取的最少的硬币数，不能换取则为-1
//这也是一种递归的遍历方法，但只遍历能去到的位置

    int coinChange(vector<int>& coins, int amount) {
        if(coins.empty())
        {
            return -1;
        }
        vector<int>memo(amount);
        int num= findWay(coins,amount,memo);
        return num;


    }
    int findWay(vector<int>coins,int amount,vector<int>&memo)
    {
        if(amount<0)
        {
            return -1;
        }
        if(amount==0)
        {
            return 0;
        }


        //使用记忆化处理，memo[n]若被赋予了值，则不需接下来的循环
        //直接返回memo[n]中的最优解
        //memo是维护了到每一个值所需要的最小可能
        if(memo[amount-1]!=0)
        {
            return memo[amount-1];
        }

        int min=INT_MAX;

        for(int i=0;i<coins.size();i++)
        {
            int res=findWay(coins,amount-coins[i],memo);

            if(res>=0&&res<min)
            {
                //兑换一个硬币，因为其已经执行了上一步
                min=res+1;
            }
        }
        memo[amount-1]=(min==INT_MAX?-1:min);
        return memo[amount-1];

    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

解法三，使用动态规划

class Solution3 {
public:

//使用自底向下的动态规划思想
    int coinChange(vector<int>& coins, int amount) {
        if(coins.empty())
        {
            return -1;
        }
        
        //memo 表示凑成金额为n所需要的最小的硬币个数
        vector<int>memo(amount+1);
        memo[0]=0;

        for(int i=1;i<=amount;i++)
        {
            int min=INT_MAX;
            for(int j=0;j<coins.size();j++)
            {
                if(i-coins[j]>=0&&memo[i-coins[j]]<min)
                {
                    //动态转移方程的表达式
                    //是最小的数的累加上去的
                    min=memo[i-coins[j]]+1;
                }
            }
            memo[i]=min;
        }
        return memo[amount]==INT_MAX?-1:memo[amount];

    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

解法四，使用动态规划2

class Solution4 {
public:

//使用自底向下的动态规划思想2
    int coinChange(vector<int>& coins, int amount) {
        if(coins.empty())
        {
            return -1;
        }
                //memo 表示凑成金额为n所需要的最小的硬币个数,初始化的值全部用面值为1的硬币填充
        vector<int>memo(amount+1,amount+1);

        memo[0]=0;

        for(int i=1;i<=amount;i++)
        {
            for(int j=0;j<coins.size();j++)
            {
                if(i-coins[j]>=0)
                {
                    //memo具有两种形态
                    //一种是包含当前的coins[i]，则剩余的钱为i-coins[j]，其硬币数需要+1
                    //另一种是不包含当前的coins的值
                    memo[i]=min(memo[i],memo[i-coins[j]]+1);
                }
            }
        }
        return memo[amount]==(amount+1)?-1:memo[amount];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31