leetcode4-5 题解

最新推荐文章于 2022-03-25 23:56:48 发布

栋次大次

最新推荐文章于 2022-03-25 23:56:48 发布

阅读量190

点赞数

分类专栏： leetcode题解文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_39529413/article/details/103284007

版权

leetcode题解专栏收录该内容

3 篇文章 0 订阅

订阅专栏

leetcode4-5 题解

第四题
- 思路一归并排序
- 思路二：分治法
第五题

leetcode 4-5题题解，用C++实现

第四题

思路一归并排序

采用归并排序，合并为一个nums，然后查找中位数。时间复杂度O(m+n)。

class Solution { //归并排序 
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        double result = 0.0;
        int index1 = 0;
        int index2 = 0;
        int index = 0;
        vector<int> nums(nums1.size()+nums2.size());
        if(nums1.size() == 0 && nums2.size() == 0)
            return result;
        if(nums1.size() == 0)
            return getResult(nums2);
        if(nums2.size() == 0)
            return getResult(nums1);
        while(index1 < nums1.size() && index2 < nums2.size()){
            if(nums1[index1]<nums2[index2]){
                nums[index] = nums1[index1];
                index1++;
            }else{
                nums[index] = nums2[index2];
                index2++;
            }
            index++;
        }
        while(index1 < nums1.size())
            nums[index++] = nums1[index1++];
        while(index2 < nums2.size())
            nums[index++] = nums2[index2++];
        return getResult(nums);
    }
    double getResult(vector<int> &nums){
        double result = 0;
        if(nums.size() % 2 == 0)
            result = (nums[nums.size() /2]  + nums[nums.size()/2-1])/2.0;
        else
            result = nums[nums.size()/2];
        return result;
    }
};

python

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        resLen = len(nums1) + len(nums2)
        kth = int(resLen/2) + 1
        num = [0] * kth # 声明存储排序后结果的list
        i = 0
        j = 0
        for k in range(kth):
            if i == len(nums1): # 当nums1已经排到最后一个元素时，直接将nums2的元素依次加进num中
                num[k] = nums2[j]
                j = j+1
            elif j == len(nums2): #当nums2已经排到最后一个元素时，直接将nums1的元素加到num中
                num[k] = nums1[i]
                i = i+1
            else: #当两个数组均没有检索完，依次将较小的数存进num中
                if nums1[i] < nums2[j]:
                    num[k] = nums1[i]
                    i = i+1
                else:
                    num[k] = nums2[j]
                    j = j+1
        if resLen%2 == 0:
            return(num[kth-2] + num[kth-1])/2
        else:
            return num[kth-1]

思路二：分治法

时间复杂度O(log(m+n))

首先分析一下题目，假设两个有序序列共有n个元素（根据中位数的定义我们要分情况考虑），当n为奇数时，搜寻第(n/2+1)个元素，当n为偶数时，搜寻第(n/2+1)和第(n/2)个元素，然后取他们的均值。进一步的，我们可以把这题抽象为“搜索两个有序序列的第k个元素“。

那如何搜索两个有序序列中第k个元素呢，这里又有个技巧。假设序列都是从小到大排列，对于第一个序列中前p个元素和第二个序列中前q个元素，我们想要的最终结果是：p+q等于k-1,且一序列第p个元素和二序列第q个元素都小于总序列第k个元素。因为总序列中，必然有k-1个元素小于等于第k个元素。这样第p+1个元素或者第q+1个元素就是我们要找的第k个元素。

所以，我们可以通过二分法将问题规模缩小，假设p=k/2，则q=k-p，且p+q=k。如果第一个序列第p个元素小于第二个序列第q个元素，我们不确定二序列第q个元素是大了还是小了，但一序列的前p个元素肯定都小于目标，所以我们将第一个序列前p个元素全部抛弃，形成一个较短的新序列。然后，用新序列替代原先的第一个序列，再找其中的第k-p个元素（因为我们已经排除了p个元素，k需要更新为k-p），依次递归。同理，如果第一个序列第p个元素大于第二个序列第q个元素，我们则抛弃第二个序列的前q个元素。递归的终止条件有如下几种：

较短序列所有元素都被抛弃，则返回较长序列的第k个元素（在数组中下标是k-1）
第一个序列的第p个元素等于第二个序列的q个元素，此时这两个元素也就是总序列的第k个元素
注意
每次递归不仅要更新数组的起始位置，也要更新k的大小

代码

class Solution { //分治算法
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        int k = (m+n)/2;
        if((m+n) % 2 ==0)
            return (findKth(nums1,nums2,0,0,m,n,k) + findKth(nums1,nums2,0,0,m,n,k+1))/2;
        else
            return findKth(nums1,nums2,0,0,m,n,k+1);
        
    }
