复习比学习更重要，更需要投入时间，更需要花费精力
- 1.字符串的排列
- 2.找出字符串中第一个匹配的下标
- 3.最大连续1的个数II
- 4.数组中的山脉
- 5.移除元素
- 6.两个数组的交集II
- 7.有序数组的平方
- 8.删除有序数组中的重复项II
- 9.寻找重复数
- 10.水果成篮
1.字符串的排列
在滑动窗口总结文章里面讲解过了
二刷debug：首先，缩小窗口的条件是r-l >s1.size()。然后，必须用need.count( c )而不是need[c] >= 1。count( c ) 仅仅检查键 c 是否存在于 unordered_map 中，与键对应的值无关！而need[c]>=1是必须need中有其键并且数量大于等于1
class Solution {
public:
bool checkInclusion(string s1, string s2) {
unordered_map<char, int> window, need;
for(char c : s1) need[c] ++;
int left = 0, right = 0;
int valid = 0;
while(right < s2.size()){
char c = s2[right];
right++;
if(need.count(c)){
window[c]++;
if(need[c] == window[c]) valid++;
}
while(right - left > s1.size()){
char d = s2[left];
left ++;
if(need.count(d)){
if(need[d] == window[d]) valid--;
window[d]--;
}
}
if(need.size() == valid && right - left == s1.size()){
return true;
}
}
return false;
}
};
2.找出字符串中第一个匹配的下标
拿到手的第一想法就是，滑动窗口，输出left
但是这个要求顺序完全一样，不能是排列或者组合
查了一下KMP是专门弄这种的，学习新算法了
(我只是来做双指针的…)这篇文章是个纯刷题记录，不贴详细讲解，最多记录大致思路，需要讲解去秒杀直接部分->传送门
二刷debug：写出来了，几乎是靠背的，注意ne初始化
class Solution {
public:
int strStr(string haystack, string needle) {
int n = haystack.size();
int m = needle.size();
vector<int> ne(m, -1);// ne数组必须初始化为-1而不是0,只有-1才代表没有相同的前后缀
// 建next数组
for(int i = 1, j = -1; i < m; i ++){
while(j != -1 && needle[i] != needle[j + 1]) j = ne[j];
if(needle[i] == needle[j + 1]) j ++;
ne[i] = j;
}
// 匹配
for(int i = 0, j = -1; i < n; i ++){
while(j != -1 && haystack[i] != needle[j + 1]) j = ne[j];
if(haystack[i] == needle[j + 1]) j ++;
if(j == m - 1){
return i - m + 1;
}
}
return -1;
}
};
3.最大连续1的个数II
不是，家人们，滑动窗口为什么都划到双指针标签下了啊
题：
给定一个二进制数组 nums 和一个整数 k，如果可以翻转最多 k 个 0 ，则返回 数组中连续 1 的最大个数 。
eg：
输入：nums = [1,1,1,0,0,0,1,1,1,1,0], K = 2
输出：6
在秒杀系列的滑动窗口秒杀文章里面写过
用滑动窗口做题需要先明白3个问题
- 什么时候扩大窗口？更改什么数据？
- 什么时候缩小窗口？更改什么数据？
- 什么时候得到答案？
针对123的答案：
- 当可替换次数k>=0的时候扩大窗口，更改窗口里面1的个数，让窗口里面都是1，等于0的时候也扩，万一窗口外面不需要改呢。
- 当可替换次数k<0的时候缩小窗口，可替换次数++，以便继续扩大
- k>=0的时候，窗口内部都是1，len更新
class Solution {
public:
int longestOnes(vector<int>& nums, int k) {
int left = 0, right = 0;
int windowOneCount = 0;
int res = 0;
while(right < nums.size()){
//right是0也++,是1就windowOneCount++,自身也++
if(nums[right] == 1){
windowOneCount ++;
}
right ++;
//窗口里面0的个数超过了k,就开始缩小窗口
while(right - left - windowOneCount > k){
if(nums[left] == 1) windowOneCount --;
left ++;
}
res = max(res, right - left);
}
return res;
}
};
4.数组中的山脉
先找到可能得山顶，再双指针两边扩展，记录res
留意l，r，i的边界
二刷debug：注意双指针两边扩展的手法，还有边界问题，如果是只能到倒数第二个元素的话，i<.size()-1即可
class Solution {
public:
int longestMountain(vector<int>& arr) {
int l = 0, r = 0, res = 0;
for(int i = 1; i < arr.size() - 1; i ++){
if(arr[i] > arr[i - 1] && arr[i] > arr[i + 1]){
l = i - 1;
r = i + 1;
while(l > 0 && arr[l] > arr[l - 1]) l --;
while(r < arr.size() - 1 && arr[r] > arr[r + 1]) r ++;
res = max(res, r - l + 1);
}
}
return res;
}
};
5.移除元素
移除val，返回新数组的长度
双指针里也有这题，秒啦
class Solution {
public int removeElement(int[] nums, int val) {
int i = 0;
for (int n : nums)
if (n != val) {
nums[i] = n;
i++;
}
return i;
}
}
6.两个数组的交集II
给nums1和nums2，以数组的形式返回两数组里都存在的数，并且这个数的次数要等于两个数组中这个数出现次数更少的那个
别人的代码是真的优雅
这个代码先记录了nums1中每个元素出现的次数到umap中
再在nums2中for每个元素
如果元素在umap中有记录则将其push进res，并且umap记录数–
假如nums1中才是数字出现少的那个，那么umap[nums1]会先到0，以至于res不了nums2的元素，假如nums2才是数字出现少的那个，那么if(nums2)会先空
太优雅了o(╥﹏╥)o
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int, int> umap;
vector<int> res;
for(int i = 0; i < nums1.size(); i ++) umap[nums1[i]]++;
for(int i = 0; i < nums2.size(); i ++){
if(umap[nums2[i]]){
res.push_back(nums2[i]);
umap[nums2[i]] --;
}
}
return res;
}
};
7.有序数组的平方
给一个非递减的数组，现在需要你将每个元素都平方，然后递增排序，返回nums。注意，需要时间复杂度是O(n)
sort的家伙，以后面试也排人后面！！！！
sort的复杂度是O(nlogn)，所以不能用sort，只能用双指针
这里有个十分关键的点，就是：原本的数组本身就是有序的，是一个非递减的数组，那么即使数组中元素有正有负，绝对值最大的元素肯定是在数组的两端的，即数组平方的最大值是在数组的两端的。
所以我们可以使用两个双指针i,j一个指向起始位置，一个指向数组的末尾。
定义一个新的数组result用于储存新的有序平方后的元素。
class Solution {
public:
//双指针
vector<int> sortedSquares(vector<int>& A) {
int k = A.size() - 1; //指向新数组的末尾，从后往前赋值
vector<int> result(A.size(), 0);
for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
if (A[i] * A[i] < A[j] * A[j]) { //判断条件1：尾部元素更大
result[k--] = A[j] * A[j];
j--;
}
else {
result[k--] = A[i] * A[i]; //判断条件2：头部元素更大
i++;
}
}
return result;
}
};
8.删除有序数组中的重复项II
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
前2个肯定不用删，所以可以跳过，从j = 2开始比
还是太优雅了这代码
二刷debug：不会，很难理解
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if(nums.size() <= 2) return nums.size();
int i = 2;
for(int j = 2; j < nums.size(); j ++){
if(nums[j] != nums[i - 2]){
nums[i] = nums[j];
i ++;
}
}
return i;
}
};
9.寻找重复数
不可以用sort也不可以用额外数组
这个要求真的是把我路都堵死了…
二刷debug：不会…
数组小技巧：数组也可以看做链表来做
以图为例，天然就有数组链表0->1->3->2->4
fast = nums[nums[fast]]相当于fast = fast->next->next
slow = nums[slow]相当于slow = slow->next
几刷？：容易写成return nums[slow]，实际上最后一个是slow = nums[slow]，所以直接写成return slow就可以了
class Solution {
public:
int findDuplicate(vector<int>& nums) {
int fast = 0, slow = 0;
while(true){
fast = nums[nums[fast]];
slow = nums[slow];
if(fast == slow) break;
}
slow = 0;
while(fast != slow){
fast = nums[fast];
slow = nums[slow];
}
return slow;
}
};
10.水果成篮
fruits数组，fruits[i]代表一种水果，比如fruits[2] = 1，,代表香蕉
现在有fruits.size()棵水果树，每次只能摘一颗树
现在有2个篮子，每个篮子装一种水果，问最多能摘多少棵数
fruit = [1,2,1]，有两种水果树，所以能摘三棵，都能摘，篮子装得下
滑动窗口。要注意不需要window.size() == need，也要计算len，因为有while(window.size() > need)在，窗口不是小了就是刚刚好，不可能大，如果fruit的水果树种类本来就不足2个，就可以返回
另外，当缩小窗口，导致其中一个苹果树没了，window应该erase掉。否则还占用一个size
二刷debug：小于等于2的水果树种类也可以，另外unordered_map类型可以使用erase
class Solution {
public:
int totalFruit(vector<int>& fruits) {
unordered_map<int, int> window;
int need = 2;
int len = 0;
int left = 0, right = 0;
while(right < fruits.size()){
int c = fruits[right];
right++;
window[c]++;;
while(window.size() > need){
int d = fruits[left];
left++;
window[d]--;
if(window[d] == 0) window.erase(d);
}
len = max(len, right - left);
}
return len;
}
};
