动态规划常见算法（1）

动态规划

爬楼梯

斐波那契数

爬楼梯

这两道都是斐波那契数列

使用最小花费爬楼梯

746. 使用最小花费爬楼梯

• 题目：

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

示例 1：

输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。

• 支付 15 ，向上爬两个台阶，到达楼梯顶部。
  总花费为 15 。

• 定义：dp[i]代表爬到第i个台阶所需最小花费，
• 遍历: dp[i] = min(dp[i - 1] + cost[i - 1] , dp[i - 2] + cost[i-2] ) . return dp[n]

背包类问题

01背包

分割等和子集

力扣题目链接(opens new window)

• 题目: 转换成01背包，数组的值即是重量，也是价值。背包大小为数组总和的一半，求背包能装的最大价值是否为数组总和一半

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200

示例 1:

• 输入: [1, 5, 11, 5]
• 输出: true
• 解释: 数组可以分割成 [1, 5, 5] 和 [11].

示例 2:

• 输入: [1, 2, 3, 5]
• 输出: false
• 解释: 数组不能分割成两个元素和相等的子集.

• 定义：dp[i] [j] 在 (0 ~ i - 1) 件物品， 背包大小为j，能装的最大价值

• 初始化 dp[n + 1] [halfsum + 1] = {0}

• 遍历：注意j的遍历顺序，从后往前，否则前面的物品会被取多次，变成完全背包

for (i = 1; i <= n; ++i) {
    for (j = halfsum; j >= 1; ++j) {
        if (j >= nums[i - 1]) {
            dp[j] = max(dp[j], dp[j - nums[i-1]] + nums[i - 1]);
        }
    }
}

最后一块石头的重量II

力扣题目链接(opens new window)

• 题目：这还是01背包，石头价值和重量，将所有石头重量一半作为背包大小，这样尽可能装多的石头，这样最后：abs(allweight - dp[halfweight] - dp[halfweight])

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；

如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例：

• 输入：[2,7,4,1,8,1]
• 输出：1

解释：

• 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
• 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
• 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
• 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

• 略

目标和

力扣题目链接(opens new window)

• 题目：注意转变思路：一半加+，一半加-，也就是 left + right = sum； left - right = target； left = （sum + target）/ 2。则还是变为01背包，在数组中取一些数，其总和等于left。特别注意，题目要求的是组合数（这里理解就算值相同，下标不同就是不同的数）。

给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例：

• 输入：nums: [1, 1, 1, 1, 1], S: 3
• 输出：5

解释：

• -1+1+1+1+1 = 3
• +1-1+1+1+1 = 3
• +1+1-1+1+1 = 3
• +1+1+1-1+1 = 3
• +1+1+1+1-1 = 3

一共有5种方法让最终目标和为3。

提示：

• 数组非空，且长度不会超过 20 。
• 初始的数组的和不会超过 1000 。
• 保证返回的最终结果能被 32 位整数存下。

• 定义：dp[i] [j] 代表 nums[0 ~ i-1]这些数中，组成和为j的组合数一共有dp[i] [j]种方法
• 初始化：dp[i] [0] = 1; dp[0] [j] = 0; dp[0] [0] = 1;
• 遍历：

for (i = 1; i <=n; ++i) {
	for (j = left; j >= 1; --j) {
        dp[i][j] += dp[i-1][j - nums[i]];
        // 一维：dp[j] += dp[j - nums[i]];
    } 	
}

return dp[left];

一和零

力扣题目链接(opens new window)

• 题目：其实还是01背包，不过这个背包是3维的。第1维度还是物品，2和3维度则是0和1的个数

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

示例 1：

• 输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
• 输出：4
• 解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。 其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

• 定义：dp[a] [b] [c] 代表 在0 ~ a -1 个物品中，最多b个0，c个1，最大子集数量
• 初始化：dp[k] [m] [n] = {0}
• 遍历:注意遍历顺序，m和n是从大到小

for (a = 1; a < k; ++a) {
	for (b = m; b >= 1; ++b) {
		for (c = n; c >= 1; ++c) {
			if (strs[i-1]的0个数 <= b && strs[i-1]的1个数 <= c)
			dp[i][b][c] = max(dp[i][b][c], dp[i-1][b - strs[i-1]的0个数][strs[i-1]的1个数] + 1);
		}
	}
}

• 优化：其实a的那层完全没有必要，可以将最外层去掉，因为都是算完i-1再算i。（由m和n是从大到小 保证，如果不是，则需要添加多一层循环）并且都是先算完小的dp[m] [n]再算大的，所以不用担心覆盖

完全背包

零钱兑换II

力扣题目链接(opens new window)

• 题目："每一种面额的硬币有无限个"就代表完全背包，完全背包与01背包的就是内层遍历背包大小的循环换过来。01：从大到小，完全：从小到大。题目求的是组合数

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

• 输入: amount = 5, coins = [1, 2, 5]
• 输出: 4

解释: 有四种方式可以凑成总金额:

• 5=5
• 5=2+2+1
• 5=2+1+1+1
• 5=1+1+1+1+1

注意，你可以假设：

• 0 <= amount (总金额) <= 5000
• 1 <= coin (硬币面额) <= 5000
• 硬币种类不超过 500 种
• 结果符合 32 位符号整数

