LeetCode 热题 HOT 100 第一天

算法解析：经典编程问题解决方案

最新推荐文章于 2023-02-21 17:43:53 发布

原创最新推荐文章于 2023-02-21 17:43:53 发布 · 131 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法

Leetcode刷题专栏收录该内容

40 篇文章

订阅专栏

这篇博客探讨了五个经典的编程问题，包括两数之和、两数相加、无重复字符的最长子串、寻找两个正序数组的中位数以及最长回文子串。通过哈希表、链表操作和双指针等算法，提供了高效的解决方案，并展示了如何在C++中实现这些算法。此外，还涉及了一个正则表达式匹配问题，展示了动态规划的应用。

1. 两数之和

思路：哈希

每一个数查找之前是否出现过，返回两个数的下标
时间复杂度为 $O (n)$

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

2. 两数相加

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        auto dummy = new ListNode(-1), cur = dummy;
        int t = 0;
        while (l1 || l2 || t){
            if (l1) t += l1->val, l1 = l1->next;
            if (l2) t += l2->val, l2 = l2->next;
            cur = cur->next = new ListNode(t % 10);
            t /= 10;
        }
        return dummy->next;
    }
};

3. 无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0, l = 0, r = 0, n = s.size();
        if (n == 0) return 0;
        unordered_map<char, int> hash;
        while (r < n){
            if (hash.count(s[r])){
                while (hash[s[r]]){
                    hash[s[l ++ ]] -- ;
                }
            }
            res = max(res, r - l + 1);
            hash[s[r ++ ]] = 1;
        }
        return res;
    }
};

4. 寻找两个正序数组的中位数

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int total = nums1.size() + nums2.size();
        if (total & 1) {
            return find(nums1, 0, nums2, 0, total / 2 + 1);
        }
        else {
            int l = find(nums1, 0, nums2, 0, total / 2);
            int r = find(nums1, 0, nums2, 0, total / 2 + 1);
            return (l + r) / 2.0;
        }
    }

    int find(vector<int>& nums1, int i, vector<int>& nums2, int j, int k) {
        // 第一个数组元素较少
        if (nums1.size() - i > nums2.size() - j) return find(nums2, j, nums1, i, k);
        // 某个数组没有元素
        if (nums1.size() == i) return nums2[j + k - 1];
        // 递归终止条件k == 1，返回两个数组中较小的元素
        if (k == 1) return min(nums1[i], nums2[j]);
        // 判断每个数组当前k / 2元素可以取到哪一个位置
        int si = min((int)nums1.size(), i + k / 2), sj = j + k / 2;
        if (nums1[si - 1] > nums2[sj - 1]) {
            return find(nums1, i, nums2, sj, k - k / 2);
        }
        else {
            return find(nums1, si, nums2, j, k - (si - i));
        }
    }
};

5. 最长回文子串

双指针 $O(n^2)$

class Solution {
public:
    string longestPalindrome(string s) {
        string res;
        for (int i = 0; i < s.size(); i ++ ) {
            int l = i - 1, r = i + 1;
            while (l >= 0 && r < s.size() && s[l] == s[r]) l -- , r ++ ;
            if (res.size() < r - l - 1) res = s.substr(l + 1, r - l - 1);

            l = i, r = i + 1;
            while (l >= 0 && r < s.size() && s[l] == s[r]) l -- , r ++ ;
            if (res.size() < r - l - 1) res = s.substr(l + 1, r - l - 1);
        }
        return res;
    }
};

10. 正则表达式匹配

class Solution {
public:
    bool isMatch(string s, string p) {
        int n = s.size(), m = p.size();
        s = ' ' + s, p = ' ' + p;
        vector<vector<bool>> f(n + 1, vector<bool>(m + 1));
        f[0][0] = true;
        for (int i = 0; i <= n; i ++ ) {
            for (int j = 1; j <= m; j ++ ) {

            }
        }
        return f[n][m];
    }
};