LeetCode 518. Coin Change 2

问题描述

• 地址

地址分析

• 类似于 LeetCode 322. Coin Change , 322是求所有可能性中的最少硬币数，是一个最优子结构问题。而该题是统计所有可能性(方法)的个数，至于LeetCode 39. Combination Sum ,则是枚举出所有的可能性的具体情况。
• 同样是一个完全背包问题（i位置元素要还是不要的问题），有两种思路：
  
  • dp[i][j] 表示 ：coins[0~i]中加出j，有多少种方法
  • dp[i][j] 表示 ：用coins的前i个元素，加出j有多少种方法

经验教训

• 状态定义的意义不同，具体解法也不同，该题中用dp[i][j] 表示 ：用coins的前i个元素，加出j有多少种方法更为简便

代码实现

• 递归

    public int change(int amount, int[] coins) {
        if (amount < 0 || coins == null ) {
            return 0;
        }
        return getNum(coins, coins.length - 1, amount);
    }

    public int getNum(int[] coins, int i, int remain) {
        if (remain <= 0 || i < 0) {
            if (remain == 0) {
                return 1;
            }
            return 0;
        }
        return getNum(coins, i - 1, remain) + getNum(coins, i, remain - coins[i]);
    }

• 动态规划

    public int change(int amount, int[] coins) {
        if (amount < 0 || coins == null  || coins.length == 0) {
           return amount == 0 ? 1 : 0;
        }
        //dp[i][j]: [0~i]中加出j，有多少种方法
        int[][] dp = new int[coins.length][amount + 1];
        dp[0][0] = 1;
        for (int j = 1; j < amount + 1; ++j) {
            dp[0][j] = j % coins[0] == 0 ? 1 : 0;
        }
        for (int i = 1; i < coins.length; ++i) {
            dp[i][0] = 1;
            for (int j = 1; j < amount + 1; ++j) {
                dp[i][j] = dp[i - 1][j] + (j - coins[i] >= 0 ? dp[i][j - coins[i]] : 0);
            }
        }
        return dp[coins.length - 1][amount];
    }

• 动态规划优化空间

    public int change(int amount, int[] coins) {
        if (amount < 0 || coins == null  || coins.length == 0) {
           return amount == 0 ? 1 : 0;
        }
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int j = 1; j < amount + 1; ++j) {
            dp[j] = j % coins[0] == 0 ? 1 : 0;
        }
        for (int i = 1; i < coins.length; ++i) {
            for (int j = coins[i]; j < amount + 1; ++j) {
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }

• 第二种动态规划

    public int change(int amount, int[] coins) {
        //dp[i][j]: 用coins的前i个元素，加出j有多少种方法
        int[][] dp = new int[coins.length + 1][amount + 1];
        dp[0][0] = 1;
        for (int i = 1; i < coins.length + 1; ++i) {
            dp[i][0] = 1;
            for (int j = 1; j < amount + 1; ++j) {
                dp[i][j] = dp[i - 1][j] + (j - coins[i - 1] >= 0 ? dp[i][j - coins[i - 1]] : 0);
            }
        }
        return dp[coins.length][amount];
    }

• 第二种动态规划优化空间

    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];
        dp[0] = 1;
        for (int i = 1; i < coins.length + 1; ++i) {
            for (int j = coins[i - 1]; j < amount + 1; ++j) {
                dp[j] += dp[j - coins[i - 1]];
            }
        }
        return dp[amount];
    }