87-96-多维动态规划、技巧

LeetCode 热题 100

文章目录

  • LeetCode 热题 100
  • 多维动态规划
    • 87. 中等-不同路径
    • 88. 中等-最小路径和
    • 89. 中等-最长回文子串
    • 90. 中等-最长公共子序列
    • 91. 困难-编辑距离
  • 技巧
    • 92. 简单-只出现一次的数字
    • 93. 简单-多数元素
    • 94. 中等-颜色分类
    • 95. 中等-下一个排列
    • 96. 中等-寻找重复数

本文存储我刷题的笔记。


多维动态规划

87. 中等-不同路径

88. 中等-最小路径和

89. 中等-最长回文子串

90. 中等-最长公共子序列

91. 困难-编辑距离

技巧

92. 简单-只出现一次的数字

87-96-多维动态规划、技巧_第1张图片

我的思路:哈希表

  • 思路:用哈希集合std::unordered_set,遍历所有元素,没遇过就存起来,遇到了就删除哈希集合对应元素,最后哈希集合中剩下的元素就是。
  • 时间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组长度。只需要对数组遍历一次。
  • 空间复杂度: O ( n ) O(n) O(n),最多可能会存储 n / 2 n/2 n/2 个元素。
  • 时间24ms(20.69%),内存19.81MB(8.87%)。
class Solution {
public:
    int singleNumber(std::vector<int>& nums) {
        int len = nums.size();
        std::unordered_set<int> s_num;
        for(int i=0; i<len; i++){
            // 遇到有的就擦除
            if(s_num.count(nums[i])){
               s_num.erase(nums[i]); 
            }
            // 遇到没有的就存起来
            else{
                s_num.emplace(nums[i]);
            }
        }
        // 返回只剩下的最后一个元素
        return *s_num.begin();
    }
};

官方思路一:位运算

  • 思路:因为只有一个数和其他的都不一样,所以将所有数字都进行异或运算,最后就只剩下那个单独的数字。
  • 时间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组长度。只需要对数组遍历一次。
  • 空间复杂度: O ( 1 ) O(1) O(1)
  • 时间8ms(98.78%),内存16.89MB(37.16%)。
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for (auto e: nums) ret ^= e;
        return ret;
    }
};

93. 简单-多数元素

87-96-多维动态规划、技巧_第2张图片

我的思路:哈希表

  • 思路:先统计,再遍历。
  • 时间复杂度: O ( n ) O(n) O(n),其中 n n n 是数组 nums的长度。我们遍历数组 nums一次,又至多遍历一次哈希表(最多包含 n − ⌊ n 2 ⌋ n - \lfloor \dfrac{n}{2} \rfloor n2n 个键值对)。因此总时间复杂度为 O ( n ) O(n) O(n)
  • 空间复杂度: O ( n ) O(n) O(n)。哈希表最多包含 n − ⌊ n 2 ⌋ n - \lfloor \dfrac{n}{2} \rfloor n2n 个键值对,所以占用的空间为 O ( n ) O(n) O(n)
  • 时间20ms(45.10%),内存19.69MB(8.36%)。

注:由于题目保证会出现多数元素,所以也可以将这两个循环放在一起。

class Solution {
public:
    int majorityElement(std::vector<int>& nums) {
        // 使用哈希表统计所有信息
        // 哈希表:键-元素的大小、值-出现的次数
        std::unordered_map<int,int> m_data;
        for(auto num : nums){
            m_data[num] += 1;
        }

        // 找出符合要求的值
        int target = nums.size()/2;
        for(auto it=m_data.begin(); it!=m_data.end(); it++){
            if(it->second > target){
                return it->first;
            }
        }
        return -1;
    }
};

官方思路二:排序

  • 思路:将数组 nums排序,那么下标为 ⌊ n 2 ⌋ \lfloor \dfrac{n}{2} \rfloor 2n 的元素一定是“多数元素”。
  • 时间复杂度: O ( n log ⁡ n ) O(n\log n) O(nlogn)。将数组排序的时间复杂度为 O ( n log ⁡ n ) O(n\log n) O(nlogn)
  • 空间复杂度: O ( log ⁡ n ) O(\log n) O(logn)。如果使用语言自带的排序算法,需要使用 O ( log ⁡ n ) O(\log n) O(logn) 的栈空间。如果自己编写堆排序,则只需要使用 O ( 1 ) O(1) O(1) 的额外空间。
  • 时间20ms(45.10%),内存19.66MB(10.82%)。
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() / 2];
    }
};

