[LeetCode] 377. 组合总和 Ⅳ
[LeetCode] 377. 组合总和 Ⅳ 文章解释[LeetCode] 377. 组合总和 Ⅳ 视频解释
题目：
给你一个由 不同 整数组成的数组
nums，和一个目标整数target。请你从nums中找出并返回总和为target的元素组合的个数。题目数据保证答案符合 32 位整数范围。
示例 1：
输入：nums = [1,2,3], target = 4 输出：7 解释： 所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1) 请注意，顺序不同的序列被视作不同的组合。示例 2：
输入：nums = [9], target = 3 输出：0提示：
1 <= nums.length <= 2001 <= nums[i] <= 1000nums中的所有元素 互不相同1 <= target <= 1000进阶：如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？
[LeetCode] 377. 组合总和 Ⅳ
自己看到题目的第一想法
从一堆数中，找出总和等于或者最接近于总和的数，可以考虑用01背包或者完全背包等背包算法。
这里求的是等于总和的组合个数，因此是背包问题应用到组合或者排列上。对于组合和排列的区别，在于当先便利容量时，dp[j] 是否和低位的 dp[j - weights[i]] 叠加， 有叠加的话就是排列问题，没有的话就是组合问题。（一开始想不明白其中的逻辑，后来画了好几次 dp 的模拟数据，才意识到 dp[i] = dp[i] + dp[i - weights[j]], 比如当前处理的背包容量为3，物品分别取 weights[j] = 1 以及 weights[j] = 2， 那么 dp[3] = dp[3] + dp[3 - 1](这里表示 1 + dp[2] 的组合)， dp[3] = dp[3] + dp[3 - 2](这里表示2+dp[1]的组合)。
看完代码随想录之后的想法
因为之前有零钱组合的问题中踩过坑，所以这里一下子就想起那时候的问题。只要调换一下遍历顺序就行。
class Solution {
public int combinationSum4(int[] nums, int target) {
// dp[j] 表示使用 0～i 个元素，元素和为 j 的组合的个数
int[] dp = new int[target + 1];
dp[0] = 1;
for (int i = 0; i <= target; i++) {
for (int j = 0; j < nums.length; j++) {
if (i < nums[j]) {
continue;
}
dp[i] = dp[i] + dp[i - nums[j]];
}
}
return dp[target];
}
}// 二维数组版本
class Solution {
public int combinationSum4(int[] nums, int target) {
// dp[j] 表示使用 0～i 个元素，元素和为 j 的组合的个数
int[][] dp = new int[nums.length][target + 1];
dp[0][0] = 1;
for (int i = nums[0]; i <= target; i++) {
dp[0][i] = dp[0][i - nums[0]];
}
for (int j = 0; j <= target; j++) {
for (int i = 1; i < nums.length; i++) {
if (nums[i] > j) {
// 当前物品无法放入当前的背包
dp[i][j] = dp[i - 1][j];
continue;
}
// 当前物品可以放入当前的背包
// 这里 j 表示当前的背包的重量，i 表示当前物品最大的索引
// 由于要求排列， 因此需要遍历一下所有的物品，
// 以遍历到的物品为开头，看看以 i 为最大物品索引，j - nums[k] 为背包容量时，一共有多少组合
// (我也是似懂非懂)
for (int k = 0; k <= i; k++) {
if (nums[k] > j) {
continue;
}
dp[i][j] += dp[i][j - nums[k]];
}
}
}
return dp[nums.length - 1][target];
}
}自己实现过程中遇到哪些困难
初始化问题还是比较棘手，需要多次尝试才能找到正确的方式。
二维数组版本给我整懵了！ 完全是模拟了一下 dp 后强行写出来的结果。。。
[KamaCoder] 57. 爬楼梯（第八期模拟笔试） 文章解释
题目描述
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
输入描述
输入共一行，包含两个正整数，分别表示n, m
输出描述
输出一个整数，表示爬到楼顶的方法数。
输入示例
3 2输出示例
3提示信息
数据范围：
1 <= m < n <= 32;当 m = 2，n = 3 时，n = 3 这表示一共有三个台阶，m = 2 代表你每次可以爬一个台阶或者两个台阶。
此时你有三种方法可以爬到楼顶。
- 1 阶 + 1 阶 + 1 阶段
- 1 阶 + 2 阶
- 2 阶 + 1 阶
[KamaCoder] 57. 爬楼梯（第八期模拟笔试）
自己看到题目的第一想法
如果一次可以跨越 m 个楼梯， 对于跨越到楼梯 i 的方式，一共有 dp[i - m] + dp[i - m + 1] ... + dp[i - 1]
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int maxStep = 0;
int maxStairs = 0;
while (scanner.hasNext()) {
String stepAndStairsStr = scanner.nextLine();
String[] stepAndStairs = stepAndStairsStr.split(" ");
maxStairs = Integer.parseInt(stepAndStairs[0]);
maxStep = Integer.parseInt(stepAndStairs[1]);
}
int[] dp = new int[maxStairs + 1];
dp[0] = 1;
for (int i = 1; i <= maxStairs; i++) {
int lowestStair = i - maxStep;
if (lowestStair < 0) {
lowestStair = 0;
}
for (int j = lowestStair; j < i; j++) {
dp[i] += dp[j];
}
}
System.out.println(dp[maxStairs]);
}
}看完代码随想录之后的想法
hhh， 自己的实现是很不动态规划的动态规划～
这一题如果转换一下逻辑，对于第 i 层楼梯，要登上该楼梯，我们每次可以走 1 步、可以走 2 步、可以走 3 步，最多可以走 m 步，请问到达第 i 层楼梯一共有多少种走法。
也就是说， 我们从 1 ～ m 中不断的选出数字， 最终加起来等于 i 的排列有几种。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int maxStep = 0;
int maxStairs = 0;
while (scanner.hasNext()) {
String stepAndStairsStr = scanner.nextLine();
String[] stepAndStairs = stepAndStairsStr.split(" ");
maxStairs = Integer.parseInt(stepAndStairs[0]);
maxStep = Integer.parseInt(stepAndStairs[1]);
}
int[] dp = new int[maxStairs + 1];
dp[0] = 1;
for (int i = 1; i <= maxStairs; i++) {
for (int j = 1; j <= maxStep; j++) {
if (i < j) {
continue;
}
dp[i] += dp[i - j];
}
}
System.out.println(dp[maxStairs]);
}
}自己实现过程中遇到哪些困难
对于需要转化为完全背包的问题，由于当前问题可能并没有 weight 和 value（weight 和 value 的值都是相等的），因此在逻辑上会有点绕不过来。
[LeetCode] 322. 零钱兑换
[LeetCode] 322. 零钱兑换 文章解释题目：
给你一个整数数组
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提示：
1 <= coins.length <= 121 <= coins[i] <= 2^31 - 10 <= amount <= 10^4
[LeetCode] 322. 零钱兑换
自己看到题目的第一想法
从多个数字中选取几个数字， 使这几个数字相加和为 target，数字可以重复选择， 因此是完全背包问题。
看完代码随想录之后的想法
基本上差不多的想法， 初始化的逻辑不太一样。
class Solution {
public int coinChange(int[] coins, int amount) {
int[] dp = new int[amount + 1];
for (int i = 0; i < dp.length; i++) {
dp[i] = -1;
}
dp[0] = 0;
for (int i = 0; i < coins.length; i++) {
for (int j = coins[i]; j <= amount; j++) {
if (dp[j - coins[i]] >= 0) {
if (dp[j] == -1) {
dp[j] = dp[j - coins[i]] + 1;
} else {
dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
}
}
}
}
return dp[amount];
}
}class Solution {
public int coinChange(int[] coins, int amount) {
int[] dp = new int[amount + 1];
for (int i = 0; i < dp.length; i++) {
dp[i] = Integer.MAX_VALUE;
}
dp[0] = 0;
for (int i = 0; i < coins.length; i++) {
for (int j = coins[i]; j <= amount; j++) {
if (dp[j - coins[i]] != Integer.MAX_VALUE) {
dp[j] = Math.min(dp[j], dp[j - coins[i]] + 1);
}
}
}
return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
}
}自己实现过程中遇到哪些困难
因为要求的是最小值， 因此就需要知道当前的 dp[j] 是否有效，在自己写算法代码的时候， 尝试了非常多的方式，最终才尝试出将 dp 数组赋值为 -1 的方式： dp[i] = -1.
[LeetCode] 279. 完全平方数
[LeetCode] 279. 完全平方数 文章解释题目：
给你一个整数
n，返回 和为n的完全平方数的最少数量 。完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，
1、4、9和16都是完全平方数，而3和11不是。示例 1：
输入：n = 12 输出：3 解释：12 = 4 + 4 + 4示例 2：
输入：n = 13 输出：2 解释：13 = 4 + 9提示：
1 <= n <= 10^4
[LeetCode] 279. 完全平方数
自己看到题目的第一想法
先找到平方后依旧小于 n 的最大整数。从 1 到找到的这个整数，同时求平方，得到可以挑选的数字列表。再从这几个数字中不停的挑选数字，求和为 n 的最小数字个数。因此可以转换为完全背包问题。
看完代码随想录之后的想法
思路一样，代码实现细节不同。 特别在于对 dp[j] 是否有效上， 将 dp[j] 初始化为 Integer.MAX_VALUE 确实很有效。
// 先遍历容量是排列，比组合更低效一些
class Solution {
public int numSquares(int n) {
int[] dp = new int[n + 1];
for (int i = 0; i < dp.length; i++) {
dp[i] = Integer.MAX_VALUE;
}
dp[0] = 0;
for (int j = 1; j <= n; j++) {
for (int i = 1; i * i <= j; i++) {
dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
}
}
return dp[n];
}
}// 先遍历元素的话是组合，比先遍历容量的排列更高效一些
class Solution {
public int numSquares(int n) {
int[] dp = new int[n + 1];
for (int i = 0; i < dp.length; i++) {
dp[i] = Integer.MAX_VALUE;
}
dp[0] = 0;
// 先遍历元素, 元素的值为 i*i
for (int i = 1; i * i <= n; i++) {
// 后遍历容量
for (int j = i * i; j <= n; j++) {
dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
}
}
return dp[n];
}
}
// 不初始化的方式，我也不知道这样的实现有没有意义。。。似乎挺蠢的？
class Solution {
public int numSquares(int n) {
int[] dp = new int[n + 1];
// 先遍历元素, 元素的值为 i*i
for (int i = 1; i * i <= n; i++) {
// 后遍历容量
for (int j = i * i; j <= n; j++) {
if (j - i * i == 0) {
dp[j] = 1;
} else if (dp[j - i * i] > 0) {
if (dp[j] == 0) {
dp[j] = dp[j - i * i] + 1;
} else {
dp[j] = Math.min(dp[j], dp[j - i * i] + 1);
}
}
}
}
return dp[n];
}
}自己实现过程中遇到哪些困难
没想到把 dp 数组初始化为 Integer.MAX_VALUE 的方式，绕了不少弯路。
330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
