Leetcode 面试题 08.11. 硬币【动态规划&回溯法（超时）】

问题描述

硬币。给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算 n 分有几种表示法。（结果可能很大，你需要将结果模上1000000007）

解题报告

回溯法[TLE]

这题和 Leetcode 39.组合总数题意相同，只是求解的内容不一样。
解释见：Leetcode. 组合总和【回溯法+人为定义子集顺序】

动态规划

很明显用 动态规划 解决这类问题
设 $dp[i]$ 表示硬币 $i$ 共有多少种表达方式，所以$dp[i]={\sum }_{j=0}^{coins.size()}dp[i-coins[j]]$
由此，我们可以很容易的写出代码

class Solution {
public:
    int waysToChange(int n) {
        vector<int>dp(n+1,0);
        int coins[4]={1,5,10,25};
        dp[0]=1;
        for(int i=1;i<=n;i++){
            for(int j=0;j<4;j++){
                if(i>=coins[j]){
                    dp[i]=(dp[i]+dp[i-coins[j]])%1000000007;
                }
            }
        }
        return dp[n];
    }
};

但其实这个代码是错误的，因为硬币可以重复使用，但是相同的币值是不加以区分的，而这种方法会得到[1,1,5]和[1,5,1]这样的伪答案。所以我们需要人为定好构成硬币 n 的各个子硬币的大小关系。

分析：
比如 dp[i] 用币值为1的硬币，那么对应这条路上dp[i-1] 只能用币值为1的硬币，一直进行下去。
如果 dp[i] 用币值为 10 的硬币，那么对应这条路上 dp[i-10] 只能用币值为10、5、1 的硬币。

解决方式
为了实现这种效果，我们将各种币值放在外循环上，则 i =0 时，代表当前所有硬币 j 的组成都走的是 dp[j-coins[0]] 这条路，而此时，所有其他的硬币的组成方式中是无法使用其他币值的【尚未循环到其他币值】；当 i=1 时，当前当前所有硬币的组成都走的是 dp[j-coins[1]] 这条路，此时，所有其他小于币值j的硬币的组成方式也只用到 coins[0]、coins[1] 这两种币值，所以组成硬币 j 的币值中不会有超过币值 coins[1] 的，后面类推。

实现代码

回溯法

class Solution {
public:
    int waysToChange(int n) {
        int ans=0;
        vector<int>candidates={1,5,10,25};
        // sort(candidates.begin(), candidates.end());
        vector<int>cur;
        dfs(ans, candidates, n, n,cur);
        return ans;
    }
    void dfs(int &ans, vector<int>& candidates, int target, int left,vector<int>&cur){
        if(left==0) ans=(ans+1)%1000000007;
        else{
            for(int i=0;i<candidates.size();i++){
                if(candidates[i]>left)
                    break;
                else if(cur.size()==0||candidates[i]>=cur.back()){
                    cur.push_back(candidates[i]);
                    dfs(ans, candidates, target, left-candidates[i], cur);
                    cur.pop_back();
                }
            }
        }
    }
};

class Solution {
public:
    int waysToChange(int n) {
        int ans=0;
        vector<int>candidates={1,5,10,25};
        dfs(ans, 0, candidates, n);
        return ans;
    }
    void dfs(int &ans, int begin, vector<int>& candidates, int left){
        if(left==0) ans=(ans+1)%1000000007;
        else{
            for(int i=begin;i<4;i++){
                if(candidates[i]>left) break;
                dfs(ans, i, candidates, left-candidates[i]);
            }
        }
    }
};

第一个代码可以过22/30个样例，第二个代码可以过28/30个样例。

动态规划实现

class Solution {
public:
    int waysToChange(int n) {
        vector<int>dp(n+1,0);
        int coins[4]={1,5,10,25};
        dp[0]=1;
        for(int i=0;i<4;i++){
            for(int j=coins[i];j<=n;j++){
                dp[j]=(dp[j]+dp[j-coins[i]])%1000000007;
            }
        }
        return dp[n];
    }
};

参考资料

[1] Leetcode 面试题 08.11. 硬币
[2] Leetcode. 组合总和【回溯法+人为定义子集顺序】