leetcode-最长无重复子串/搜索插入的位置/报数

本文链接：https://blog.csdn.net/qq_40123329/article/details/88686214

一最长无重复子串

法一

剑指offer的思路是动态规划。

（1）用一个position数组(128)，存放所有字符最后一次出现的位置。

（2）用dp[i]表示以第i个字符结尾的无重复子串的最大长度：

如果第i个字符之前没有出现过，那么dp[i]=dp[i-1]+1

如果第i个字符之前出现过，那么就判断2个字符最近的距离d=i-position[ch]与dp[i-1]的关系

1）d<=dp[i-1]；dp[i]=d

2）d>dp[i-1]；dp[i]=dp[i-1]+1

（3）遍历dp数组求最值即可。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>

using namespace std;

int getloogestlen(const string &str)
{
    int len=str.size();
    if(len==0)
        return 0;
    int dp[len];
    memset(dp,0,sizeof(dp));

    int position[128];
    for(int i=0;i<128;i++)
    {
        position[i]=-1;
    }

    dp[0]=1;
    position[str[0]-0]=0;
    for(int i=1;i<len;i++)
    {
        int pos=str[i]-0;
        if(pos==-1)
            dp[i]=dp[i-1]+1;
        else   //出现过
        {
            int d=i-position[pos];
            if(d>dp[i-1])
                dp[i]=dp[i-1]+1;
            else
                dp[i]=d;
        }
        position[pos]=i;
    }
    int maxlen=-1;
    for(int i=0;i<len;i++)
    {
        if(maxlen<dp[i])
            maxlen=dp[i];
    }
    return maxlen;
}

int main()
{
    string str;
    cin>>str;
    int len=getloogestlen(str);
    cout<<len;
    return 0;
}

法二

跟动态规划的思路有点像。

（1）用position数组记录字符最后一次出现的位置

（2）用res来记录最长的长度，用left来记录局部无重复子串的起始位置

（3）遍历字符串，如果当前字符和局部起始字符一样，就把边界left加1。如果当前字符出现的位置在left后面，那么left就更新为当前字符出现的位置加1。然后更新res即可。

有点像动态规划，即每一次遍历到的字符都把它当作最右边边界，计算以它为字符串结尾时最长无重复字串的长度

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len=s.size();
        if(len==0)
            return 0;
        int a[128];
        fill(a,a+128,-1);
        int res=0;
        int left=0;
        for(int i=0;i<len;i++)
        {
            if(left==a[s[i]-0])
                left+=1;
            else if(left<a[s[i]-0])
                left=a[s[i]-0]+1;

            res=max(res,i-left+1);
            a[s[i]-0]=i;
        }
        return res;
    }
};

法三：滑动窗口双指针

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size()<=1)
            return s.size();
        
        int left=0,right=0;
        int maxlen=-1;
        unordered_map<char,int> window;

        while(right<s.size())
        {
            char ch=s[right];
            window[ch]++;
            right++;
            while(window[ch]>1)
            {
                
                char ch2=s[left];
                window[ch2]--;
                left++;
            }
            if(right-left>maxlen)
                maxlen=right-left;
        }
        return maxlen;
    }
};

关于滑动窗口

二搜索插入的位置

题目链接：https://leetcode-cn.com/problems/search-insert-position/

法一二分查找

注意二分查找的边界：https://blog.csdn.net/qq_40123329/article/details/87797712

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        if(nums.size()==0)
            return 0;
        else if(target>nums[nums.size()-1])
            return nums.size();
        else if(target<nums[0])
            return 0;
        else
        {
            int left=0,right=nums.size()-1;
            while(left<=right)
            {
                int mid=left+(right-left)/2;
                if(nums[mid]==target)
                    return mid;
                else if(nums[mid]<target)
                    left=mid+1;
                else
                    right=mid-1;
            }
            return left;
        }        
    }
};

可以先把几个特殊情况罗列出来，之后再解决普通和一般的情况。

法二遍历数组

同样先罗列几种特殊情况，然后再一次遍历数组即可，如果target小于或等于目前元素，返回目前元素的下标即可，否则返回nums.size();

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        if(nums.size()==0)
            return 0;
        else if(target>nums[nums.size()-1])
            return nums.size();
        else if(target<nums[0])
            return 0;
        else
        {
            for(int i=0;i<nums.size();i++)
            {
                if(target<=nums[i])
                    return i;
            }
            return nums.size();
        } 
    }
};

三报数

题目链接：https://leetcode-cn.com/problems/count-and-say/

理解题意很重要：只要碰到连续的数字，就用几个几来表示，否则就是1个几。譬如111221的下一个就是312211

所以程序就变为了遍历字符换，找到来连续相等的数字及个数。

class Solution {
public:
    string countAndSay(int n) {
        if(n==1)
            return "1";
        string str="11";
        for(int i=2;i<n;i++)
        {
            char pre=str[0];    //前一个字符
            int cnt=1;           //重复个数   
            string temp="";
            for(int j=1;j<str.size();j++)
            {
                if(str[j]==pre)     //当前字符与之前字符相同，进行计数
                    cnt++;
                else
                {
                    //char ch='0'+cnt;
                    temp.push_back('0'+cnt);
                    //temp=temp+ch+pre;
                    temp.push_back(pre);
                    pre=str[j];
                    cnt=1;
                }
            }
            //不要忘记添加最后一次记录的数据
            //char ch='0'+cnt;
            temp.push_back('0'+cnt);
            //temp=temp+ch+pre;
            temp.push_back(pre);
            str=temp;
        }
        return str;  
    }
};

有几个细节：

（1）数字变字符：