算法闭关修炼百题计划（一）

多看优秀的代码一定没有错，此篇博客属于个人学习记录

1.两数之和
2.前k个高频元素
3.只出现一次的数字
4.数组的度
5.最佳观光组合
6.整数反转
7.缺失的第一个正数
8.字符串中最多数目的子序列
9.k个一组翻转链表
10.反转链表II
11. 公司命名
12.合并区间
13.快速排序
14.数字中的第k个最大元素
15.归并排序
16.岛屿数量
17.每种字符至少取k个
18.螺旋矩阵II
19.旋转图像
20.删除数组中重复的元素II

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> heap;
        for(int i = 0; i < nums.size(); i ++){
            if(heap.find(target - nums[i]) != heap.end()) return {heap[target - nums[i]], i};
            heap[nums[i]] = i;
        }
        return {};
    }
};

2.前k个高频元素

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按任意顺序返回答案。

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> valToFreq;
        vector<int> result;
        for(auto num : nums){
            valToFreq[num] ++;
        }
        vector<pair<int,int>> vec(valToFreq.begin(), valToFreq.end());
        sort(vec.begin(),vec.end(),[](pair<int,int>& a, pair<int,int>& b){
            return a.second > b.second;
        });
        for(auto pair:vec){
            if(k > 0){
                result.push_back(pair.first);   
            }
            k--;
        }
        return result;
    }
};

3.只出现一次的数字

给你一个非空整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

不能用sort也不能新开空间！
小tips：

一个数和它本身做异或运算结果为 0，即 a ^ a = 0；
一个数和 0 做异或运算的结果为它本身，即 a ^ 0 = a。
对于这道题目，我们只要把所有数字进行异或，成对儿的数字就会变成 0，落单的数字和 0 做异或还是它本身，所以最后异或的结果就是只出现一次的元素。

class Solution {
public:
    int singleNumber(std::vector<int>& nums) {
        int res = 0;
        for (int n : nums) {
            res ^= n;
        }
        return res;
    }
};

4.数组的度

给定一个非空且只包含非负数的整数数组 nums，数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

class Solution {
public:
    const int N = 50010;
    int findShortestSubArray(vector<int>& nums) {
        int n = nums.size(), maxP = 0, ans = 0x3f3f3f3f;
        //统计频率
        unordered_map<int, int> umap;
        //统计每个元素出现的最早和最晚位置
        vector<int> first(N, -1), last(N, -1);
        for(int i = 0; i < nums.size(); i ++){
            umap[nums[i]]++;
            maxP = max(maxP, umap[nums[i]]);
            if(first[nums[i]] == -1) first[nums[i]] = i;
            last[nums[i]] = i;
        }
        for(auto t : nums){
            if(umap[t] == maxP) ans = min(ans, last[t] - first[t] + 1);
        }
        return ans;

    }
};

5.最佳观光组合

给你一个正整数数组 values，其中 values[i] 表示第 i 个观光景点的评分，并且两个景点 i 和 j 之间的距离为 j - i。
一对景点（i < j）组成的观光组合的得分为 values[i] + values[j] + i - j ，也就是景点的评分之和减去它们两者之间的距离。
返回一对观光景点能取得的最高分。

class Solution {
public:
    int maxScoreSightseeingPair(vector<int>& values) {
        //求value[i] + value[j] + i - j的max
        //相当于求value[i] + i, 和value[j] - j的最大值, i < j
        //所以只需要遍历一次
        int maxScore = INT_MIN, left = values[0];
        for(int i = 1; i < values.size(); i ++){
            maxScore = max(maxScore, values[i] - i + left);
            left = max(left, values[i] + i);
        }
        return maxScore;
    }
};

6.整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−2³¹, 2³¹ − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

class Solution {
public:
    int reverse(int x) {
        long long res = 0;  // 使用 long long 避免溢出
        int sign = (x < 0) ? -1 : 1;  // 根据 x 的符号确定结果的符号
        x = abs(x);  // 只处理正数，避免负号干扰
        
        while (x != 0) {
            res = res * 10 + x % 10;  // 反转数字
            x /= 10;  // 去除最低位
            if (res > INT_MAX) return 0;  // 检查溢出
        }
        
        return sign * res;  // 应用符号并返回结果
    }
};

7.缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

这个最小的正整数一定在[1，nums.size() + 1]之间，为什么。想一想

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        unordered_map<int, int> umap;
        for(int i = 0; i < nums.size(); i++){
            umap[nums[i]]++;
        }
        for(int i = 1; i <= nums.size(); i ++){
            if(umap[i] == 0) return i;
        }
        return nums.size()+1;
    }
};

8.字符串中最多数目的子序列

给你一个下标从 0 开始的字符串 text 和另一个下标从 0 开始且长度为 2 的字符串 pattern ，两者都只包含小写英文字母。

