leetcode/nowcoder-huawei-6-双指针

CaCu999

已于 2023-01-09 16:17:12 修改

阅读量230

点赞数

分类专栏： LeetCode/NowCoder 文章标签： leetcode 算法 c++

于 2023-01-06 09:56:42 首次发布

本文链接：https://blog.csdn.net/qq_41940001/article/details/128574023

版权

LeetCode/NowCoder 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

文章介绍了使用双指针解决LeetCode中的两道题目：674.最长连续递增序列和17.最长回文子串。在最长连续递增序列问题中，通过比较相邻元素调整最大长度和结束位置。而在最长回文子串问题中，通过反转子串并对比来寻找符合条件的子串。此外，还提出了28.最小覆盖子串的问题，目标是在给定字符串中找到包含另一个字符串所有字符的最短子串。

摘要由CSDN通过智能技术生成

6.双指针

leecode 674.最长连续递增序列

描述

给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。
连续递增的子序列 可以由两个下标 l 和 r（l < r）确定，如果对于每个 l <= i < r，都有 nums[i] < nums[i + 1] ，那么子序列 [nums[l], nums[l + 1], ..., nums[r - 1], nums[r]] 就是连续递增子序列。 

示例 1：
输入：nums = [1,3,5,4,7]
输出：3
解释：最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为 5 和 7 在原数组里被 4 隔开。 
示例 2：
输入：nums = [2,2,2,2,2]
输出：1
解释：最长连续递增序列是 [2], 长度为1。 

提示：
1 <= nums.length <= 104
-109 <= nums[i] <= 109

思路

指向最大的数字，数字变小时候更新长度值，否则增加

代码

#include <iostream>
using namespace std;
#include <vector>

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if (nums.size() == 0)   return 0;
        int m = 1;
        int n = 1;
        int e = 0;
        for (int i = 1; i < nums.size(); i++) {
            if (nums[i] <= nums[e]) {
                m = max(m, n);
                n = 1;
            } else {
                n++;
            }
            e = i;
        }
        m = max(m, n);
        return m;
    }
};

int main() {
    vector<int> nums = {1,3,5,7};
    Solution sol;
    cout << sol.findLengthOfLCIS(nums) << endl;
    return 0;
}

NC17. 最长回文子串

描述

对于长度为n的一个字符串A（仅包含数字，大小写英文字母），请设计一个高效算法，计算其中最长回文子串的长度。

数据范围：1≤n≤1000
要求：空间复杂度O(1)，时间复杂度O(n^2)
进阶:  空间复杂度O(n)，时间复杂度O(n)

示例1
输入：
	"ababc"
返回值：
	3
说明：
最长的回文子串为"aba"与"bab"，长度都为3

示例2
输入：
	"abbba"
返回值：
	5

示例3
输入：
	"b"
返回值：
	1

描述

确定子串长度，子串和反转子串对比，对比相等直接返回长度

代码

#include <iostream>
using namespace std;
#include <algorithm>

class Solution {
public:
    int getLongestPalindrome(string str) {
        if(str.size() <= 1) return  str.size();
        int len = str.size();
        string revStr;
        while(len) {
            for(int i = 0; i <= str.size() - len; i++) {
                revStr.assign(str.substr(i,len));
                reverse(revStr.begin(),revStr.end());
                if(str.substr(i,len).compare(revStr) == 0)  return len;
            }
            len--;
        }
        return len;
    }
};

int main() {
    string str;
    cin >> str;
    Solution sol;
    cout << sol.getLongestPalindrome(str) << endl;
    return 0;
}

NC28. 最小覆盖子串

描述

给出两个字符串 s 和 t，要求在 s 中找出最短的包含 t 中所有字符的连续子串。

数据范围：0≤∣S∣,∣T∣≤10000，保证s和t字符串中仅包含大小写英文字母
要求：进阶：空间复杂度O(n) ， 时间复杂度O(n)
例如：S="XDOYEZODEYXNZ" T="XYZ"
找出的最短子串为"YXNZ".
注意：
如果 s 中没有包含 t 中所有字符的子串，返回空字符串 “”；
满足条件的子串可能有很多，但是题目保证满足条件的最短的子串唯一。

示例1
输入：
	"XDOYEZODEYXNZ","XYZ"
返回值：
	"YXNZ"
示例2
输入：
	"abcAbA","AA"
返回值：
	"AbA"

思路
- 记录所有t包含的字符
- [low，high]记录范围，外层循环增加high，同时增加len记录包含t的字符个数
- [low, high]有所有t字符时，进入子循环
- 记录最短子串，并不断增加下界。如果下界指向元素存在于t中，len–

代码

#include <iostream>
using namespace std;
#include <algorithm>
#include <map>

class Solution {
public:

    string minWindow(string s, string t) {
        int count[256] = {0};
        for(auto ch:t)
            count[ch]++;
        int minLen = s.size();
        //len记录包含t中字符的个数
        int low = 0, high = 0, len = 0;
        string res;
        for (;high < s.size(); high++) {
            //右移上界，如果包含t元素，len++
            if(count[s[high]]-- > 0)  len++;
            // count[s[high]]--;
            //包含所有t中的字符，进入子循环
            while (len == t.size()) {
                if(high - low + 1 <= minLen) {
                    minLen = high - low + 1;
                    res = s.substr(low, minLen);
                    cout << len <<"     "<< res << endl;
                }
                //移动下界
                printf(">>>>  %c  %d\n",s[low],count[s[low]]);
                if(++count[s[low++]] > 0){
                    len--;
                }
            }
            
        }
        return res;
    }
};

int main() {
    string S,T;
    cin >> S;
    cin >> T; 
    Solution sol;
    cout << sol.minWindow(S,T) << endl;
    return 0;
}