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

LeetCode 热题 100

本文存储我刷题的笔记。

---

多维动态规划

87. 中等-不同路径

88. 中等-最小路径和

89. 中等-最长回文子串

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

91. 困难-编辑距离

技巧

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

我的思路：哈希表

• 思路：用哈希集合std::unordered_set，遍历所有元素，没遇过就存起来，遇到了就删除哈希集合对应元素，最后哈希集合中剩下的元素就是。
• 时间复杂度：$O(n)$，其中 $n$ 是数组长度。只需要对数组遍历一次。
• 空间复杂度：$O(n)$，最多可能会存储 $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)$，其中 $n$ 是数组长度。只需要对数组遍历一次。
• 空间复杂度：$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. 简单-多数元素

我的思路：哈希表

• 思路：先统计，再遍历。
• 时间复杂度：$O(n)$，其中 $n$ 是数组 nums的长度。我们遍历数组 nums一次，又至多遍历一次哈希表（最多包含 $n-\lfloor \frac{n}{2}\rfloor$ 个键值对）。因此总时间复杂度为 $O(n)$。
• 空间复杂度：$O(n)$。哈希表最多包含 $n-\lfloor \frac{n}{2}\rfloor$ 个键值对，所以占用的空间为 $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排序，那么下标为 $\lfloor \frac{n}{2}\rfloor$ 的元素一定是“多数元素”。
• 时间复杂度：$O(n\log n)$。将数组排序的时间复杂度为 $O(n\log n)$。
• 空间复杂度：$O(\log n)$。如果使用语言自带的排序算法，需要使用 $O(\log n)$ 的栈空间。如果自己编写堆排序，则只需要使用 $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(\infty )$，但实际上期望的时间复杂度为 $O(n)$。
• 空间复杂度：$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，随后在 a1和 a2中选出正确的众数。最后的的子问题都是长度为 1的数组。
• 时间复杂度：$O(n\log n)$。推导见原文“方法四：分治”。
• 空间复杂度：$O(\log n)$。尽管分治算法没有直接分配额外的数组空间，但在递归的过程中使用了额外的栈空间。算法每次将数组从中间分成两部分，所以数组长度变为 1之前需要进行 $O(\log n)$ 次递归，即空间复杂度为 $O(\log n)$。
• 时间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为任意值，count为 0；
2. 遍历数组 nums中的所有元素，对于每个元素 x，在判断 x之前，如果 count的值为 0，我们先将 x的值赋予 candidate，随后我们判断 x：

如果 x与 candidate相等，那么计数器 count的值增加 1；
如果 x与 candidate不等，那么计数器 count的值减少 1。

3. 在遍历完成后，candidate即为整个数组的众数。

• 时间复杂度：$O(n)$。Boyer-Moore 算法只对数组进行了一次遍历。
• 空间复杂度：$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(??%)。