你可以在 text 中任意位置插入一个字符，这个插入的字符必须是 pattern[0] 或者 pattern[1] 。注意，这个字符可以插入在 text 开头或者结尾的位置。

请你返回插入一个字符后，text 中最多包含多少个等于 pattern 的子序列。

子序列指的是将一个字符串删除若干个字符后（也可以不删除），剩余字符保持原本顺序得到的字符串。

比如：
输入：text = “abdcdbc”, pattern = “ac”
输出：4

思路：
首先考虑不加的情况，怎么计算子序列？
使用两个变量 cnt0 和 cnt1 分别记录 pattern[0] 和 pattern[1] 出现了多少次，使用 ans 记录答案数量。

遍历字符串，如果当前字符和 pattern[1] 相同，那么ans += cnt0（这是因为之前的每个pattern[0]都可以和当前字符组成pattern，并且cnt1 += 1；

如果当前字符和pattern[0]相同，那么cnt0 += 1。

现在再考虑加上字符，会有什么变化？
如果要添加pattern[0]到字符串中，那么肯定要将pattern[0]添加到字符串开头，这样后面每个pattern[1]都可以和开头新增的这个pattern[0]组成pattern，答案数量增加cnt1（有多少个pattern[1]就能多组成多少个pattern）；

如果要添加pattern[1]到字符串中，那么肯定要添加到字符串尾，这样答案数量就会增加cnt0。

也就是说，往字符串中添加字符，最多可以令答案增加max(cnt0，cnt1)

typedef long long ll;
class Solution{
public:
	ll maximumSubsequenceCount(string text, string pattern) {
		ll ans = 0;
		ll cnt0 = 0, cnt1 = 0;
		//for计算不加的情况,顺便记录cnt01值
		for(char c : text){
			if(c == pattern[1]){
				cnt1++;
				ans += cnt0;
			}
			if(c == pattern[0]){
				cnt0++;
			}
		}
		return ans + max(cnt0, cnt1);
	}
};

9.k个一组翻转链表

题目要求输入 head，reverseKGroup 函数能够把以 head 为头的这条链表进行翻转。

我们要充分利用这个递归函数的定义，把原问题分解成规模更小的子问题进行求解。
先翻转以head开头的k个元素，将第k+1个元素作为head递归调用 reverseKGroup 函数。

然后还需要将两个过程的结果连起来
在这里插入图片描述

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(head == nullptr) return nullptr;
        //区间[a,b)包含k个待翻转的元素
        ListNode* a = head;
        ListNode* b = head;
        for(int i = 0; i < k; i ++){
            if(b ==  nullptr) return head;
            b = b->next;
        }
        //翻转前k个
        ListNode* newHead = reverse(a, b);
        //翻转前后连起来
        a->next = reverseKGroup(b, k);
        return newHead;
    }
    //[a,b)
    ListNode* reverse(ListNode* a, ListNode* b){
        ListNode* pre, *cur, *tmp;
        pre = nullptr;
        cur = a;
        tmp = a;
        while(cur != b){
            tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

10.反转链表II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回反转后的链表。

假如left == 1，需要反转的部分从链表的第一个节点就开始，那么翻转后链表的头结点将发生变化，使用dummy可以特殊处理这种情况。

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* p0 = dummy;
        for(int i = 1; i < left; i ++) p0 = p0->next;
        ListNode* pre = nullptr;
        ListNode* cur = p0->next;
        for(int i = 0; i < right - left + 1; i ++){
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        p0->next->next = cur;
        p0->next = pre;
        return dummy->next;
        
        
    }
};

11. 公司命名

在这里插入图片描述
难得一批，但是看懂了

思路：
按照首字母来统计后半部分字符串的集合，如果2个集合之间的元素可以互换首字母，那么只要满足A集合中的没有在B集合出现过即可。

class Solution {
public:
    long long distinctNames(vector<string>& ideas) {
        // 使用数组存储每个首字母对应的尾部部分集合
        vector<unordered_set<string>> sets(26);
        
        // 将 ideas 按首字母分类存入对应的集合
        for (const string& idea : ideas) {
            sets[idea[0] - 'a'].insert(idea.substr(1));
        }

        long long ans = 0;

        // 双重循环比较不同首字母的集合
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < i; j++) {
                int m = 0;
                // m 统计两个集合中相同尾部部分的个数
                for (const string& s : sets[i]) {
                    if (sets[j].count(s)) {
                        m++;
                    }
                }
                // 计算有效组合
                ans += (long long)(sets[i].size() - m) * (sets[j].size() - m);
            }
        }

        return ans * 2;
    }
};

12.合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