private:
    double findKth(vector<int> &nums1, vector<int> &nums2, int start1, int start2, int len1, int len2, int k){
        //保证nums1是较短的数组
        if(len1 > len2)
            return findKth(nums2,nums1,start2,start1,len2,len1,k);
        if(len1 == 0){
            return nums2[start2+k-1];
        }
        if(k==1)
            return min(nums1[start1], nums2[start2]);
        int p1 = min(k/2,len1);
        int p2 = k - p1;
        if(nums1[start1+p1-1] < nums2[start2+p2-1]){
            return findKth(nums1,nums2,start1+p1, start2, len1 - p1, len2, k-p1);
        }else if(nums1[start1+p1-1]>nums2[start2+p2-1]){
            return findKth(nums1,nums2,start1,start2+p2,len1,len2-p2,k-p2);
        }
        else{
            return nums1[start1+p1-1];
        }
    }
};

python

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        m = len(nums1)
        n = len(nums2)
        k = int((m+n)/2)
        if (m+n)%2 == 0:
            return (self.findKth(nums1,nums2,0,0,m,n,k) + self.findKth(nums1,nums2,0,0,m,n,k+1))/2
        else:
            return self.findKth(nums1,nums2,0,0,m,n,k+1)
    def findKth(self, nums1: List[int], nums2: List[int], start1: int, start2: int, len1: int, len2: int, k: int) -> float:
         # 保证nums1是较短的数组
        if len1 > len2:
            return self.findKth(nums2,nums1,start2,start1,len2,len1,k)
        if len1 == 0 :
            return nums2[start2+k-1]
        if k==1:
            return min(nums1[start1], nums2[start2])
        p1 = int(min(k/2,len1));
        p2 = k - p1;
        if nums1[start1+p1-1] < nums2[start2+p2-1] :
            return self.findKth(nums1,nums2,start1+p1, start2, len1 - p1, len2, k-p1)
        elif nums1[start1+p1-1]>nums2[start2+p2-1]:
            return self.findKth(nums1,nums2,start1,start2+p2,len1,len2-p2,k-p2)
        else :
            return nums1[start1+p1-1]

第五题

最长回文字符

解法一暴力枚举

第一种方法是暴力枚举，复杂度O(n^3)，应该会超时，没有尝试

解法二动态规划

删除暴力解法中的很多重复的判断。动态规划方程如下：

dp[i][j]表示子串s[i…j]是否是回文
dp[i][i] = true (0 <= i <= n-1); dp[i][i-1] = true (1 <= i <= n-1); 其余的初始化为false
dp[i][j] = (s[i] == s[j] && dp[i+1][j-1] == true)
时间复杂度O（n^{2）,空间O（n}2）。
代码

class Solution { //动态规划
public:
    string longestPalindrome(string s) {
        const int len = s.size();
        if(len <= 1) return s;
        bool dp[len][len]; //dp[i][j]表示s[i...j]是否是回文
        memset(dp, 0, sizeof(dp));
        int resLeft = 0, resRight = 0;
        dp[0][0] = true;
        for(int i=1; i<len; i++){
            dp[i][i] = true;
            dp[i][i-1] = true; //当k=2的时候需要用到这个初始条件
        }
        for(int k=2; k<=len; k++){
            for(int i =0; i<=len-k; i++){
                //枚举子串起始位置
                if(s[i]==s[i+k-1] && dp[i+1][i+k-2]){
                    dp[i][i+k-1] = true;
                    if(resRight - resLeft + 1 < k){
                        resLeft = i;
                        resRight = i+k-1;
                    }
                }
            }
        }
        return s.substr(resLeft, resRight-resLeft+1);
    }
};

解法三中心扩展

以某个元素为中心，分别计算偶数长度的回文最大长度和奇数长度的回文最大长度。时间复杂度O(n^2), 空间O(1)。

代码

class Solution {  // 中心化方法
public:
    string longestPalindrome(string s) {
        const int len = s.size();
        if(len<=1) return s;
        int start, maxLen =0;
        for(int i=1; i<len; i++){
            //寻找以i-1，i,为中心的偶数长度的回文
            int low = i-1, high = i;
            while(low>=0 && high<len && s[low]==s[high]){
                low--;
                high++;
            }
            if(high-low-1 > maxLen){
                maxLen = high-low-1;
                start = low + 1;
            }
            //寻找以i为中心的奇数长度的回文
            low = i-1;
            high = i+1;
            while(low>=0 && high < len && s[low] == s[high]){
                low--;
                high++;
            }
            if(high - low - 1 > maxLen){
                maxLen = high - low -1;
                start = low +1;
            }
        }
        return s.substr(start, maxLen);
    }
};

解法四 Manacher算法

