LeetCode3. Longest Substring Without Repeating Characters(C++/Python)

Given a string, find the length of the longest substring without repeating characters.

Example 1:

Input: "abcabcbb"
Output: 3 
Explanation: The answer is "abc", with the length of 3. 

Example 2:

Input: "bbbbb"
Output: 1
Explanation: The answer is"b", with the length of 1.

Example 3:

Input: "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3. 
Note that the answer must be a substring, "pwke"is a subsequence and not a substring.

题目大意：寻找最长的无重复字母的子字符串；

方法一：暴力法

对所有子字符串进行判断，判断其是否为无重复字母的子字符串（有一个测试样例会超时(⊙o⊙)…）

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length();
        if(len == 0)
            return 0;
        for(int i = len; i >= 1; -- i)
            for(int j = 0; j + i <= len; ++ j){
                vector<bool>visit(256, false);
                bool flag = true;
                for(int k = j; k < j + i; ++ k){
                    if(visit[s[k]] == true){
                        flag = false;
                        break;
                    }
                    visit[s[k]] = true;
                }
                if(flag == true)
                    return i;
            }
        return 1;
    }
};

方法二：双指针法

双指针法 i , j ，用j指针进行遍历，利用字母的ASCII码值进行映射，记录是否访问过，如果访问到之前访问过的，则 i 指针前移，一直遍历到与 j 指针相同的字母的后，同时修改 i 遍历过的字母对应的visit数组的值。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length(), i = 0, j = 0, ans = 0;
        vector<bool>visit(256, false);
        while(i < len && j < len){
            if(visit[s[j]] == false){
                visit[s[j++]] = true;
                ans = max(ans, j - i);
            }
            else
                visit[s[i++]] = false;
        }
        return ans;
    }
};

方法三：双指针优化

方法二中移动 i 指针的方式是依次遍历，会导致 i 和 j 指针都遍历了一遍s，可以通过记录每个字符出现的位置，直接得出 i 指针的值，而不用再一次用 i 指针遍历，假设 i 指针要到达 tempi 处，那么 i ~ tempi 之间的pos值如何修改，这儿用到讨巧的方法，我们直接修改 i 的值，而 i ~ tempi 之间的pos值并未修改，但是我们在得tempi 的值的时候，取 i 和 pos[s[j]]较大的值，就相当于i之前的pos的值不再影响 tempi。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int len = s.length(), i = 0, j = 0, ans = 0;
        vector<int>pos(256, -1);
        for(; j < len; ++ j){
            if(pos[s[j]] != -1)
                i = max(pos[s[j]], i);
            pos[s[j]] = j + 1;
            ans = max(ans, j - i + 1);
        }
        return ans;
    }
};

Python

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        pos = [-1] * 256
        i, ans = 0, 0
        for j in range(len(s)):
            i = max(i, pos[ord(s[j])])
            pos[ord(s[j])] = j + 1
            ans = max(ans, j - i + 1)
        return ans