某不知名学校算法课第三次实验报告
题目来自力扣 这次实验是贪心算法
贪心的思维很跳跃，每道题也没有固定的模板的思考方向
跳跃游戏
题目描述：
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
我们把数组中的每个元素看作是最大覆盖范围，当覆盖范围到达终点时，即满足题目条件
以样例1为例 初始指向2 覆盖范围为231，更新至3 覆盖范围3114 到达终点 符合题意
以样例2为例 初始指向3 覆盖范围3210 指向2 覆盖范围210 指向1 覆盖范围10 指向0 覆盖范围0
可以看到 我们没有办法覆盖到终点4 所以不符合题意
代码加注释如下：
class Solution {
public:
bool canJump(vector<int>& nums) {
int cover = 0;
for(int i = 0; i <= cover; i ++ )
{
//不断更新自己的覆盖范围
cover = max(cover, nums[i] + i);
//如果覆盖范围能到达终点
if(cover >= nums.size() - 1) return true;
}
return false;
}
};很短，但是很需要思维，这就是贪心 也是传说中的局部最优解到全局最优解
分割平衡字符串
题目描述：
在一个「平衡字符串」中，'L' 和 'R' 字符的数量是相同的。
给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。
返回可以通过分割得到的平衡字符串的最大数量。
示例 1：
输入：s = "RLRRLLRLRL"
输出：4
解释：s 可以分割为 "RL", "RRLL", "RL", "RL", 每个子字符串中都包含相同数量的 'L' 和 'R'。
示例 2：
输入：s = "RLLLLRRRLR"
输出：3
解释：s 可以分割为 "RL", "LLLRRR", "LR", 每个子字符串中都包含相同数量的 'L' 和 'R'。
示例 3：
输入：s = "LLLLRRRR"
这道题可以暴力 数据不大 但是感觉这种查询匹配问题 用哈希表的方式解决是通常的选择
计数L 发现R计数相等时 就是一对平衡字串 思路很简单
代码如下：
class Solution {
public:
int balancedStringSplit(string s) {
int cnt = 0; //记录L R的数量关系
int res = 0;
for(char c : s) // 遍历
{
if( c == 'L' ) cnt ++ ;
else cnt --;
if( cnt == 0 ) res ++ ;
}
return res;
}
};用户分组
题目描述：
有 n 位用户参加活动，他们的 ID 从 0 到 n - 1，每位用户都 恰好 属于某一用户组。给你一个长度为 n 的数组 groupSizes，其中包含每位用户所处的用户组的大小，请你返回用户分组情况（存在的用户组以及每个组中用户的 ID）。
你可以任何顺序返回解决方案，ID 的顺序也不受限制。此外，题目给出的数据保证至少存在一种解决方案。
示例 1：
输入：groupSizes = [3,3,3,3,3,1,3]
输出：[[5],[0,1,2],[3,4,6]]
解释：
其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。
示例 2：
输入：groupSizes = [2,1,3,3,3,2]
输出：[[1],[0,5],[2,3,4]]
提示：
groupSizes.length == n
1 <= n <= 500
1 <= groupSizes[i] <= n
从题目中，我们知道要填入的数据是0 ~n-1的连续整数，也正好对应了数组的下标
然后给的函数要返回双层vector，也就是说我们得要一个单层vector填入
跟上一题差不多，也是用一个类似哈希表的写法，进行查询和匹配的问题
代码＋注释如下：
class Solution {
public:
vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
vector<vector<int>> res;
//二维vector只能用一级vector去push——back
unordered_map<int , vector<int>>M; //哈希表
int cnt = 0; // 记录数组下标 正好是0~n-1号数字
for(auto x : groupSizes) //强化for循环
{
M[x].push_back(cnt);
//该组存满了
if(M[x].size() >= x)
{
//存入答案
res.push_back(M[x]);
//同时清空
M[x].clear();
}
cnt ++;
}
return res;
}
};非递增顺序的最小子序列
题目描述：
给你一个数组 nums，请你从中抽取一个子序列，满足该子序列的元素之和 严格 大于未包含在该子序列中的各元素之和。
如果存在多个解决方案，只需返回 长度最小 的子序列。如果仍然有多个解决方案，则返回 元素之和最大 的子序列。
与子数组不同的地方在于，「数组的子序列」不强调元素在原数组中的连续性，也就是说，它可以通过从数组中分离一些（也可能不分离）元素得到。
注意，题目数据保证满足所有约束条件的解决方案是 唯一 的。同时，返回的答案应当按 非递增顺序 排列。
示例 1：
输入：nums = [4,3,10,9,8]
输出：[10,9]
解释：子序列 [10,9] 和 [10,8] 是最小的、满足元素之和大于其他各元素之和的子序列。但是 [10,9] 的元素之和最大。
示例 2：
输入：nums = [4,4,7,6,7]
输出：[7,7,6]
解释：子序列 [7,7] 的和为 14 ，不严格大于剩下的其他元素之和（14 = 4 + 4 + 6）。因此，[7,6,7] 是满足题意的最小子序列。注意，元素按非递增顺序返回。
简单贪心题，我们先进行一遍排序，从最大的数字开始选，选到答案集合中的数的和大于剩下的数的和即可
代码＋注释如下：
class Solution {
public:
vector<int> minSubsequence(vector<int>& nums) {
vector<int> res; // 存答案 返回值是vector
sort(nums.begin(),nums.end()); // 排序
int sum = 0, cur = 0, idx = nums.size() - 1;
for(int i : nums) sum += i;
while(cur <= sum) //答案序列和小于剩余序列和
{
sum -= nums[idx];
cur += nums[idx];
res.push_back(nums[idx--]); // 加入答案序列 顺便往前选择
}
return res;
}
};
