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

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;
    }
};