LeetCode01——无重复字符的最长子串

题目

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

示例 1:

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

示例 2:

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

示例 3:

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

解决方案

方法一：暴力法

思路

逐个检查所有的子字符串，看它是否不含有重复的字符。

算法

假设我们有一个函数 boolean allUnique(String substring) ，如果子字符串中的字符都是唯一的，它会返回true，否则会返回false。我们可以遍历给定字符串 s 的所有可能的子字符串并调用函数 allUnique。如果事实证明返回值为true，那么我们将会更新无重复字符子串的最大长度的答案。

现在让我们填补缺少的部分：

为了枚举给定字符串的所有子字符串，我们需要枚举它们开始和结束的索引。假设开始和结束的索引分别为 $\leq i \lt j \leq n0≤i<j≤n （这里的结束索引 jj 是按惯例排除的）。因此，使用 ii 从0到 n - 1n−1 以及 jj 从 i+1i+1 到 nn 这两个嵌套的循环，我们可以枚举出 s 的所有子字符串。$
要检查一个字符串是否有重复字符，我们可以使用集合。我们遍历字符串中的所有字符，并将它们逐个放入 set 中。在放置一个字符之前，我们检查该集合是否已经包含它。如果包含，我们会返回 false。循环结束后，我们返回 true。

扫描二维码关注公众号，回复： 4811436 查看本文章

 1 public class Solution {
 2     public int lengthOfLongestSubstring(String s) {
 3         int n = s.length();
 4         int ans = 0;
 5         for (int i = 0; i < n; i++)
 6             for (int j = i + 1; j <= n; j++)
 7                 if (allUnique(s, i, j)) ans = Math.max(ans, j - i);
 8         return ans;
 9     }
10 
11     public boolean allUnique(String s, int start, int end) {
12         Set<Character> set = new HashSet<>();
13         for (int i = start; i < end; i++) {
14             Character ch = s.charAt(i);
15             if (set.contains(ch)) return false;
16             set.add(ch);
17         }
18         return true;
19     }
20 }

复杂度分析

时间复杂度： $O(n^3)O(n3) 。$

要验证索引范围在

对于给定的 i，对于所有 $\in [i+1, n]j∈[i+1,n] 所耗费的时间总和为：$

$\sum_{i+1}^{n}O(j - i)∑i+1nO(j−i)$

因此，执行所有步骤耗去的时间总和为：

$O\left(\sum_{i = 0}^{n - 1}\left(\sum_{j = i + 1}^{n}(j - i)\right)\right) = O\left(\sum_{i = 0}^{n - 1}\frac{(1 + n - i)(n - i)}{2}\right) = O(n^3)O(∑i=0n−1(∑j=i+1n(j−i)))=O(∑i=0n−12(1+n−i)(n−i))=O(n3)$
空间复杂度：

方法二：滑动窗口

算法

暴力法非常简单。但它太慢了。那么我们该如何优化它呢？

在暴力法中，我们会反复检查一个子字符串是否含有有重复的字符，但这是没有必要的。如果从索引 $s_{ij}sij 已经被检查为没有重复字符。我们只需要检查 s[j]s[j] 对应的字符是否已经存在于子字符串 s_{ij}sij 中。$

要检查一个字符是否已经在子字符串中，我们可以检查整个子字符串，这将产生一个复杂度为 $O(n^2)O(n2)的算法，但我们可以做得更好。$

通过使用 HashSet 作为滑动窗口，我们可以用

滑动窗口是数组/字符串问题中常用的抽象概念。窗口通常是在数组/字符串中由开始和结束索引定义的一系列元素的集合，即

回到我们的问题，我们使用 HashSet 将字符存储在当前窗口

 1 public class Solution {
 2     public int lengthOfLongestSubstring(String s) {
 3         int n = s.length();
 4         Set<Character> set = new HashSet<>();
 5         int ans = 0, i = 0, j = 0;
 6         while (i < n && j < n) {
 7             // try to extend the range [i, j]
 8             if (!set.contains(s.charAt(j))){
 9                 set.add(s.charAt(j++));
10                 ans = Math.max(ans, j - i);
11             }
12             else {
13                 set.remove(s.charAt(i++));
14             }
15         }
16         return ans;
17     }
18 }

复杂度分析

时间复杂度：
空间复杂度：

方法三：优化的滑动窗口

上述的方法最多需要执行 2n 个步骤。事实上，它可以被进一步优化为仅需要 n 个步骤。我们可以定义字符到索引的映射，而不是使用集合来判断一个字符是否存在。当我们找到重复的字符时，我们可以立即跳过该窗口。

也就是说，如果

Java（使用 HashMap）

 1 public class Solution {
 2     public int lengthOfLongestSubstring(String s) {
 3         int n = s.length(), ans = 0;
 4         Map<Character, Integer> map = new HashMap<>(); // current index of character
 5         // try to extend the range [i, j]
 6         for (int j = 0, i = 0; j < n; j++) {
 7             if (map.containsKey(s.charAt(j))) {
 8                 i = Math.max(map.get(s.charAt(j)), i);
 9             }
10             ans = Math.max(ans, j - i + 1);
11             map.put(s.charAt(j), j + 1);
12         }
13         return ans;
14     }
15 }

Java（假设字符集为 ASCII 128）

以前的我们都没有对字符串 s 所使用的字符集进行假设。

当我们知道该字符集比较小的时侯，我们可以用一个整数数组作为直接访问表来替换 Map。

常用的表如下所示：

int [26] 用于字母 ‘a’ - ‘z’或 ‘A’ - ‘Z’
int [128] 用于ASCII码
int [256] 用于扩展ASCII码

 1 public class Solution {
 2     public int lengthOfLongestSubstring(String s) {
 3         int n = s.length(), ans = 0;
 4         int[] index = new int[128]; // current index of character
 5         // try to extend the range [i, j]
 6         for (int j = 0, i = 0; j < n; j++) {
 7             i = Math.max(index[s.charAt(j)], i);
 8             ans = Math.max(ans, j - i + 1);
 9             index[s.charAt(j)] = j + 1;
10         }
11         return ans;
12     }
13 }

复杂度分析

时间复杂度：
空间复杂度（HashMap）：
空间复杂度（Table）：