LeetCode 3. Longest Substring Without Repeating Characters题解

题目

3. Longest Substring Without Repeating Characters

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.

---

分析

本题要求给出一个方法lengthOfLongestSubstring，方法要求：
传入一个参数：字符串s。
传出s中不含重复字符的最长连续子串。

思路1：简单遍历

先给出一种基本思路：先暴力再优化
假定字符串s的长度为n，我们要找到最长的连续不重复子串，就从长度为n的字符串找起。如果中间出现重复字符，再找长度为n-1的字符串，然后是n-2的……以此类推。
附上实现该思路的java代码：

public int lengthOfLongestSubstring(String s) {
        int length = s.length();
        for(int len=length;len>=1;len--){//len：截取的字符串长度
            for(int head=0;head<=length-len;head++){//head：截取的字符串的首位
                String substring = s.substring(head,head+len);//截取的字符串
                char [] subchars = substring.toCharArray();//将截取字符串转为char数组
                int charLen = subchars.length;
                boolean duplications = false;//判断字串中是否出现字符重复
                for(int i=0;i<charLen-1;i++){
                    for(int j=i+1;j<charLen;j++){
                        if(subchars[j]==subchars[i]){
                            duplications = true;
                            break;
                        }
                    }
                    if(duplications)break;
                }
                if(!duplications){
                    return len;
                }
            }
        }
        return 0;
    }

但是如果这样就能解决了，这道题也就不是Medium难度的了~
那么如何优化呢：
我们可以考虑将len的初始值优化。len的最大可能值可以从“字符串长度”缩减为“字符串中不重复字符的个数”。
以下为优化后代码：

public int lengthOfLongestSubstring(String s) {
        int length = s.length();

        //先统计不同字符数，以提升算法总体速度
        int characters = 1;
        char [] chars = s.toCharArray();
        boolean flag = false;//判断是否出现重复
        for(int i=1;i<length;i++){
            flag = false;
            for(int j=0;j<i;j++){
                if(chars[i] == chars[j]){
                    flag = true;
                    continue;
                }
            }
            if(!flag)characters++;
        }

        //以下只需考虑长度≤characters的字符串即可
        for(int len=characters;len>=1;len--){//len：截取的字符串长度
            for(int head=0;head<=length-len;head++){//head：截取的字符串的首位
                String substring = s.substring(head,head+len);//截取的字符串
                char [] subchars = substring.toCharArray();//将截取字符串转为char数组
                int charLen = subchars.length;
                boolean duplications = false;//判断字串中是否出现字符重复
                for(int i=0;i<charLen-1;i++){
                    for(int j=i+1;j<charLen;j++){
                        if(subchars[j]==subchars[i]){
                            duplications = true;
                            break;
                        }
                    }
                    if(duplications)break;
                }
                if(!duplications){
                    return len;
                }
            }
        }
        return 0;
    }

成功AC。

思路2：设置移动窗口

我们维护两个变量：
left：移动窗口的左边界
res：字符不重复的连续子串的最大长度

而移动窗口的右边界，我们放在循环中遍历（依次加1）

例如字符串abcdbfcgh，思路图解如下：

从最左端开始设置移动窗口：

而后逐步向右扩展（在不遇到重复字符的前提下）：



在这里我们遇到了b，发现和前面出现了重复。
此时把左边界left更新为原来b的下标（也就是1），移动整个窗口：

而后继续向右扩展：

后面遇到c，又出现重复问题。跟之前一样的方法解决。将left更新为原来c的下标2，移动窗口：

继续扩展：


最后得到res的最大值：6。
代码请参考题解部分。

---

题解

java实现1

public int lengthOfLongestSubstring(String s) {
        int length = s.length();

        //先统计不同字符数，以提升算法总体速度
        int characters = 1;
        char [] chars = s.toCharArray();
        boolean flag = false;//判断是否出现重复
        for(int i=1;i<length;i++){
            flag = false;
            for(int j=0;j<i;j++){
                if(chars[i] == chars[j]){
                    flag = true;
                    continue;
                }
            }
            if(!flag)characters++;
        }

        //以下只需考虑长度≤characters的字符串即可
        for(int len=characters;len>=1;len--){//len：截取的字符串长度
            for(int head=0;head<=length-len;head++){//head：截取的字符串的首位
                String substring = s.substring(head,head+len);//截取的字符串
                char [] subchars = substring.toCharArray();//将截取字符串转为char数组
                int charLen = subchars.length;
                boolean duplications = false;//判断字串中是否出现字符重复
                for(int i=0;i<charLen-1;i++){
                    for(int j=i+1;j<charLen;j++){
                        if(subchars[j]==subchars[i]){
                            duplications = true;
                            break;
                        }
                    }
                    if(duplications)break;
                }
                if(!duplications){
                    return len;
                }
            }
        }
        return 0;
    }

java实现2

public int lengthOfLongestSubstring(String s) {
        int[] m = new int[256];//存储字符出现的位置，例如m['A']=0,说明字符A出现在下标为0的位置
        Arrays.fill(m, -1);
        int res = 0, left = -1;
        for (int i = 0; i < s.length(); ++i) {
            left = Math.max(left, m[s.charAt(i)]);
            m[s.charAt(i)] = i;
            res = Math.max(res, i - left);
        }
        return res;
    }

java实现3

//与“java实现2”是几乎完全一样的思路，只不过用hashset
public int lengthOfLongestSubstring(String s) {
        int res = 0, left = 0, right = 0;
        HashSet<Character> t = new HashSet<Character>();
        while (right < s.length()) {
            if (!t.contains(s.charAt(right))) {
                t.add(s.charAt(right++));
                res = Math.max(res, t.size());
            } else {
                t.remove(s.charAt(left++));
            }
        }
        return res;
    }

c++实现

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int m[256] = {0}, res = 0, left = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (m[s[i]] == 0 || m[s[i]] < left) {
                res = max(res, i - left + 1);
            } else {
                left = m[s[i]];
            }
            m[s[i]] = i + 1;
        }
        return res;
    }
};