无重复字符的最长子串

题目

给定一个字符串 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 由英文字母、数字、符号和空格组成

解答

这题需要注意的是，暴力解法每轮循环需要取子串最大值，优化解法从重复的字符继续遍历

public class LengthOfLongestSubstring {
    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring("dvdf"));
    }

    /**
     * 暴力解法
     * 
     * @param s
     * @return
     */
    public static int lengthOfLongestSubstring1(String s) {
        char[] chars = s.toCharArray();
        // 最大子串
        int max = 0;
        // 临时存储子串
        List tempStr = new ArrayList<>();
        for (int j = 0; j < chars.length; ) {
            for (int i = j; i < chars.length; i++) {
                if (tempStr.indexOf(chars[i]) == -1) {
                    // 如果子串中不包含，则添加
                    tempStr.add(chars[i]);
                    continue;
                }
                // 如果子串中包含，则对比子串
                max = tempStr.size() > max ? tempStr.size() : max;
                tempStr = new ArrayList();
                j += 1;
                break;
            }
        }
        return max;
    }

    /**
     * 优化解法 （从前面重复的字符继续遍历，减少遍历次数）
     * @param s
     * @return
     */
    public static int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) {
            return 0;
        }
        int res = 0;
        // 使用HashMap，记录前面是否出现过重复的字符
        Map<Character, Integer> map = new HashMap<>();
        // 使用dp数组，记录以该字符为结尾的前面
        int[] dp = new int[40005];
        char[] sChar = s.toCharArray();
        dp[0] = 1;
        map.put(sChar[0], 0);
        res = 1;
        for (int j = 1; j < sChar.length; j++) {
            if (!map.containsKey(sChar[j])) {
                map.put(sChar[j], j);
                dp[j] = dp[j - 1] + 1;
                res = Math.max(res, dp[j]);
            } else {
                // 若出现了重复的字符，那么应该从前面重复的字符的下一位开始向后继续查找
                j = map.get(sChar[j]) + 1;
                map = new HashMap<Character, Integer>();
                map.put(sChar[j], j);
                dp[j] = 1;
                res = Math.max(res, dp[j]);
            }
        }
        return res;
    }
}