探索LeetCode【0003】无重复字符的最长子串（已搞懂，未练习）

方小汪

已于 2023-04-05 08:42:23 修改

阅读量529

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

于 2023-03-18 11:27:51 首次发布

本文链接：https://blog.csdn.net/weixin_42828571/article/details/129633625

版权

LeetCode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

0、题目

题目链接：【0003】无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

1、官方答案（ok）

官方答案

代码1

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 哈希集合，记录每个字符是否出现过
        unordered_set<char> occ;
        int n = s.size();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        // 枚举左指针的位置，初始值隐性地表示为 -1
        for (int i = 0; i < n; ++i) {
        	// 删去左边界的第一个字符
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.erase(s[i - 1]);
            }
            // 只要后面还有字符，且新探索的【那个字符】并不存在于保存字符串中，不断向右探索并存储之，
            // 如果【那个字符】与之前字符相同，那么跳出循环，转到前面代码中删除之
            while (rk + 1 < n && !occ.count(s[rk + 1])) {
                // 不断地移动右指针
                occ.insert(s[rk + 1]);
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = max(ans, rk - i + 1);
        }
        return ans;
    }
};

2、第二个参考答案（ok）

答案链接，并包含了其他与【滑动窗口】和【万能模板】相关的题目和答案

代码2，非常精彩

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.size() == 0) return 0;		// 如果是空字符串，返回0
        unordered_set<char> lookup;		// 参看本链接末尾的讲解
        int maxStr = 0;		// 记录最大长度
        int left = 0;		// 窗口最左边边界
        for(int i = 0; i < s.size(); i++){
        	// 查看新探索的字符是否已经存在于之前的字符串中
            while (lookup.find(s[i]) != lookup.end()){
            	// 如果字符串中已经存在新探索到的【那个字符】，那么进入循环
            	// 删除窗口最左边边界处的字符
            	// 一直循环，一直删，直到最终删掉字符串中早已存在的【那个字符】
                lookup.erase(s[left]);
                // 每进行一次删除时，窗口的最左左边界向右滑一位
                left ++;
            }
            // 最大长度总是取历史上的最大长度
            maxStr = max(maxStr,i-left+1);
            // 如果新探索到的【那个字符】不曾有过，加入之
            lookup.insert(s[i]);
    	}
    	// 返回最大字符长度
        return maxStr;        
    }
};

3、第三个参考答案（需要进一步删减）

链接

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> m(128, 0);
        int ans = 0;
        int i = 0;
        for (int j = 0; j < s.size(); j++) {
            i = max(i, m[s[j]]);
            m[s[j]] = j + 1;
            ans = max(ans, j - i + 1);
        }
        return ans;
    }
};

class Solution {
public:
	int lengthOfLongestSubstring(string s) {
	    vector<int> m(128, 0); //ASCII码范围：0-127
	    int ans = 0;
	    int i = 0;
	    for (int j = 0; j < s.size(); j++) {
	        if(m[s[j]]!=0)  
	        i = max(i, m[s[j]]);
	        
	        m[s[j]] = j + 1;
	        ans = max(ans, j - i + 1);
	    }
	    return ans;
	}
};

增加注释

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
		vector<int> m(128,0);//这个容器为了存当遇到相同的字符(假设是a)时i应该变成的值，即前面那个a的下一个字符
		int ans=0; //最终的子串长度
		int i=0;
		for(int j=0;j<s.size();j++){
			//如果遇到了相同的字符(假设为a)，此时m[s[j]]会又去到同样的存储单元m[a的ASCII码值]
			//因为之前遇到a时已经将这个位置的值改成前面那个a的下一个位置了，所以m[s[j]]大于i，将i更新
		    i=max(i,m[s[j]]);
		    m[s[j]]=j+1;//更新这个位置的值，当下次再遇到该字母时，将i调整到该字母下一个位置的地方
		    ans=max(ans,j-i+1);//更新最终结果值，即没相同字母的子串的字符个数
		}
		return ans;
    }
};

改进注释：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        //创建桶(数组)，设定128个元素对应0-127ASCII码值，全部赋0
        vector<int> m(128, 0);
        //存最大长度
        int maxlen = 0;
        //head表示窗口最左边的字母序号：如果出现重复的，比如两个相同的字母a，上一个a在桶里存的m[s[i]]是a+1表示a的下一个位置
        //那么第二个a出现时，head就=a+1也就是max(head,m[s[i]])，去除了窗口里上一个a，保证窗口里无重复字母
        int head = 0;
        //遍历字符串
        for (int i = 0; i < s.size(); i++) {
            //修改最左边的字母序号head
            head = max(head, m[s[i]]);
            //当前字母对应的ASCII码桶里存下一个位置(i+1)，用于更新head
            m[s[i]] = i + 1;
            //更新长度
            maxlen = max(maxlen, i - head + 1);
        }
        return maxlen;
    }
};

4、第四个参考答案

4.1 解法一，滑动窗口

链接

class Solution
{
public:
    int lengthOfLongestSubstring(string s)
    {
        //s[start,end) 前面包含 后面不包含
        int start(0), end(0), length(0), result(0);
        int sSize = int(s.size());
        while (end < sSize)
        {
            char tmpChar = s[end];
            for (int index = start; index < end; index++)
            {
                if (tmpChar == s[index])
                {
                    start = index + 1;
                    length = end - start;
                    break;
                }
            }

            end++;
            length++;
            result = max(result, length);
        }
        return result;
    }
};

4.2 解法二，利用hashmap优化

链接

