LeetCode 热题 HOT 100 第五天

最新推荐文章于 2025-11-25 14:21:24 发布

原创最新推荐文章于 2025-11-25 14:21:24 发布 · 119 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划 #算法

Leetcode刷题专栏收录该内容

40 篇文章

订阅专栏

本文介绍了如何通过旋转二维矩阵的巧妙操作，结合对角线和垂直翻转实现旋转，并展示了如何利用哈希映射解决字母异位词分组问题。同时涉及动态规划在最大子序和中的应用，以及维护跳跃边界在跳跃游戏中的策略。

21. 旋转图像

思路

一次性旋转不行，先对角线翻转，再选择上下翻转

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for (int i = 0; i < n; i ++ ) {
            for (int j = 0; j < i; j ++ )
                swap(matrix[i][j], matrix[j][i]);
        }

        for (int i = 0; i < n; i ++ ) {
            for (int j = 0, k = n - 1; j < k; j ++ , k -- )
                swap(matrix[i][j], matrix[i][k]);
        }
    }
};

22. 字母异位词分组

思路

对每一个单词排序，使用哈希映射到每一个分组

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> hash;
        for (auto& str : strs) {
            string s = str;
            sort(s.begin(), s.end());
            hash[s].push_back(str);
        }

        vector<vector<string>> res;
        for (auto& t : hash) res.push_back(t.second);
        return res;
    }
};

23. 最大子序和

思路：动态规划

集合：以 $n u m s [i]$ 结尾的子序列最大值
转移：不包含和包含前面的字符取最大值，空间压缩

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int maxn = nums[0], n = nums.size(), pre = nums[0];
        for (int i = 1; i < nums.size(); i ++ )
        {
            int cur = max(pre + nums[i], nums[i]);
            maxn = max(cur, maxn);
            pre = cur;
        }
        return maxn;
    }
};

24. 跳跃游戏

思路

维护最大跳跃的位置

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();
        int res = 0;
        for (int i = 0; i < n; i ++ )
        {
            if (i <= res)
                res = max(res, i + nums[i]);
            if (res >= n - 1) return true;
        }
        return false;
    }
};

25. 合并区间

思路

左端点排序， $v e c t o r$ 按照第一关键词升序排序，归并区间

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> res;
        sort(intervals.begin(), intervals.end());
        int l = intervals[0][0], r = intervals[0][1];
        for (int i = 1; i < intervals.size(); i ++ ) {
            if (intervals[i][0] <= r) {
                r = max(r, intervals[i][1]);
            }
            else {
                res.push_back({l, r});
                l = intervals[i][0], r = intervals[i][1];
            }
        }

        res.push_back({l, r});
        return res;
    }
};