LeetCode高频题刷题笔记（四）队列

123冲鸭

已于 2023-06-01 11:24:26 修改

阅读量172

点赞数

分类专栏： LeetCode刷题专栏文章标签： leetcode 算法数据结构

于 2023-03-24 14:35:42 首次发布

本文链接：https://blog.csdn.net/qq_29355253/article/details/129054524

版权

LeetCode刷题专栏专栏收录该内容

15 篇文章 1 订阅

订阅专栏

基础知识

队列(queue)遵循FIFO先进先出原则。
6 个基本操作： push()、pop()、empty()、size()、front()、back()
front、back：返回队首、队尾不删除

优先队列（默认大根堆）priority_queue：top() 返回最大值
双端队列 deque：push_back()、push_front()、pop_back()、pop_front()

题目

⭐1.滑动窗口最大值（ LeetCode 239 ）

难度： 困难
题目表述：
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
代码（C++）：

class Solution {
public:
	// 优先队列
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<pair<int, int>> q;
        for (int i = 0; i < k; i++) {
            q.emplace(nums[i], i);
        }
        vector<int> ans = {q.top().first};
        for (int i = k; i < nums.size(); i++) {
            q.emplace(nums[i], i);
            while (q.top().second <= i - k) {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
    // 双端队列 单调递减
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        deque<int> q;
        for (int i = 0; i < nums.size(); i++) {
            while (!q.empty() && nums[q.back()] <= nums[i]) {
                q.pop_back();
            }
            q.push_back(i);
            if (i >= k - 1) {
                while (q.front() <= i - k) {
                    q.pop_front();
                }
                ans.push_back(nums[q.front()]);
            }
        }
        return ans;
    }
};

题解： 优先队列 / 双端单调（递减）队列

⭐2.最小覆盖子串（ LeetCode 76 ）

难度： 困难
题目表述：
给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。
代码（C++）：

class Solution {
public:
    unordered_map<char, int> ori, cnt;
    bool check() {
        for (const auto &p: ori) {
            if (cnt[p.first] < p.second) {
                return false;
            }
        }
        return true;
    }
    string minWindow(string s, string t) {
        for (const auto &c: t) {
            ori[c]++;
        }
        int l = 0, r = 0, len = INT_MAX, ansL = -1;
        while (r < s.size()) {
            if (ori.find(s[r]) != ori.end()) {
                cnt[s[r]]++;
            }
            while (check() && l <= r) {
                if (r - l + 1 < len) {
                    len = r - l + 1;
                    ansL = l;
                }
                if (ori.find(s[l]) != ori.end()) {
                    cnt[s[l]]--;
                }
                l++;    
            }
            r++;
        }
        return ansL == -1 ? string() : s.substr(ansL, len);
    }
    	// 模板法
    	while (r < s.size()) {
            cnt[s[r]]++;
            while (check() && l <= r) {
                if (r -l + 1 < len) {
                    len = r - l + 1;
                    ansL = l;
                }
                cnt[s[l]]--;
                if (cnt[s[l]] == 0) {
                    cnt.erase(cnt[s[l]]);
                }
                l++;
            }
            r++;
        }
};

题解： 滑动窗口
unordered_map[key] 如果不存在 key ，就插入并赋初始值；
unordered_map.at(key) 如果不存在 key ，将给出运行时错误。

3.无重复字符的最长子串（ LeetCode 76 ）

难度： 中等
题目表述：
给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。
代码（C++）：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_set<char> occ;
        int j = 0, ans = 0;
        for (int i = 0 ; i < s.size(); i++) {
            if (i > 0) {
                occ.erase(s[i - 1]);
            }
            while (j < s.size() && !occ.count(s[j])) {
                occ.insert(s[j]);
                j++;
            }
            ans = max(ans, j - 1 - i + 1);
        }
        return ans;
    }
    // 模板法
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> occ;
        int l = 0, r = 0, ans = 0;
        while (r < s.size()) {
            occ[s[r]]++;
            if (r - l + 1 == occ.size()) {
                ans = max(ans, r - l + 1);
            }
            while (r - l + 1 > occ.size()) {
                occ[s[l]]--;
                if (occ[s[l]] == 0) {
                    occ.erase(s[l]);
                }
                l++;
            }
            r++;
        }
        return ans;
    }
};

题解： 滑动窗口
使用一种数据结构来判断是否有重复的字符，常用的数据结构为哈希集合std::unordered_set，
.count() 统计键为key的元素个数，返回值为0或1，因为该容器不允许有重复元素。

4.删除子数组的最大得分（ LeetCode 1695 ）

难度： 中等
题目表述：
给你一个正整数数组 nums ，请你从中删除一个含有若干不同元素的子数组。删除子数组的得分就是子数组各元素之和。返回只删除一个子数组可获得的最大得分。
代码（C++）：