class Solution
{
public:
    int lengthOfLongestSubstring(string s)
    {
        //s[start,end) 前面包含 后面不包含
        int start(0), end(0), length(0), result(0);
        int sSize = int(s.size());
        unordered_map<char, int> hash;
        while (end < sSize)
        {
            char tmpChar = s[end];
            //仅当s[start,end) 中存在s[end]时更新start
            if (hash.find(tmpChar) != hash.end() && hash[tmpChar] >= start)
            {
                start = hash[tmpChar] + 1;
                length = end - start;
            }
            hash[tmpChar] = end;

            end++;
            length++;
            result = max(result, length);
        }
        return result;
    }
};

4.3 解法三，利用数组（桶代替hashmap）

链接

class Solution
{
public:
    int lengthOfLongestSubstring(string s)
    {
        //s[start,end) 前面包含 后面不包含
        int start(0), end(0), length(0), result(0);
        int sSize = int(s.size());
        vector<int> vec(128, -1);
        while (end < sSize)
        {
            char tmpChar = s[end];
            //仅当s[start,end) 中存在s[end]时更新start
            if (vec[int(tmpChar)] >= start)
            {
                start = vec[int(tmpChar)] + 1;
                length = end - start;
            }
            vec[int(tmpChar)] = end;

            end++;
            length++;
            result = max(result, length);
        }
        return result;
    }
};

5、解释代码`unordered_set`

上述代码中提到的unordered_set具体如下

unordered_set是C++ STL中的一个容器，用于存储一组不重复的元素，其内部实现是基于哈希表的。unordered_set中的元素是无序的，但是可以通过哈希函数快速查找元素。

unordered_set的用法和其他STL容器类似，可以使用insert()函数向其中插入元素，使用erase()函数删除元素，使用find()函数查找元素等。另外，unordered_set还提供了一些其他的成员函数，如size()、empty()、clear()等。

在使用unordered_set时，需要注意以下几点：

unordered_set中的元素必须是可哈希的，即需要定义哈希函数和相等比较函数。
unordered_set中的元素是无序的，不能通过下标访问元素。
unordered_set中的元素不允许重复，如果插入重复元素会被忽略。

下面是一个使用unordered_set的例子：

#include <iostream>
#include <unordered_set>
using namespace std;
int main()
{
    unordered_set<int> mySet;
    mySet.insert(1);
    mySet.insert(2);
    mySet.insert(3);
    mySet.insert(2); //插入重复元素，会被忽略    
    cout << "mySet size: " << mySet.size() << endl; //输出元素个数    
    if (mySet.find(2) != mySet.end()) //查找元素2        
        cout << "2 is in mySet" << endl;
    else
        cout << "2 is not in mySet" << endl;

    mySet.erase(3); //删除元素3    

    for (auto it = mySet.begin(); it != mySet.end(); ++it) //遍历元素        
        cout << *it << " ";

    cout << endl;
    mySet.clear(); //清空元素    
    cout << "mySet size: " << mySet.size() << endl; //输出元素个数    
    return 0;
}

输出情况为：

mySet size: 3
2 is in mySet
1 2
mySet size: 0

6、拆分文件

如有不足，敬请指正！

6.1 fyo_test.cpp

#include "Solution1.h"
#include<iostream>
#include<string>
#include<fstream>
#include<vector>;
#include<unordered_set>;
#include<cassert>;

using namespace std;

//class Solution {
// public:
//     int lengthOfLongestSubstring(string s) {
//         if (s.size() == 0) return 0;
//         unordered_set<char> lookup;
//         int maxStr = 0;
//         int left = 0;
//         for (int i = 0; i < s.size(); i++) {
//             while (lookup.find(s[i]) != lookup.end()) {
//                 lookup.erase(s[left]);
//                 left++;
//             }
//             maxStr = max(maxStr, i - left + 1);
//             lookup.insert(s[i]);
//         }
//         return maxStr;
//     }
// };

 string stringToString(string input) {
     assert(input.length() >= 2);
     string result;
     for (int i = 1; i < input.length() - 1; i++) {
         char currentChar = input[i];
         if (input[i] == '\\') {
             char nextChar = input[i + 1];
             switch (nextChar) {
             case '\"': result.push_back('\"'); break;
             case '/': result.push_back('/'); break;
             case '\\': result.push_back('\\'); break;
             case 'b': result.push_back('\b'); break;
             case 'f': result.push_back('\f'); break;
             case 'r': result.push_back('\r'); break;
             case 'n': result.push_back('\n'); break;
             case 't': result.push_back('\t'); break;
             default: break;
             }
             i++;
         }
         else {
             result.push_back(currentChar);
         }
     }
     return result;
 }

 int main() {
     string line;
     while (getline(cin, line)) {
         string s = stringToString(line);

         Solution1 sl;
         int ret = sl.lengthOfLongestSubstring(s);

         string out = to_string(ret);
         cout << out << endl;
     }
     return 0;
 }

6.2 Solution1.cpp

#include "Solution1.h"

Solution1::Solution1(){
}

Solution1::~Solution1(){
}

int Solution1::lengthOfLongestSubstring(string s) {
    if (s.size() == 0) return 0;
    unordered_set<char> lookup;
    int maxStr = 0;
    int left = 0;
    for (int i = 0; i < s.size(); i++) {
        while (lookup.find(s[i]) != lookup.end()) {
            lookup.erase(s[left]);
            left++;
        }
        maxStr = max(maxStr, i - left + 1);
        lookup.insert(s[i]);
    }
    return maxStr;
}

6.3 Solution1.h

#pragma once
#ifndef SOLUTION1_H
#define SOLUTION1_H

#include<iostream>
#include<string>
#include<fstream>
#include<vector>
#include<unordered_set>
#include<cassert>

using namespace std;

class Solution1{
public:
    Solution1();
    ~Solution1();
    int lengthOfLongestSubstring(std::string s);
private:
};
#endif