feat: update solutions: 0003. Longest Substring Without Repeating Chars

Author: yanglbme

README.md

@@ -67,6 +67,7 @@
 
 ### 字符串
 
+- [无重复字符的最长子串](/solution/0000-0099/0003.Longest%20Substring%20Without%20Repeating%20Characters/README.md)
 - [反转字符串中的元音字母](/solution/0300-0399/0345.Reverse%20Vowels%20of%20a%20String/README.md)
 - [字符串转换整数 (atoi)](/solution/0000-0099/0008.String%20to%20Integer%20%28atoi%29/README.md)
 - [赎金信](/solution/0300-0399/0383.Ransom%20Note/README.md)

README_EN.md

@@ -66,6 +66,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 
 ### Strings
 
+- [Longest Substring Without Repeating Characters](/solution/0000-0099/0003.Longest%20Substring%20Without%20Repeating%20Characters/README_EN.md)
 - [Reverse Vowels of a String](/solution/0300-0399/0345.Reverse%20Vowels%20of%20a%20String/README_EN.md)
 - [String to Integer (atoi)](/solution/0000-0099/0008.String%20to%20Integer%20%28atoi%29/README_EN.md)
 - [Ransom Note](/solution/0300-0399/0383.Ransom%20Note/README_EN.md)

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README.md

@@ -33,22 +33,54 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+- 定义一个哈希表存放字符及其出现的位置；
+- 定义 i, j 分别表示不重复子串的开始位置和结束位置；
+- j 向后遍历，若遇到与 `[i, j]` 区间内字符相同的元素，更新 i 的值，此时 `[i, j]` 区间内不存在重复字符，计算 res 的最大值。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        res, chars = 0, dict()
+        i = j = 0
+        while j < len(s):
+            if s[j] in chars:
+                # chars[s[j]]+1 可能比 i 还小，通过 max 函数来锁住左边界
+                # e.g. 在"tmmzuxt"这个字符串中，遍历到最后一步时，最后一个字符't'和第一个字符't'是相等的。如果没有 max 函数，i 就会回到第一个't'的索引0处的下一个位置
+                i = max(i, chars[s[j]] + 1)
+            res = max(res, j - i + 1)
+            chars[s[j]] = j
+            j += 1
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int res = 0;
+        Map<Character, Integer> chars = new HashMap<>();
+        for (int i = 0, j = 0; j < s.length(); ++j) {
+            char c = s.charAt(j);
+            if (chars.containsKey(c)) {
+                // chars.get(c)+1 可能比 i 还小，通过 max 函数来锁住左边界
+                // e.g. 在"tmmzuxt"这个字符串中，遍历到最后一步时，最后一个字符't'和第一个字符't'是相等的。如果没有 max 函数，i 就会回到第一个't'的索引0处的下一个位置
+                i = Math.max(i, chars.get(c) + 1);
+            }
+            chars.put(c, j);
+            res = Math.max(res, j - i + 1);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0003.Longest Substring Without Repeating Characters/README_EN.md

@@ -63,13 +63,37 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        res, chars = 0, dict()
+        i = j = 0
+        while j < len(s):
+            if s[j] in chars:
+                i = max(i, chars[s[j]] + 1)
+            res = max(res, j - i + 1)
+            chars[s[j]] = j
+            j += 1
+        return res
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int res = 0;
+        Map<Character, Integer> chars = new HashMap<>();
+        for (int i = 0, j = 0; j < s.length(); ++j) {
+            char c = s.charAt(j);
+            if (chars.containsKey(c)) {
+                i = Math.max(i, chars.get(c) + 1);
+            }
+            chars.put(c, j);
+            res = Math.max(res, j - i + 1);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0003.Longest Substring Without Repeating Characters/Solution.java

@@ -1,15 +1,15 @@
 class Solution {
     public int lengthOfLongestSubstring(String s) {
-        Map<Character, Integer> map = new HashMap<>();
-        int max = 0;
-        for (int fast = 0, slow = 0; fast < s.length(); fast ++) {
-            if (map.containsKey(s.charAt(fast))) {
-                int target = map.get(s.charAt(fast)) + 1;
-                slow = target < slow ? slow : target;
+        int res = 0;
+        Map<Character, Integer> chars = new HashMap<>();
+        for (int i = 0, j = 0; j < s.length(); ++j) {
+            char c = s.charAt(j);
+            if (chars.containsKey(c)) {
+                i = Math.max(i, chars.get(c) + 1);
             }
-            map.put(s.charAt(fast), fast);
-            max = Math.max(max, fast - slow + 1);
+            chars.put(c, j);
+            res = Math.max(res, j - i + 1);
         }
-        return max;
+        return res;
     }
 }

solution/0000-0099/0003.Longest Substring Without Repeating Characters/Solution.py

@@ -1,12 +1,11 @@
 class Solution:
-    def lengthOfLongestSubstring(self, s: str):
-        max = 0
-        length = len(s)
-        substr = ""
-        for i in range(0, length):
-            index = substr.find(s[i])
-            if index > -1:
-                substr = substr[index + 1:]
-            substr += s[i]
-            max = (max if (max > len(substr)) else len(substr))
-        return max
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        res, chars = 0, dict()
+        i = j = 0
+        while j < len(s):
+            if s[j] in chars:
+                i = max(i, chars[s[j]] + 1)
+            res = max(res, j - i + 1)
+            chars[s[j]] = j
+            j += 1
+        return res