剑指Offer48—最长不含重复字符的字符串

剑指offer48

题意

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

解法1—动态规划

• 状态定义： 设动态规划列表 dp ，dp[j] 代表以字符 s[j] 为结尾的 “最长不重复子字符串” 的长度。

• 转移方程： 固定右边界 j ，设字符 s[j] 左边距离最近的相同字符为 s[i]，即 s[i] = s[j] 。

  • 当 i < 0，即 s[j]  左边无相同字符，则 dp[j] = dp[j-1] + 1；

  • 当 dp[j - 1] < j - i ，说明字符 s[i] 在 子字符串 dp[j-1] 区间之外 ，则 dp[j] = dp[j - 1] + 1；

  • 当 dp[j−1]≥j−i ，说明字符 s[i] 在子字符串 dp[j-1] 区间之中 ，则 dp[j] 的左边界由 s[i] 决定，即 dp[j] = j - i；

    • 注意：由于s[i]是重复元素，所以dp[j]= j -i，≠ j-i+1。

  • 

• 返回值： max(dp) ，即全局的 “最长不重复子字符串” 的长度。

 空间复杂度优化：

• 由于返回值是取 dp 列表最大值，因此可借助变量 tmp 存储 dp[j] ，变量 res 每轮更新最大值即可。
• 此优化可节省 dp 列表使用的 O(N) 大小的额外空间。

C++实现

class Solution 
{
public:
    int lengthOfLongestSubstring(string s) 
    {
        if(s.size()<=1)
            return s.size();
        unordered_map<char,int> hash;   //记录字符与下标的关系
        int tmp=-0,res=0;    //初始化tmp记录dp[j]、res记录最大值
        for(int j=0;j<s.size();++j)
        {
            //如果当前遍历的字符没有与之重复的字符
            if(hash.find(s[j])==hash.end())
            {
                tmp=tmp+1;  // dp[j]=ap[j-1]+1;
            }
           else 
           {
               int i = hash[s[j]];
               tmp = tmp<(j-i)?tmp+1:j-i;
           }
           hash[s[j]]=j;    //更新hash
           res=res>tmp?res:tmp;
        }
        return res;
    }
};

解法2—滑动窗口

利用双指针 left和i 。保证滑动窗口 (left,i] 区间没有重复的字符，滑动窗口长度为 i-left。

注意滑动窗口是左开右闭！

由于取不到left所处的元素，所以初始时 left=-1 ,i从0开始遍历。

向右遍历字符串，如果没有遇到重复的字符，则不含重复字符的子字符串的长度就为i -left，i然后一直增加。当出现和前面重复的字符时，将left指针移到重复元素中下标最大值处，每次遇到重复的字符时，left都要更新。

在每一轮遍历的时候，都要更新滑动窗口的最大长度，最后返回这个最大长度即可。

C++实现1

class Solution 
{
public:
    int lengthOfLongestSubstring(string s) 
    {
        if(s.size()<=1)
            return s.size();
        unordered_map<char,int> hash;   //记录字符与下标的关系
        int left=-1,i=0;    //初始化滑动窗口
        int max=0;  //记录滑动窗口的最大长度
        for(i=0;i<s.size();++i)
        {
            //如果当前遍历的字符和之前滑动窗口的元素重复了，就要更新left
            if(hash.find(s[i])!=hash.end())
            {
                left=left>hash[s[i]]?left:hash[s[i]];    //left更新为重复元素下标的最大值
            }
            hash[s[i]]=i;
            max=(i-left)>max?(i-left):max;  //记录滑动窗口的最大值
        }
        return max;
    }
};

C++实现2

class Solution 
{
public:
    int lengthOfLongestSubstring(string s) 
    {
        int res=0;
        unordered_set<char> uset;
        int i=0,j=0;
        while(j<s.size())
        {
            char ch = s[j];
            if(uset.find(ch)!=uset.end())
            {
                //有重复字符了
                while(i<=j&&(uset.find(ch)!=uset.end()))
                {
                    uset.erase(s[i]);
                    i++;
                }
            }
            else
            {
                uset.insert(ch);
                res = res>(j-i+1)?res:(j-i+1);
                j++;
            }
        }
        return res;
    }
};