题目：
给你一个字符串
s和一个字符串列表wordDict作为字典。如果可以利用字典中出现的一个或多个单词拼接出s则返回true。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。
示例 1：
输入: s = "leetcode", wordDict = ["leet", "code"] 输出: true 解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。示例 2：
输入: s = "applepenapple", wordDict = ["apple", "pen"] 输出: true 解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。 注意，你可以重复使用字典中的单词。示例 3：
输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"] 输出: false提示：
1 <= s.length <= 3001 <= wordDict.length <= 10001 <= wordDict[i].length <= 20s和wordDict[i]仅由小写英文字母组成wordDict中的所有字符串 互不相同
[LeetCode] 139. 单词拆分
自己看到题目的第一想法
回溯算法，每次回溯都遍历一遍 wordDict 中的每个单词，将所有单词拼接起来，如果长度超过目标字符串，则表示失败返回 false。否则判断字符串是否相等，相等则返回 true。
但是动态规划章节肯定是要用动态规划啦，只能是从 wordDict 中不停的取单词，看最终是否能拼凑成目标字符串，看起来像是完全背包的问题。但是背包问题都是要有个容量，这里容量该怎么选择呢？从所有字符串中不停选取元素，看最终是否能凑成长度为 n 的字符串。 容量就是 1 个字符组成的字符串、2个字符组成的字符串，一直到 n 个字符组成的字符串。
那物品呢，就是字典里的字符了。
看完代码随想录之后的想法
迷迷糊糊的～
// 一维数组版本
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
boolean[] dp = new boolean[s.length() + 1];
dp[0] = true;
for (int i = 1; i < dp.length; i++) {
// 对于字符串 s 的 0～i 区间，都需要对 wordDict 遍历一遍
// 同时如果 dp[i] 已经可以被拼接上的话，不管到底拼接的组合是怎么样的，不需要管剩下的单词了
for (int j = 0; j < wordDict.size() && !dp[i]; j++) {
if (i < wordDict.get(j).length()) {
continue;
}
int startIndex = s.indexOf(wordDict.get(j), i - wordDict.get(j).length());
if (startIndex != -1 && startIndex == i - wordDict.get(j).length()) {
dp[i] = dp[i - wordDict.get(j).length()];
}
}
}
return dp[s.length()];
}
}// 二维数组版本：效率很低。
class Solution {
public boolean wordBreak(String s, List<String> wordDict) {
boolean[][] dp = new boolean[wordDict.size()][s.length() + 1];
for (int i = 0; i < dp.length; i++) {
dp[i][0] = true;
}
for (int i = 1; i <= s.length(); i++) {
for (int j = 0; j < dp.length; j++) {
for (int k = 0; k < wordDict.size() && !dp[j][i]; k++) {
if (i < wordDict.get(k).length()) {
if (j >= 1) {
dp[j][i] = dp[j - 1][i];
}
continue;
}
int startIndex = s.indexOf(wordDict.get(k), i - wordDict.get(k).length());
if (startIndex == i - wordDict.get(k).length()) {
dp[j][i] = dp[j][startIndex];
} else {
if (j - 1 >= 0) {
dp[j][i] = dp[j - 1][i];
}
}
}
}
}
return dp[dp.length - 1][s.length()];
}
}自己实现过程中遇到哪些困难
随想录网站上的算法版本，一开始一直想不清楚和背包的关系，但是首先代码一定是能通过的，因此一定是满足了背包的定义。后来自己用一维和二维都实现了一遍，其实 for (j = 0; j <=i; j++) 的部分，就是在找普通完全背包里的 nums[i], 找到后才能找到递推的位置
[KamaCoder] 56. 携带矿石资源（第八期模拟笔试）
[KamaCoder] 56. 携带矿石资源（第八期模拟笔试）文章解释
题目描述
你是一名宇航员，即将前往一个遥远的行星。在这个行星上，有许多不同类型的矿石资源，每种矿石都有不同的重要性和价值。你需要选择哪些矿石带回地球，但你的宇航舱有一定的容量限制。
给定一个宇航舱，最大容量为 C。现在有 N 种不同类型的矿石，每种矿石有一个重量 w[i]，一个价值 v[i]，以及最多 k[i] 个可用。不同类型的矿石在地球上的市场价值不同。你需要计算如何在不超过宇航舱容量的情况下，最大化你所能获取的总价值。
输入描述
输入共包括四行，第一行包含两个整数 C 和 N，分别表示宇航舱的容量和矿石的种类数量。
接下来的三行，每行包含 N 个正整数。具体如下：
第二行包含 N 个整数，表示 N 种矿石的重量。
第三行包含 N 个整数，表示 N 种矿石的价格。
第四行包含 N 个整数，表示 N 种矿石的可用数量上限。
输出描述
输出一个整数，代表获取的最大价值。
输入示例
10 3 1 3 4 15 20 30 2 3 2输出示例
90提示信息
数据范围：
1 <= C <= 10000;
1 <= N <= 10000;
1 <= w[i], v[i], k[i] <= 10000;
[KamaCoder] 56. 携带矿石资源（第八期模拟笔试）
自己看到题目的第一想法
无
看完代码随想录之后的想法
相对于 01 背包，每次计算当前容量可以装的最大价值时，不仅要考虑到 dp[j - weights[i]] + values[i], 还要考虑到直接放入 k 个的情况，即是 dp[j - k * weights[i]] + k * values[i]
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
/**
* bagWeight:背包容量
* n:物品种类
*/
int bagWeight, n;
//获取用户输入数据，中间用空格隔开，回车键换行
bagWeight = sc.nextInt();
n = sc.nextInt();
int[] weight = new int[n];
int[] value = new int[n];
int[] nums = new int[n];
for (int i = 0; i < n; i++) weight[i] = sc.nextInt();
for (int i = 0; i < n; i++) value[i] = sc.nextInt();
for (int i = 0; i < n; i++) nums[i] = sc.nextInt();
int[] dp = new int[bagWeight + 1];
for (int i = 0; i < weight.length; i++) {
// 01 背包问题记得要倒序
for (int j = bagWeight; j >= weight[i]; j--) {
for (int k = 1; k <= nums[i] && j >= k * weight[i]; k++) {
dp[j] = Math.max(dp[j], dp[j - k * weight[i]] + k * value[i]);
}
}
}
System.out.println(dp[bagWeight]);
}
}自己实现过程中遇到哪些困难
1. 忘记了多重背包的 k 循环以及对应 j >= k * weight[i] 的判断
2. 01 背包是需要倒序遍历的
[LeetCode] 198. 打家劫舍 视频解释
题目：
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。示例 2：
输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。 偷窃到的最高金额 = 2 + 9 + 1 = 12 。提示：
1 <= nums.length <= 1000 <= nums[i] <= 400
[LeetCode] 198. 打家劫舍
自己看到题目的第一想法
好像挺复杂的，有点像分糖果一样，顾此失彼。
看完代码随想录之后的想法
好简单， 一个递推公式搞定。
class Solution {
public int rob(int[] nums) {
if (nums.length == 1) {
return nums[0];
}
int[] dp = new int[nums.length];
dp[0] = nums[0];
dp[1] = Math.max(dp[0], nums[1]);
for (int i = 2; i < nums.length; i++) {
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[nums.length - 1];
}
}自己实现过程中遇到哪些困难
代码还是比较简单的， 注意一个 nums.length == 1 的情况.
[LeetCode] 213. 打家劫舍 II
[LeetCode] 213. 打家劫舍 II 文章解释题目：
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 1：
输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。示例 2：
输入：nums = [1,2,3,1] 输出：4 解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。 偷窃到的最高金额 = 1 + 3 = 4 。示例 3：
输入：nums = [1,2,3] 输出：3提示：
1 <= nums.length <= 1000 <= nums[i] <= 1000
[LeetCode] 213. 打家劫舍 II
自己看到题目的第一想法
不会～
看完代码随想录之后的想法
好简单～
class Solution {
public int rob(int[] nums) {
if (nums.length == 1) {
return nums[0];
}
return Math.max(rob(nums, 0, nums.length - 2), rob(nums, 1, nums.length - 1));
}
private int rob(int[] nums, int start, int end) {
if (start == end) {
return nums[start];
}
int[] dp = new int[end - start + 1];
dp[0] = nums[start];
dp[1] = Math.max(nums[start + 1], dp[0]);// 别忘了要比较 0 和 1 取最大值
for (int i = 2; i <= end - start; i++) {
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[start + i]);
}
return dp[dp.length - 1];
}
}自己实现过程中遇到哪些困难
稍微有点没绕过来，整体还好。
[LeetCode] 337. 打家劫舍 III
[LeetCode] 337. 打家劫舍 III 文章解释题目：
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为
root。除了
root之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。给定二叉树的
root。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。示例 1:
输入: root = [3,2,3,null,3,null,1] 输出: 7 解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7示例 2:
输入: root = [3,4,5,1,3,null,1] 输出: 9 解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9提示：
- 树的节点数在
[1, 10^4]范围内0 <= Node.val <= 10^4
[LeetCode] 337. 打家劫舍 III
自己看到题目的第一想法
一脸懵逼。
看完代码随想录之后的想法
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
// dp[0] 不偷当前节点的最大值， dp[1] 偷当前节点的最大值
int[] dp = traversal(root);
return Math.max(dp[0], dp[1]);
}
private int[] traversal(TreeNode node) {
if (node == null) {
return new int[2];
}
int[] left = traversal(node.left);
int[] right = traversal(node.right);
int [] dp = new int[2];
dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
dp[1] = node.val + left[0] + right[0];
return dp;
}
}自己实现过程中遇到哪些困难
当不偷自己的时候，要知道左孩子和右孩子，每个孩子返回的值中，要选择其中大的值。
[LeetCode] 121. 买卖股票的最佳时机
[LeetCode] 121. 买卖股票的最佳时机 文章解释[LeetCode] 121. 买卖股票的最佳时机 视频解释
题目：
给定一个数组
prices，它的第i个元素prices[i]表示一支给定股票第i天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回
0。示例 1：
输入：[7,1,5,3,6,4] 输出：5 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。示例 2：
输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。提示：
1 <= prices.length <= 10^50 <= prices[i] <= 10^4
[LeetCode] 121. 买卖股票的最佳时机
自己看到题目的第一想法
做贪心的时候看过，当时看的是可以多次买卖的版本，因此计算 dp[i][0] 的时候，写成 dp[i - 1][1] - prices[i]，这是不对的。
看完代码随想录之后的想法
可以多次买卖虽然能理解背后的数学本质，但真的挺难想的。总感觉掌握不住。
class Solution {
public int maxProfit(int[] prices) {
// dp[i][0] 表示第 i 天持有股票，账户中剩余的资金
// dp[i][1] 表示第 i 天不持有股票，账户中剩余的资金
int[][] dp = new int[prices.length][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for (int i = 1; i < dp.length; i++) {
dp[i][0] = Math.max(dp[i - 1][0], - prices[i]);
dp[i][1] = Math.max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
}
return dp[prices.length - 1][1];
}
}class Solution {
public int maxProfit(int[] prices) {
int result = 0;
int low = prices[0];
for (int i = 1; i < prices.length; i++) {
if (prices[i] < low) {
low = prices[i];
} else if (prices[i] - low > result) {
result = prices[i] - low;
}
}
return result;
}
}自己实现过程中遇到哪些困难
递推公式写错啦～
220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