• 定义：dp[i] [j] 代表用 0~i-1种硬币，凑成面额为j的组合数
• 初始化dp[i] [j] = 0; dp[0] [0] = 1;
• 遍历

for (i = 1; i <= n; ++i) {
	for (j = 1; j <= amount; ++j) {
		if (coins[i-1] <= j) {
			dp[j] += dp[j-coins[i-1]]; 
		}
	}
}

组合总和 Ⅳ

力扣题目链接(opens new window)

• 题目：完全背包，而且求的是排列数。

给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。

示例:

• nums = [1, 2, 3]
• target = 4

所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1)

请注意，顺序不同的序列被视作不同的组合。

因此输出为 7。

• 定义：dp[i] [j] 从 0到i-1种硬币，组成面额j的排列数
• 初始化：dp[i] [0] = 1, else = 0
• 遍历

对于完全背包“

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

for (j = 1; j <= target; ++j) {
	for (i = 1; i <= n; ++i) {
		if (j >= coins[i - 1]) {
			dp[i][j] += dp[i-1][j-conis[i-1]];
		}
	}
}

return dp[n][target]

爬楼梯（进阶版）

卡码网：57. 爬楼梯(opens new window)

• 题目：1-m个台阶代表物品，目前台阶j代表背包大小，”多少种方法“代表有先后顺序，而且是完全背包，则与上面的 组合求和Ⅳ相同。注意先遍历背包，再遍历物品。

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

输入描述：输入共一行，包含两个正整数，分别表示n, m

输出描述：输出一个整数，表示爬到楼顶的方法数。

输入示例：3 2

输出示例：3

提示：

当 m = 2，n = 3 时，n = 3 这表示一共有三个台阶，m = 2 代表你每次可以爬一个台阶或者两个台阶。

此时你有三种方法可以爬到楼顶。

• 1 阶 + 1 阶 + 1 阶段
• 1 阶 + 2 阶
• 2 阶 + 1 阶

零钱兑换

力扣题目链接(opens new window)

• 题目："每种硬币的数量是无限的"代表完全背包。而且是组合数，从而确定遍历顺序

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

示例 1：

• 输入：coins = [1, 2, 5], amount = 11
• 输出：3
• 解释：11 = 5 + 5 + 1

示例 2：

• 输入：coins = [2], amount = 3
• 输出：-1

示例 3：

• 输入：coins = [1], amount = 0
• 输出：0

• 定义：dp[i] [j] >= 0 代表可以用 0 到 i-1种硬币凑成面额j用的最少硬币数。为INT_MAX则代表不能。
• 初始化：dp[i] [0] 全部为0, 其余都为INT_MAX
• 遍历：求组合，而且完全背包。这道题目要注意：你尽量不用二维矩阵做（下面有做），因为dp[i] [j] 依赖的很复杂他不仅依赖dp[i-1] [j - coin], 而且还依赖最新的 dp[i] [j - coin]，所以你每次都需要新复制上一行，那这样不如用一维的，而且注意背包的遍历顺序，从小到大，因为大的依赖小的。建议与 零钱兑换Ⅱ 对比一下。

for (i = 1; i <= n; ++i) {
	for (j = amount; j >= 0; --j) {
		if (j >= coins[i-1]) {
            dp[i][j] = min(dp[i][j], dp[i-1][j-coins[i-1]]+1);
        }		
	}
}

return dp[n][amount] != INT_MAX ? dp[n][amount] : -1;

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        if (amount == 0) return 0;
        int n = coins.size();
        vector<long long> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = coins[i]; j <= amount; ++j) {
                dp[j] = min(dp[j], dp[j-coins[i]]+1);
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
         
        // 二维
        vector<vector<long long>> dp(n + 1, vector<long long>(amount + 1, INT_MAX));
        for (int j = 1; j <= amount; ++j) dp[0][j] = INT_MAX;   // 没有硬币
        for (int i = 0; i <= n; ++i) dp[i][0] = 0;              // 总额为0
        for (int i = 1; i <= n; ++i) {
            dp[i] = dp[i-1];	// 注意这一行
            for (int j = coins[i-1]; j <= amount; ++j) {
            	dp[i][j] = min({dp[i][j], dp[i][j-coins[i-1]]+1});	
            }
        }
        return dp[n][amount] != INT_MAX ? dp[n][amount] : -1;
        
        
    }
};

完全平方数

力扣题目链接(opens new window)

给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

给你一个整数 n ，返回和为 n 的完全平方数的 最少数量 。

完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

平方数作为物品，先遍历物品，再从小到大遍历背包，就是完全背包，因为每个平方数可以使用多次

class Solution {
public:
    int numSquares(int n) {
        // if (sqrt(n) * sqrt(n) == n) return 1;
        // dp[i]代表和为i的完全平方数的最少数量
        vector<int> dp(n + 1);
        dp[0] = 0;
        for (int i = 1; i <= n; ++i) {
            dp[i] = i;
        }
        for (int i = 1, square = i * i; square <= n; ++i, square = i * i) {
            for (int j = square; j <= n; ++j) {
                if (dp[j - square] + 1 < dp[j]) {
                    dp[j] = dp[j - square] + 1;
                }
            }
        }
        return dp[n];
    }
};