官方思路三:随机化

  • 思路:由于“多数元素”过半,那么随机挑选一个是“多数元素”的概率很大。于是代码逻辑为,随机生成一个下标,检查它是否是“多数元素”,如果是就返回,否则继续随机挑选。
  • 时间复杂度:理论上最坏情况下的时间复杂度为 O ( ∞ ) O(\infty) O(),但实际上期望的时间复杂度为 O ( n ) O(n) O(n)
  • 空间复杂度: O ( 1 ) O(1) O(1)。随机方法只需要常数级别的额外空间。
  • 时间16ms(75.52%),内存19.63MB(14.46%)。
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        while (true) {
            int candidate = nums[rand() % nums.size()];
            int count = 0;
            for (int num : nums)
                if (num == candidate)
                    ++count;
            if (count > nums.size() / 2)
                return candidate;
        }
        return -1;
    }
};

官方思路四:分治

  • 思路:分治算法递归求解。将数组分成左右两部分,分别求出左半部分的众数 a1以及右半部分的众数 a2,随后在 a1a2中选出正确的众数。最后的的子问题都是长度为 1的数组。
  • 时间复杂度: O ( n log ⁡ n ) O(n\log n) O(nlogn)。推导见原文“方法四:分治”。
  • 空间复杂度: O ( log ⁡ n ) O(\log n) O(logn)。尽管分治算法没有直接分配额外的数组空间,但在递归的过程中使用了额外的栈空间。算法每次将数组从中间分成两部分,所以数组长度变为 1之前需要进行 O ( log ⁡ n ) O(\log n) O(logn) 次递归,即空间复杂度为 O ( log ⁡ n ) O(\log n) O(logn)
  • 时间28ms(9.03%),内存19.58MB(21.58%)。
class Solution {
    // 统计目标值在指定范围内的次数
    int count_in_range(vector<int>& nums, int target, int lo, int hi) {
        int count = 0;
        for (int i = lo; i <= hi; ++i)
            if (nums[i] == target)
                ++count;
        return count;
    }
    // 分治算法
    int majority_element_rec(vector<int>& nums, int lo, int hi) {
        // 递归最小的子问题:长度为1的数组
        if (lo == hi)
            return nums[lo];
        // 统计左右两部分的“多数元素”
        int mid = (lo + hi) / 2;
        int left_majority = majority_element_rec(nums, lo, mid);
        int right_majority = majority_element_rec(nums, mid + 1, hi);
        // 检查哪个符合出现次数标准
        if (count_in_range(nums, left_majority, lo, hi) > (hi - lo + 1) / 2)
            return left_majority;
        if (count_in_range(nums, right_majority, lo, hi) > (hi - lo + 1) / 2)
            return right_majority;
        return -1;
    }
public:
    int majorityElement(vector<int>& nums) {
        return majority_element_rec(nums, 0, nums.size() - 1);
    }
};

官方思路五:Boyer-Moore 投票算法

  • 思路: 如果我们把众数记为 +1+1+1,把其他数记为 −1-1−1,将它们全部加起来,显然和大于 0,从结果本身我们可以看出众数比其他数多。于是,Boyer-Moore 算法的详细步骤:
  1. 维护一个候选众数 candidate和它出现的次数 count。初始时 candidate为任意值,count0
  2. 遍历数组 nums中的所有元素,对于每个元素 x,在判断 x之前,如果 count的值为 0,我们先将 x的值赋予 candidate,随后我们判断 x

如果 xcandidate相等,那么计数器 count的值增加 1
如果 xcandidate不等,那么计数器 count的值减少 1

  1. 在遍历完成后,candidate即为整个数组的众数。
  • 时间复杂度: O ( n ) O(n) O(n)。Boyer-Moore 算法只对数组进行了一次遍历。
  • 空间复杂度: O ( 1 ) O(1) O(1)。Boyer-Moore 算法只需要常数级别的额外空间。
  • 时间12ms(93.37%),内存19.70MB(6.31%)。
class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int candidate = -1;
        int count = 0;
        for (int num : nums) {
            if (num == candidate)
                ++count;
            else if (--count < 0) {
                candidate = num;
                count = 1;
            }
        }
        return candidate;
    }
};

94. 中等-颜色分类

95. 中等-下一个排列

96. 中等-寻找重复数

我的思路

  • 思路

  • 时间??ms(??%),内存??MB(??%)。


官方思路:

  • 思路

  • 时间??ms(??%),内存??MB(??%)。


你可能感兴趣的:(#,LeetCode刷题,动态规划,算法)