注意他的for是怎么遍历的

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        //按照start排序
        sort(intervals.begin(), intervals.end(),[](vector<int> a, vector<int> b){return a[0] < b[0];});
        vector<vector<int>> res;
        //把第一个元素push进去
        res.push_back(intervals[0]);
        for(int i = 1; i < intervals.size(); i ++){
            //区间重叠
            if(res.back()[1] >= intervals[i][0]){
                res.back()[1] = max(res.back()[1], intervals[i][1]);
            }
            //区间不重叠
            else{
                res.push_back(intervals[i]);
            }
        }
        return res;
    }
};

13.快速排序

快排就是分治，给一个基准值，左边都小于这个基准值，右边都大于这个基准值
分别排序左右，合并就是有序数组了
注意mid = nums[(l + r) / 2]，而不是mid = (l + r) / 2，不要用索引直接用值

class Solution {
public:
    void quick_sort(vector<int>& nums, int l, int r){
        if(l >= r) return;
        int left = l - 1, right = r + 1, mid = nums[(l + r) / 2];
        while(left < right){
            do left ++; while(nums[left] < mid);
            do right--;while(nums[right] > mid);
            if(left < right) swap(nums[left], nums[right]);
        }
        quick_sort(nums, l, right);
        quick_sort(nums, right + 1, r);

    }
    vector<int> sortArray(vector<int>& nums) {
        quick_sort(nums, 0, nums.size() - 1);
        return nums;
    }
};

14.数字中的第k个最大元素

真的很想sort，但是这道题考频这么高，不可能让你调用库函数…

如果对原数组排序，再返回倒数第k个位置，这样复杂度是O(nlogn)
其实可以更快
在快排中，每次经过划分后，一定可以确定一个元素的最终位置，即x的最终位置是q，并且a[l…q - 1]中的每个元素小于等于a[q]，且a[q]小于等于a[q + 1…r]中的每个元素，所以只要某次划分的q为倒数第k个下标的时候，我们就找到了答案，只需关注这点。

class Solution {
public:
    int quickselect(vector<int> &nums, int l, int r, int k) {
        if (l == r)
            return nums[k];
        int mid = nums[(l + r)/2], i = l - 1, j = r + 1;
        while (i < j) {
            do i++; while (nums[i] < mid);
            do j--; while (nums[j] > mid);
            if (i < j)
                swap(nums[i], nums[j]);
        }
        if (k <= j) return quickselect(nums, l, j, k);
        else return quickselect(nums, j + 1, r, k);
    }

    int findKthLargest(vector<int> &nums, int k) {
        int n = nums.size();
        return quickselect(nums, 0, n - 1, n - k);
    }
};

15.归并排序

如果说快排是前序，那么归并就是后序，一个是先计算再递归，一个是先递归再计算
两个都属于分治算法

void merge_sort(vector<int>& nums, int lo, int hi){
	if(lo >= hi) return;
	int mid = (lo + hi) >> 1;
	merge_sort(nums, lo, mid);
    merge_sort(nums, mid + 1, hi);

    vector<int> tmp(hi - lo + 1); // 创建一个新的 tmp 数组
    int k = 0;
    int i = lo, j = mid + 1;
    while(i <= mid && j <= hi){
        if(nums[i] > nums[j]){
                tmp[k++] = nums[j++];
            }
            else{
                tmp[k++] = nums[i++];
            }
     }
    while(i <= mid) tmp[k++] = nums[i++];
    while(j <= hi) tmp[k++] = nums[j++];

    for(int i = lo, j = 0; i <= hi && j < k; i ++, j ++){
        nums[i] = tmp[j];
    }
}

16.岛屿数量

class Solution {
private:
    int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};
    void dfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y){
        for(int i = 0; i < 4; i ++){//4个方向的1全标记true
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue;
            if(!visited[nextx][nexty] && grid[nextx][nexty] == '1'){
                visited[nextx][nexty] = true;
                dfs(grid, visited, nextx, nexty);
            }
        }
    }
public:
    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size(), m = grid[0].size();
        vector<vector<bool>> visited(n, vector<bool>(m, false));
        int res = 0;
        for(int i = 0; i < n; i ++){
            for(int j = 0; j < m; j ++){
                if(!visited[i][j] && grid[i][j] == '1'){
                    res++;
                    dfs(grid, visited, i, j);
                }
            }
        }
        return res;
    }
};

17.每种字符至少取k个

给你一个由字符 ‘a’、‘b’、‘c’ 组成的字符串 s 和一个非负整数 k 。每分钟，你可以选择取走 s 最左侧还是最右侧的那个字符。

你必须取走每种字符至少 k 个，返回需要的最少分钟数；如果无法取到，则返回 -1 。

