标签：return int res memo coins 零钱 amount 动态 规划

遍历N叉树

public void inOrder(Node root) {
    if(root == null) {
        return;
    }
    res.add(root.val);
    int s = root.children.size();
    for(int i = 0; i < s; i++) {
        inOrder(root.children.get(i));
    }
}

暴力解法

int res = Integer.MAX_VALUE;
public int coinChange(int[] coins, int amount) {
    if(coins.length == 0){
        return -1;
    }

    findWay(coins,amount,0);

    // 如果没有任何一种硬币组合能组成总金额，返回 -1。
    if(res == Integer.MAX_VALUE){
        return -1;
    }
    return res;
}

public void findWay(int[] coins,int amount,int count){
    if(amount < 0){
        return;
    }
    if(amount == 0){
        res = Math.min(res,count);
    }

    for(int i = 0;i < coins.length;i++){
        // amount-coins[i]作为root.children.get(i)
        findWay(coins,amount-coins[i],count+1);
    }
}

优化

int res = Integer.MAX_VALUE;
//+++++++++
int[] memo;
public int coinChange(int[] coins, int amount) {
    if(coins.length == 0){
        return -1;
    }
    //++++++++
    memo = new int[amount];

    return findWay(coins,amount);
}
// memo[n] 表示钱币n可以被换取的最少的硬币数，不能换取就为-1
// findWay函数的目的是为了找到 amount数量的零钱可以兑换的最少硬币数量，返回其值int
public int findWay(int[] coins,int amount){
    if(amount < 0){
        return -1;
    }
    if(amount == 0){
        return 0;
    }
    // 记忆化的处理，memo[n]用赋予了值，就不用继续下面的循环
    // 直接的返回memo[n] 的最优值
    //+++++++++++++++
    if(memo[amount-1] != 0){
        return memo[amount-1];
    }
    int min = Integer.MAX_VALUE;
    for(int i = 0;i < coins.length;i++){
        int res = findWay(coins,amount-coins[i]);
        //++++++++++++++++
        if(res >= 0 && res < min){
            min = res + 1; // 加1，是为了加上得到res结果的那个步骤中，兑换的一个硬币
        }
    }
    //+++++++++++++++++
    memo[amount-1] = (min == Integer.MAX_VALUE ? -1 : min);
    return memo[amount-1];
}

使用迭代

 public int coinChange(int[] coins, int amount) {
    // 自底向上的动态规划
    if(coins.length == 0){
        return -1;
    }

    // memo[n]的值： 表示的凑成总金额为n所需的最少的硬币个数
    int[] memo = new int[amount+1];
    memo[0] = 0;
    for(int i = 1; i <= amount;i++){
        int min = Integer.MAX_VALUE;
        for(int j = 0;j < coins.length;j++){
            if(i - coins[j] >= 0 && memo[i-coins[j]] < min){
                min = memo[i-coins[j]] + 1;
            }
        }
        // memo[i] = (min == Integer.MAX_VALUE ? Integer.MAX_VALUE : min);
        memo[i] = min;
    }

    return memo[amount] == Integer.MAX_VALUE ? -1 : memo[amount];
}

memo[i] 有两种实现的方式，去两者的最小值

• 包含当前的 coins[i]，那么剩余钱就是 i−coins[i]，这种操作要兑换的硬币数是 memo[i−coins[j]]+1

• 不包含，要兑换的硬币数是 memo[i]

public int coinChange(int[] coins, int amount) {
    // 自底向上的动态规划
    if(coins.length == 0){
        return -1;
    }

    // memo[n]的值： 表示的凑成总金额为n所需的最少的硬币个数
    int[] memo = new int[amount+1];
    // 给memo赋初值，最多的硬币数就是全部使用面值1的硬币进行换
    // amount + 1 是不可能达到的换取数量，于是使用其进行填充
    Arrays.fill(memo,amount+1);
    memo[0] = 0;
    for(int i = 1; i <= amount;i++){
        for(int j = 0;j < coins.length;j++){
            if(i - coins[j] >= 0){
                // memo[i]有两种实现的方式，
                // 一种是包含当前的coins[i],那么剩余钱就是 i-coins[i],这种操作要兑换的硬币数是 memo[i-coins[j]] + 1
                // 另一种就是不包含，要兑换的硬币数是memo[i]
                memo[i] = Math.min(memo[i],memo[i-coins[j]] + 1);
            }
        }
    }

    return memo[amount] == (amount+1) ? -1 : memo[amount];
}

标签：return,int,res,memo,coins,零钱,amount,动态,规划
来源： https://www.cnblogs.com/ycoder/p/14226341.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。