需要注意当总金额j = 0时，认为只有一种组合方式：什么也不选。

代码实现：二维dp

class Solution {
    public int change(int amount, int[] coins) {
        int n = coins.length;

        // dp[i][j]: 从下标小于i的硬币面额中选择，恰好凑够总金额j的组合数
        int dp[][] = new int[n][amount+1];

        // 初始化第一行：只用面额为coins[0]的硬币来凑
        dp[0][0] = 1; // 总金额为0时只有一种组合方式：什么也不选
        for(int j = 1; j <= amount; j++) {
            if(j < coins[0]){
                // 总金额j小于coins[0] => 不能凑成总金额j
                dp[0][j] = 0;
            }else{
                // 总金额j大于等于coins[0] => 如果减去当前面额后的总金额j-coins[0]不能正好凑齐，那么总金额j也无法正好凑齐；否则，先凑够j-coins[0]后再加上当前硬币面额即可，总组合数等于dp[0][j-coins[0]]
                dp[0][j] = (dp[0][j-coins[0]] == 0 ? 0 : dp[0][j-coins[0]]);
            }
        }

        // 初始化第一列：凑成总金额0 => 只有一种组合方式：什么也不选
        // dp[0][0]已经在前面初始化过了
        for(int i = 1; i < n; i++){
            dp[i][0] = 1;
        }

        // 递推计算
        for(int i = 1; i < n; i++){
            for(int j = 1; j <= amount; j++){
                if(j < coins[i]){
                    // 总金额j小于coins[i] => 不能选择coins[i]
                    dp[i][j] = dp[i-1][j];
                }else{
                    // 总金额j大于等于coins[i] => 可以选择coins[i]，也可以不选择coins[i]，两种加起来为总组合数
                    dp[i][j] = dp[i-1][j] 
                             + (dp[i][j-coins[i]] == 0 ? 0 : dp[i][j-coins[i]]);
                }
            }
        }

        // 返回结果
        return dp[n-1][amount];
    }
}

代码实现：一维dp

class Solution {
    public int change(int amount, int[] coins) {
        int n = coins.length;

        // dp[j]: 恰好凑够总金额j的组合数
        int dp[] = new int[amount+1];

        // 初始化第一行：只用面额为coins[0]的硬币来凑
        dp[0] = 1; // 总金额为0时只有一种组合方式：什么也不选
        for(int j = 1; j <= amount; j++) {
            if(j < coins[0]){
                // 总金额j小于coins[0] => 不能凑成总金额j
                dp[j] = 0;
            }else{
                // 总金额j大于等于coins[0] => 如果减去当前面额后的总金额j-coins[0]不能正好凑齐，那么总金额j也无法正好凑齐；否则，先凑够j-coins[0]后再加上当前硬币面额即可，总组合数等于dp[j-coins[0]]
                dp[j] = (dp[j-coins[0]] == 0 ? 0 : dp[j-coins[0]]);
            }
        }

        // 递推计算
        for(int i = 1; i < n; i++){
            dp[0] = 1; // 初始化原二维dp中的第一列
            for(int j = 1; j <= amount; j++){
                // if(j < coins[i]){
                //     // 总金额j小于coins[i] => 不能选择coins[i]
                //     dp[j] = dp[j]; // 什么也没做
                // }else{
                //     // 总金额j大于等于coins[i] => 可以选择coins[i]，也可以不选择coins[i]，两种加起来为总组合数
                //     dp[j] = dp[j] + (dp[j-coins[i]] == 0 ? 0 : dp[j-coins[i]]);
                // }
                if(j >= coins[i]){
                    dp[j] = dp[j] + (dp[j-coins[i]] == 0 ? 0 : dp[j-coins[i]]);
                }
            }
        }

        // 返回结果
        return dp[amount];
    }
}

我觉得这道题实际上是爬楼梯的进阶版，不属于完全背包问题。

因为这道题中是要考虑选择的顺序的，(2, 1, 1)和(1, 1, 2)就是两个不同的可行解；而背包问题是不考虑顺序的，在背包问题中认为先选择1还是先选择2都是一样的，比如上一道题518. 零钱兑换 Ⅱ就是一个典型的完全背包问题。

而在爬楼梯问题中，把整个过程看作是一系列的决策过程，而在计算dp[i]时主要考虑的是：在本轮有哪几种选择？

对应到该问题中，就是：将整个过程看作是从nums数组中依次选择数字的过程，每次只能选一个数字，数字可以重复且考虑顺序，问选出的一组数字的总和正好为target的取数方式有几种？

• dp[i]：从nums中每次选择一个数字（可以重复，考虑顺序），使得总和为i，共有几种选择
• 在计算dp[i]时：考虑在本轮有哪几种选择？（n种）
  • 共n种选择，对于每一个nums[j],(0<=j<n)：如果nums[j] <= i，则可以先选出总和为i-nums[j]的一组数，然后在本轮选择nums[j]
  • 对所有情况求和得到本轮的总选择数
• 递推公式：$$dp[i]=\sum _{j=0}^{n-1}\left\{\begin{array}{cc}nums[j]<=i:& dp[j-dp[i]]\\ nums[j]>i:& 0\end{array}\right\}$$
• 计算顺序：在计算dp[i]时可能会用到dp[0...i-1]，因此从前向后计算（i = 0 -> target）即可
• 初始化：dp[0]的含义是 “从nums中每次选择一个数字（可以重复，考虑顺序），使得总和为0，共有几种选择”，答案是只有一种选择——什么也不选，因此dp[0] = 1;

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int n = nums.length;

        // dp[i]: 从nums中每次选择一个数字（可以重复，考虑顺序），使得总和为i，共有几种选择
        int[] dp = new int[target+1];

        // 初始化: 总和为0只有1种选择 => 什么也不选
        dp[0] = 1; 
        
        // 递推计算
        for(int i = 1; i <= target; i++){
            dp[i] = 0;
            for(int j = 0; j < n; j++){
                dp[i] += (nums[j] <= i ? dp[i-nums[j]] : 0);
            }
        }
        
        // 返回结果
        return dp[target];
    }
}