该算法首先对字符串进行预处理，在字符串的每个字符前后都加入一个特殊符号，比如字符串 abcd 处理成 #a#b#c#d#,为了避免处理越界，在字符串首尾加上不同的两个特殊字符(c类型的字符串尾部不用加，因为自带‘\0’)，这样预处理后最终变成$#a#b#c#d#^，经过这样处理后有个好处是原来的偶数长度和奇数长度的回文在处理后的字符串中都是奇数长度。假设处理后的字符串为s。

对于已经预处理好的字符串我们用数组p[i]来记录以字符S[i]为中心的最长回文子串向左/右扩张的长度（包括S[i]）,以字符串“12212321”为例，p数组如下：

s	$	#	1	#	2	#	2	#	1	#	2	#	3	#	2	#	1	#	^
p		1	2	1	2	5	2	1	4	1	2	1	6	1	2	1	2	1

可以看出，P[i]-1正好是原字符串中回文串的总长度,
如果p数组已知，遍历p数组找到最大的p[i]就可以求出最长回文的长度，也可以求出回文的位置

下面给出求p[]数组的方法：
设id是当前求得的最长回文子串中心的位置，mx为当前最长回文子串的右边界（回文子串不包括该右边界），即mx = id + p[id]。记j = 2*id – i ，即 j 是 i 关于 id 的对称点。

1、当i < mx 时。此时可以得出一个非常神奇的结论p[i] >= min(p[2*id - i], mx - i)

如何根据p[j]来求p[i]呢，又要分成两种情况

（1.1）当mx – i > p[j], 这时候以S[j]为中心的回文子串包含在以S[id]为中心的回文子串中，由于 i 和 j 对称，以S[i]为中心的回文子串必然包含在以S[id]为中心的回文子串中，所以 P[i] 至少等于 p[j], 后面的再继续匹配

在这里插入图片描述

注：这里其实p[i]一定等于p[j],后面不用再匹配了。因为如果p[i]后面还可以继续匹配，根据对称性，p[j]也可以继续扩展了

（1.2）当mx – i <= p[j]，以S[j]为中心的回文子串不完全包含于以S[id]为中心的回文子串中，但是基于对称性可知，下图中两个绿框所包围的部分是相同的，也就是说以S[i]为中心的回文子串，其向右至少会扩张到mx的位置，也就是说 P[i] 至少等于 mx - i，至于mx之后的部分是否对称，就只能老老实实去匹配了。

在这里插入图片描述

注：如果mx – i < p[j] ，这时p[i]一定等于mx - i, 因为如果p[i]在mx之后还可以继续匹配，根据对称性，mx之后匹配的点(包括mx)一定会出现在my的前面，这说明p[id]也可以继续扩展了

2、当i >= mx, 无法对p[i]做更多的假设，只能p[i] = 1,然后再去匹配

算法复杂度分析：根据斜体字部分的注释，只有当mx-i = p[j]时以及 i > mx时才要扩展比较，而mx也是在不断扩展的，总体而言每个元素比较次数是n的线性关系，所以时间复杂度为O(n)

代码：

class Solution {   //manachar 算法
public:
    string longestPalindrome(string s) {
        const int len = s.size();
        if(len <= 1) return s;
        string str = preProcess(s); //进行预处理
        int n = str.size(), id = 0, mx = 0;
        vector<int> p(n, 0);
        for(int i = 1; i<n-1; i++){
            p[i] = mx>i ? min(p[2*id - i], mx-i) : 1;
            while(str[i+p[i]] == str[i-p[i]]) p[i]++;
            if(i+p[i]>mx){
                mx = i+p[i];
                id = i;
            }
        }
        // 遍历p 寻找最大回文长度
        int maxLen = 0, index = 0;
        for(int i = 1; i<n-1; i++){
            if(p[i]>maxLen){
                maxLen = p[i];
                index = i;
            }
        }
        return s.substr((index-maxLen)/2, maxLen-1);
    }
    
    //预处理字符串
    string preProcess(const string &s){
        int n = s.size();
        string res;
        res.push_back('$'); //把$放在字符串头部
        res.push_back('#');
        for(int i = 0; i<n; i++){
            res.push_back(s[i]);
            res.push_back('#');
        }
        res.push_back('^');
        return res;
    }
};

参考博客
https://blog.csdn.net/suool/article/details/38383045
https://blog.csdn.net/jek123456/article/details/80022075

栋次大次

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
leetcode4-5 题解

leetcode4-5 题解第四题思路一归并排序思路二：分治法第五题解法一暴力枚举解法二动态规划解法三中心扩展解法四 Manacher算法leetcode 1-3题题解，用C++实现第四题思路一归并排序采用归并排序，合并为一个nums，然后查找中位数。时间复杂度O(m+n)。class Solution { //归并排序 public: double findMe...
复制链接

扫一扫