题目:
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。
对每个孩子
i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸s[j]。如果s[j] >= g[i]，我们可以将这个饼干j分配给孩子i，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。示例 1:
输入: g = [1,2,3], s = [1,1] 输出: 1 解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。 虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。 所以你应该输出1。示例 2:
输入: g = [1,2], s = [1,2,3] 输出: 2 解释: 你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。 你拥有的饼干数量和尺寸都足以让所有孩子满足。 所以你应该输出2.
[LeetCode] 455. 分发饼干
自己看到题目的第一想法
把最大的给能满足的胃口最大的小孩, 依次往下.
看完代码随想录之后的想法
差不多的想法.
class Solution {
// s 代表饼干, g 代表小孩
public int findContentChildren(int[] g, int[] s) {
Arrays.sort(g);
Arrays.sort(s);
int result = 0;
int cookieIndex = s.length - 1;
int childIndex = g.length - 1;
while (cookieIndex >= 0 && childIndex >= 0) {
if (s[cookieIndex] >= g[childIndex--]) {
cookieIndex--;
result++;
}
}
return result;
}
}class Solution {
// s 代表饼干, g 代表小孩
public int findContentChildren(int[] g, int[] s) {
Arrays.sort(g);
Arrays.sort(s);
int result = 0;
int cookieIndex = 0;
int childIndex = 0;
while (cookieIndex < s.length && childIndex < g.length) {
if (s[cookieIndex++] >= g[childIndex]) {
childIndex++;
result++;
}
}
return result;
}
}自己实现过程中遇到哪些困难
无
题目:
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
例如，
[1, 7, 4, 9, 2, 5]是一个 摆动序列 ，因为差值(6, -3, 5, -7, 3)是正负交替出现的。- 相反，
[1, 4, 7, 2, 5]和[1, 7, 4, 5, 5]不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。
给你一个整数数组
nums，返回nums中作为 摆动序列 的 最长子序列的长度 。示例 1：
输入：nums = [1,7,4,9,2,5] 输出：6 解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。示例 2：
输入：nums = [1,17,5,10,13,15,10,5,16,8] 输出：7 解释：这个序列包含几个长度为 7 摆动序列。 其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。示例 3：
输入：nums = [1,2,3,4,5,6,7,8,9] 输出：2
[LeetCode] 376. 摆动序列
自己看到题目的第一想法
直接看解释了~~~
看完代码随想录之后的想法
1. 有转折的地方需要考虑是否是波峰波谷
2. 转折的地方, 如果是从平坡专责过来的, 就要考虑平坡之前的坡的方向. 如果平坡左右两边的坡是相反的方向, 才是波峰波谷.
3. 如果整个序列是递增和递减的, 那就只有两个波峰波谷.
class Solution {
public int wiggleMaxLength(int[] nums) {
int rightDiff = 0;
int leftDiff = 0;
int result = 1;
for (int i = 0; i < nums.length - 1; i++) {
rightDiff = nums[i + 1] - nums[i];
if ((leftDiff >= 0 && rightDiff < 0)
|| (leftDiff <= 0 && rightDiff > 0)) {
result++;
leftDiff = rightDiff;// 注意 leftDiff 是在 if 语句里更新的
}
}
return result;
}
}// 动态规划版本
class Solution {
public int wiggleMaxLength(int[] nums) {
int result = 0;
int[][] dp = new int[nums.length][2];
dp[0][0] = dp[0][1] = 1;// 开始节点即算波峰又算波谷???
for (int i = 1; i < nums.length; i++) {
dp[i][0] = dp[i][1] = 1;
for (int j = 0; j < i; j++) {
if (nums[j] > nums[i]) {
dp[i][1] = Math.max(dp[i][1], dp[j][0] + 1);// 波谷 +1
}
}
for (int j = 0; j < i; j++) {
if (nums[j] < nums[i]) {
dp[i][0] = Math.max(dp[i][0], dp[j][1] + 1);// 波峰 +1
}
}
}
return Math.max(dp[nums.length - 1][0], dp[nums.length - 1][1]);
}
}自己实现过程中遇到哪些困难
动态规划的部分的运行流程, 感觉不是很好完全展开... 有点云里雾里的感觉.
题目:
给你一个整数数组
nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组
是数组中的一个连续部分。示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4] 输出：6 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。示例 2：
输入：nums = [1] 输出：1示例 3：
输入：nums = [5,4,-1,7,8] 输出：23提示：
1 <= nums.length <= 10^5-10^4 <= nums[i] <= 10^4
[LeetCode] 53. 最大子数组和
自己看到题目的第一想法
第一个反应是想到了双指针窗口(错误的逻辑): 一个 for 循环, 从左往右把数字添加进来, 计算一个结果. 如果当前结果小于上一个结果, 则说明当前数字是负数. 这时候要收缩窗口大小, 移动左侧指针.
看完代码随想录之后的想法
我看到题目的第一反应是错误的, 因为当添加一个新的数字后, 和变的更小, 说明当前数字是负数. 而窗口无论如何搜索, 都不可能得到一个大于旧和的数了. 因此这里应该是记录住当前和, 同时跳过当前的负数, 继续向下遍历.
class Solution {
public int maxSubArray(int[] nums) {
int sum = 0;
Integer result = null;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];// 先把数累加起来
if (result == null || result < sum) {
// 如果当前总和大于 result, 则更新.
result = sum;
}
// if (nums[i] < 0) {// 这里老是写错
if (sum < 0) {
sum = 0;
}
}
return result;
}
}// 动态规划解法
class Solution {
public int maxSubArray(int[] nums) {
Integer result = null;
int[] dp = new int[nums.length];
result = dp[0] = nums[0];
for (int i = 1; i < nums.length; i++) {
if (dp[i - 1] < 0) {
dp[i] = nums[i];
} else {
dp[i] = dp[i - 1] + nums[i];
}
if (result == null || dp[i] > result) {
result = dp[i];
}
}
return result;
}
}自己实现过程中遇到哪些困难
看都懂... 写怎么都写不出来... T_T
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