如果用-1来表示不能凑成总金额，会导致dp[]数组中元素的含义不统一，正好题目又要求要求最小值，这样的话在讨论的时候需要对-1的情况进行单独讨论，逻辑有点啰嗦。

代码实现

class Solution {
    public int coinChange(int[] coins, int amount) {
        int n = coins.length;

        // dp[i][j]: 从下标小于i的硬币面额中选择，恰好凑够总金额j所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，则为-1 。
        int[][] dp = new int[n][amount+1];

        // 初始化第一行：用面额为coins[0]的硬币凑成总金额j
        dp[0][0] = 0; // 总金额为0时只有一种组合方式：什么也不选，此时所需的最小硬币数为0
        for(int j = 1; j <= amount; j++){
            if(j < coins[0]){
                // 总金额j小于coins[0] => 不能凑成总金额j
                dp[0][j] = -1;
            }else{
                // 总金额j大于等于coins[0] => 如果减去当前面额后的总金额j-coins[0]不能正好凑齐，那么总金额j也无法正好凑齐；否则，先凑够j-coins[0]后再加上当前硬币面额即可，所需的最少硬币数等于dp[0][j-coins[0]]+1
                dp[0][j] = (dp[0][j-coins[0]] == -1 ? -1 : dp[0][j-coins[0]]+1);
            }
        } 

        // 初始化第一列：凑成总金额0 => 只有一种组合方式：什么也不选，此时所需的最小硬币数为0
        // dp[0][0]已经在前面初始化过了
        for(int i = 1; i < n; i++){
            dp[i][0] = 0;
        }

        // 递推计算
        for(int i = 1; i < n; i++){
            for(int j = 1; j <= amount; j++){
                if(j < coins[i]){
                    // 总金额j小于coins[i] => 不能选择coins[i]，问题转换为dp[i-1][j]
                    dp[i][j] = dp[i-1][j];
                }else{
                    // 总金额j大于等于coins[i] => 可以选择coins[i]，也可以不选择coins[i]，两者取最小
                    // 由于-1具有特殊含义且题目要求是取最小值，此时需要进行分类讨论
                    if(dp[i-1][j] == -1 && dp[i][j-coins[i]] == -1){
                        dp[i][j] = -1; // 如果两种都不能恰好凑成
                    }else if(dp[i-1][j] == -1){
                        // dp[i-1][j] == -1, dp[i][j-coins[i]] != -1
                        dp[i][j] = dp[i][j-coins[i]] + 1;
                    }else if(dp[i][j-coins[i]] == -1){
                        // dp[i-1][j] != -1, dp[i][j-coins[i]] == -1
                        dp[i][j] = dp[i-1][j];
                    }else{
                        dp[i][j] = Math.min(dp[i-1][j], dp[i][j-coins[i]] + 1);
                    }
                }
            }
        }
        
        // 返回结果
        return dp[n-1][amount];
    }
}

该问题可以转换为完全背包问题：

• 共有$\lfloor \sqrt{n}\rfloor$个物品，$1\le n\le \lfloor \sqrt{n}\rfloor$ ，其中第i个物品的重量为 $i^2$
• 背包的最大容量为 $n$
• 求能使背包恰好装满的最少物品数量

该问题问能否用字典worddict中的单词拼出字符串s

可以转换为下面这个问题：

• 有一个字符串集合worddict
• 依次从该字符串集合中选出一系列字符串，每个字符串可以选多次（类似于有放回抽取），将这些字符串按顺序拼接
• 问能否正好拼出字符串s

由于该问题需要考虑顺序，所以只能按照多阶段决策的思路来思考。

dp[i]：问能否用字典worddict中的单词拼出【字符串s的前i个字符组成的前缀字符串】

在每一次决策中，即在计算dp[i]时：

• 有哪些选择？ 可以选择的单词的下标集合： { k ∣ 单词 w o r d d i c t [ k ] 正好是 d p [ i ] 的后缀子字符串 } \{ k | 单词worddict[k]正好是dp[i]的后缀子字符串 \} {k∣单词worddict[k]正好是dp[i]的后缀子字符串}
  • 如果在本轮决策中选择单词worddict[k]，则能否拼出字符串s取决于dp[i-worddict[k].length]
• 如何做决策？
  • 如果在本轮有某一个选择能够拼出字符串s，本轮的决策结果就为true，其实就是对所有选择的结果做或运算

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        // dp[i]: 问能否用字典worddict中的单词拼出字符串s的前i个字符组成的前缀字符串
        boolean[] dp = new boolean[s.length()+1];

        // 初始化
        dp[0] = true; // 在字典中什么都不选时，正好拼出空字符串

        // 递推计算
        for(int i = 1; i <= s.length(); i++){
            String curStr = s.substring(0, i);
            for(String word : wordDict){
                dp[i] = false;
                if(curStr.endsWith(word) && dp[i-word.length()]){
                    dp[i] = true;
                    break;
                }
            }
        }

        // 返回结果
        return dp[s.length()];
    }
}

碎碎念：事实证明直接用多阶段决策的思路做就OK！