class Solution {
public:
    int maximumUniqueSubarray(vector<int>& nums) {
        int n = nums.size();
        int j = 0, ans = 0, sum = 0;
        unordered_set<int> dig;
        for (int i = 0; i < n; i++) {
            if (i > 0) {
                dig.erase(nums[i - 1]);
                sum -= nums[i - 1];
            }
            while (j < n && !dig.count(nums[j])) {
                dig.insert(nums[j]);
                sum += nums[j];
                j++;
            }
            ans = max(ans, sum);
        }
        return ans;
    }
    // 模板法
    int maximumUniqueSubarray(vector<int>& nums) {
        int n = nums.size();
        int l = 0, r = 0, ans = 0, sum = 0;
        unordered_map<int, int> dig;
        while (r < n) {
            dig[nums[r]]++;
            sum += nums[r];
            if (r - l + 1 == dig.size()) {
                ans = max(ans, sum);
            } 
            while (r - l + 1 > dig.size()){
                sum -= nums[l];
                dig[nums[l]]--;
                if (dig[nums[l]] == 0){
                    dig.erase(nums[l]);
                }
                l++;
            }
            r++;
        }
        return ans;
    }
};

题解： 滑动窗口

5.找到字符串中所有字母异位词（ LeetCode 438 ）

难度： 中等
题目表述：
给定两个字符串 s 和 p，找到 s 中所有 p 的异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。异位词指由相同字母重排列形成的字符串（包括相同的字符串）。
代码（C++）：

class Solution {
public:
    // 模板法
    vector<int> findAnagrams(string s, string p) {
        unordered_map<char, int> ori, cnt;
        for (const auto &c: p) {
            ori[c]++;
        }
        int l = 0, r = 0, k = p.size();
        vector<int> ansL;
        while (r < s.size()) {
            cnt[s[r]]++;
            if (ori == cnt) {
                ansL.push_back(l);
            }
            if (r >= k - 1) {
                cnt[s[l]]--;
                if (cnt[s[l]] == 0) {
                    cnt.erase(s[l]);
                }
                l++;
            }
            r++;
        }
        return ansL;
    }
};

题解： 滑动窗口

6.前 K 个高频元素（ LeetCode 347 ）

难度： 中等
题目表述：
给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。
代码（C++）：

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mp;
        for (int x: nums) {
            mp[x]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
        for (const auto& p: mp) {
            if (q.size() == k) {
                if (q.top().first < p.second) {
                    q.pop();
                    q.emplace(p.second, p.first);
                } 
            } else
                q.emplace(p.second, p.first);
        }   
        vector<int> res;
        while (!q.empty()) {
            res.push_back(q.top().second);
            q.pop();
        }
        return res;
    }
};

题解：
优先队列默认大根堆less，小根堆是greater：priority_queue<int, vector< int>, greater< int>> pq;
优先队列自定义排序，重载()：

struct cmp{
    bool operator()(ListNode* a, ListNode* b){
        return a->val > b->val; // 小根堆
    }
};
priority_queue<ListNode*, vector<ListNode*>, cmp> pq;

小结

应用场景：滑动窗口、子串、子数组
常用方法：双端队列、左右指针

滑动窗口模板：

定义变量：确定需要维护的变量：数之和，最大最小长度，哈希表等
滑动窗口：确定滑动窗口的左右边界，开始滑动窗口
合法更新：在滑动窗口有效的情况下，合法的更新需要维护的变量
非法更新（二次更新）：在滑动窗口无效或者即将无效的情况下，更新维护的变量，并且收缩滑动窗口的左边界，非法更新的两种情况：

滑动窗口的长度是固定的！！！使用 if条件来更新
滑动窗口的长度是可变的！！！使用 while条件来更新

返回与得到答案

int func(vector<int>& nums,int k)
{
	//Step1. 定义维护变量：
	1. unordered_map<char,int> m;	//在需要统计字符或者数字出现的次数的时候，使用哈希表
	1.1 //如果匹配模板是子串，则将待匹配子串先放进哈希表，以便后续验证窗口合法性
	for (const auto &c: p) {
        ori[c]++;
    }
	2. int sum=0,res=0;			//在需要记录整数数组中的子序列和或者其他求和时，使用sum记录每一次滑动窗口的子和，再利用res得到最大的或者最小的结果	
	3. int len=0,start=0;		//得到字符串的字串，len记录字串长度，start标识字串开始位置

	//Step2. 确定滑动窗口的边界，开始滑动：
	int left=0,right=0;
	while (right< n) 	// n: 数组长度	
	{
		//Step3. 合法更新：每进行一次滑动时，必须要更新的变量：如Step1的哈希表，sum,res,len与start等等
		......
		if (满足条件) //满足某一种条件：例如滑动窗口的长度：right-left+1 与某个值相等时，则进行一次判断，保存临时结果
		{
			//更新：res=max(res,sum)  ......
		}
		//Step4: 非法更新
		//(1): 滑动窗口的长度固定：使用if来更新窗口
		if (right>=k-1)//举个例子：子数组的最大平均值，子数组规定长度不能超过k，因此滑窗长度固定
		{
			.....
		}
		//(2)： 滑动窗口的长度不固定，使用while来更新窗口	
		while (right-left+1 > m.size())//举个例子：无重复字符的最长字串，你的窗口长度大于哈希表的长度，则一定含有重复元素，因此更新左边界，使用if
		{
			.....
		}
		right++;//此处可以改为for循环
	}
	return res;//Step5: 返回结果
}