两边不好想，用滑动窗口想中间
怎么看外面字符呢，用一个tar数组，初始化为-k，for遍历++，tar中存的就是比k多的数量
滑动窗口内的数字，和tar里面留的数字比较，滑动窗口的数字小于tar中的，说明两侧这个字母的数量>k，滑动窗口的数字大于tar中的，说明两侧这个字母小于k

什么时候缩小窗口：因为当窗口中某个字符的数量超过 tar 时，就意味着在剩余的字符串中，该字符的数量将少于 k，这不符合题目要求。tar[i] 表示的是在可以移除的字符中，每种字符最多能移除的数量（即总数量减去 k）。因此，在滑动窗口中，我们需要确保窗口中每种字符的数量不超过 tar[i]。

class Solution {
public:
    int takeCharacters(string s, int k) {
        vector<int> tar(3, -k);  // 初始化目标数组为-k
        for (char c : s) tar[c - 'a']++;  // 计数数组

        // 如果任意字符计数小于0，则无法形成有效子串
        if (tar[0] < 0 || tar[1] < 0 || tar[2] < 0) return -1;
        
        // 如果所有字符恰好达到k次，返回整个字符串长度
        if (tar[0] == 0 && tar[1] == 0 && tar[2] == 0) return s.length();

        int l = 0, r = 0, res = 0;
        vector<int> cnt(3, 0);  // 计数当前窗口中各字符的数量
        while (r < s.length()) {
            cnt[s[r++] - 'a']++;  // 扩展窗口右边界
            // 当窗口中任一字符数量超过tar时，收缩窗口左边界
            while (cnt[0] > tar[0] || cnt[1] > tar[1] || cnt[2] > tar[2]) {
                cnt[s[l++] - 'a']--;
            }
            // 更新最大子串长度
            res = max(res, r - l);
        }
        // 返回除去最短有效子串后的剩余长度
        return s.length() - res;
    }
};

18.螺旋矩阵II

给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。

四个方向循环的表达式 dirIdx = (dirIdx + 1) % 4; 是一种非常高效且常用的方式来实现这种循环控制：

dirIdx + 1：这部分是将当前的方向索引增加1，以便移动到下一个方向。
取模运算符 % 用来实现循环效果。因为有四个方向，所以取模4。这意味着当 dirIdx 从3增加1变为4时，4 % 4 的结果是0，从而将方向索引重置为0（即向右方向），形成一个循环。

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty()) return {}; // 处理空矩阵的情况

        int n = matrix.size();
        int m = matrix[0].size();
        vector<int> res;
        vector<vector<int>> direction = {
            {0, 1},  // 向右移动
            {1, 0},  // 向下移动
            {0, -1}, // 向左移动
            {-1, 0}  // 向上移动
        };
        vector<vector<bool>> seen(n, vector<bool>(m, false));
        int i = 0, j = 0, dirIdx = 0; // dirIdx 用来控制方向

        for (int k = 0; k < m * n; k++) {
            res.push_back(matrix[i][j]);
            seen[i][j] = true;
            int nexti = i + direction[dirIdx][0];
            int nextj = j + direction[dirIdx][1];
            
            // 检查是否需要转向：下一步是否出界或已访问
            if (nexti >= 0 && nexti < n && nextj >= 0 && nextj < m && !seen[nexti][nextj]) {
                i = nexti;
                j = nextj;
            } else {
                // 调整方向
                dirIdx = (dirIdx + 1) % 4; // 四个方向循环
                i += direction[dirIdx][0];
                j += direction[dirIdx][1];
            }
        }
        return res;
    }
};

19.旋转图像

90度旋转
在这里插入图片描述
要求原地旋转，不另开数组

其实是个数学问题
先上下对称翻转，再主对角线翻转
在这里插入图片描述

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size() ;
        //首先进行上下翻转
        for( int i = 0 ; i < n/2 ; i ++ ){
            swap(matrix[ i ], matrix[ n - i - 1]) ; 
        }
        //然后进行对角线翻转
        for( int i = 0 ; i < n ; i ++ ){
            for( int j = i ; j < n ;j ++ ){
                swap(matrix[i][j],matrix[j][i]) ;
            }
        }

    }
};

20.删除数组中重复的元素II

有重复的全删掉，一个也不留

需要dummy node
初始化cur指向dummy node
每次循环看下一个节点和下下节点的值是不是一样的，如果是一样的，就嵌套一个while，不一样，cur就移动

这里嵌套while的方法无敌，仔细学

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = head;
        ListNode* cur = dummy;
        while(cur && cur->next && cur->next->next){
            //先把这个值存下来
            int num = cur->next->val;
            if(cur->next->next->val == num){
                //可能不止2个
                while(cur->next && cur->next->val == num){
                    cur->next = cur->next->next;
                }
            }
            else cur = cur->next;
        }
        return dummy->next;
    }
};