找零钱问题

322. 零钱兑换
518. 零钱兑换 II

//dp
int coinChange_dp(vector<int>& coins,int amount){
    int n = coins.size();
    //dp[i][j] : coins[0..i]元素替换成j的方法种数
    vector<vector<int>> dp(n,vector<int> (amount+1));
    //初始值：只用coins[0]替换 dp[0][j] = j%coins[0]==0 ? 1:0
    for(int j=0;j<=amount;++j){
        dp[0][j] = j%coins[0]==0 ? 1:0;
    }
    for(int i=1;i<n;++i){
        for(int j=0;j<=amount;++j){
            for(int k=0;k*coins[i]<=j;++k){
                dp[i][j] += dp[i-1][j-k*coins[i]];
            }
        }
    }
    return dp[n-1][amount];
}

//dp优化
int coinChange_dp1(vector<int>& coins,int amount){
    int n = coins.size();
    //dp[i][j] : coins[0..i]元素替换成j的方法种数
    vector<vector<int>> dp(n,vector<int> (amount+1,0));
    //初始值：只用coins[0]替换 dp[0][j] = j%coins[0]==0 ? 1:0
    for(int j=0;j<=amount;++j){
        dp[0][j] = j%coins[0]==0 ? 1:0;
    }
    for(int i=1;i<n;++i){
        for(int j=0;j<=amount;++j){
            if(j<coins[i]){
                dp[i][j] = dp[i-1][j];
            }
            else{
                //j>=coins[i]时，dp[i][j]为用coins[0..i-1]凑j + 用coins[0..i]凑j-coins[i]（先用一个coins[i]替换，再用coins[0..i]凑j-coins[i]，有点像递归）
                dp[i][j] = dp[i-1][j] + dp[i][j-coins[i]];
            }
        }
    }
    return dp[n-1][amount];
}

//dp空间优化
int coinChange_dp2(vector<int>& coins,int amount){
    int n = coins.size();
    //dp[i]:用coins[0..n]替换i的方案数
    vector<int> dp(amount+1);
    dp[0] = 1;
    for(int i=0;i<n;++i){
        for(int j=coins[i];j<=amount;++j){
            dp[j] += dp[j-coins[i]];
        }
    }
    return dp[amount];
}

//深搜
int dfs(vector<int>& coins,int amount,int idx){
    int n = coins.size();
    if(amount==0){
        return 1;
    }
    int res = 0; 
    //从idx开始，避免重复
    for(int i=idx;i<n;++i){
        if(amount>=coins[i]){  //只要当前元素可选就选
            res+=dfs(coins,amount-coins[i],i);
        }
    }
    return res;
}

//递归
int dfs1(vector<int>& coins,int amount,int idx){
    int n = coins.size();
    if(idx==n){
        return amount==0 ? 1:0;
    }
    int res = 0; 
    //在不超过amount的情况下，每次由前一种面值的coin增加导致的金额变化，都递归查找后面面值种类组成的可能解
    for(int i=0;i*coins[idx]<=amount;++i){
        res+=dfs1(coins,amount-i*coins[idx],idx+1);
    }
    return res;
} 

//记忆化递归 ：由于每次递归查找的是当前coin元素增加导致amount变化时，后面的元素组成新amount的可能解，
// 故可在递归过程中记录当前元素的下标以及当前元素增加导致的新amount，表示对于此新amount，后面的元素可组成的解的数量
// 之后再搜索到此元素且产生同样的amount时，可直接使用
// 如coins={1,2,5} num表示每个元素使用的数量，搜索到num={0,2,0}时,记录idx=1,amount=1,之后再搜索num={2,1,0}
// 时可直接跳过
unordered_map<string,int> mp;
int dfs2(vector<int>& coins,int amount,int idx){
    int n = coins.size();
    string key = to_string(idx)+"_"+to_string(amount);
    if(mp.find(key)!=mp.end()){
        return mp[key];
    }
    if(idx==n){
        return amount==0 ? 1:0;
    }
    int res = 0; 
    //在不超过amount的情况下，每次由前一种面值的coin增加导致的金额变化，都递归查找后面面值种类组成的可能解
    for(int i=0;i*coins[idx]<=amount;++i){
        res+=dfs2(coins,amount-i*coins[idx],idx+1);
    }
    //从当前{idx,amount}搜索完后将其结果记录
    mp[key] = res;
    return res;
}

int main(){
    vector<int> coins = {1,1,2,3,4,5,5};
    int amount = 5;
    cout<<coinChange_dp1(coins,amount)<<endl;
    cout<<dfs(coins,amount,0)<<endl;
}