feat: add solutions to lc problem: No.1763

No.1763.Longest Nice Substring

Author: yanglbme

solution/1700-1799/1763.Longest Nice Substring/README.md

@@ -56,12 +56,42 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：枚举 + 哈希表**
+
+我们可以直接枚举所有子串的起点位置 $i$，找到以该位置所在的字符为首字符的所有子串，用哈希表 $s$ 记录子串的所有字符。
+
+如果子串中存在一个字母找不到对应的大写字母或者小写字母，那么不满足条件，否则取最长的且最早出现的子串。
+
+时间复杂度 $O(n^2 \times C)$，空间复杂度 $O(C)$。其中 $n$ 为字符串 $s$ 的长度，而 $C$ 为字符集的大小。
+
+**方法二：枚举 + 位运算**
+
+与方法一类似，我们可以直接枚举所有子串的起点位置 $i$，找到以该位置所在的字符为首字符的所有子串，用两个整数 $lower$ 和 $upper$ 分别记录子串中小写字母和大写字母的出现情况。
+
+判断子串是否满足条件，只需要判断 $lower$ 和 $upper$ 中对应的位是否都为 $1$ 即可。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def longestNiceSubstring(self, s: str) -> str:
+        n = len(s)
+        ans = ''
+        for i in range(n):
+            ss = set()
+            for j in range(i, n):
+                ss.add(s[j])
+                if all(c.lower() in ss and c.upper() in ss for c in ss) and len(ans) < j - i + 1:
+                    ans = s[i: j + 1]
+        return ans
+```
+
 ```python
 class Solution:
     def longestNiceSubstring(self, s: str) -> str:
@@ -74,8 +104,8 @@ class Solution:
                     lower |= 1 << (ord(s[j]) - ord('a'))
                 else:
                     upper |= 1 << (ord(s[j]) - ord('A'))
-                if lower == upper and j - i + 1 > len(ans):
-                    ans = s[i : j + 1]
+                if lower == upper and len(ans) < j - i + 1:
+                    ans = s[i: j + 1]
         return ans
 ```
 
@@ -85,10 +115,39 @@ class Solution:
 
 ```java
 class Solution {
+    public String longestNiceSubstring(String s) {
+        int n = s.length();
+        int k = -1;
+        int mx = 0;
+        for (int i = 0; i < n; ++i) {
+            Set<Character> ss = new HashSet<>();
+            for (int j = i; j < n; ++j) {
+                ss.add(s.charAt(j));
+                boolean ok = true;
+                for (char a : ss) {
+                    char b = (char) (a ^ 32);
+                    if (!(ss.contains(a) && ss.contains(b))) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok && mx < j - i + 1) {
+                    mx = j - i + 1;
+                    k = i;
+                }
+            }
+        }
+        return k == -1 ? "" : s.substring(k, k + mx);
+    }
+}
+```
 
+```java
+class Solution {
     public String longestNiceSubstring(String s) {
         int n = s.length();
-        String ans = "";
+        int k = -1;
+        int mx = 0;
         for (int i = 0; i < n; ++i) {
             int lower = 0, upper = 0;
             for (int j = i; j < n; ++j) {
@@ -98,82 +157,149 @@ class Solution {
                 } else {
                     upper |= 1 << (c - 'A');
                 }
-                if (lower == upper && j - i + 1 > ans.length()) {
-                    ans = s.substring(i, j + 1);
+                if (lower == upper && mx < j - i + 1) {
+                    mx = j - i + 1;
+                    k = i;
                 }
             }
         }
-        return ans;
+        return k == -1 ? "" : s.substring(k, k + mx);
     }
 }
 ```
 
-### **TypeScript**
+### **C++**
 
-```ts
-function longestNiceSubstring(s: string): string {
-    const n = s.length;
-    let ans = '';
-    for (let i = 0; i < n; i++) {
-        let lower = 0,
-            upper = 0;
-        for (let j = i; j < n; j++) {
-            const c = s.charCodeAt(j);
-            if (c > 96) {
-                lower |= 1 << (c - 97);
-            } else {
-                upper |= 1 << (c - 65);
-            }
-            if (lower == upper && j - i + 1 > ans.length) {
-                ans = s.substring(i, j + 1);
+```cpp
+class Solution {
+public:
+    string longestNiceSubstring(string s) {
+        int n = s.size();
+        int k = -1, mx = 0;
+        for (int i = 0; i < n; ++i) {
+            unordered_set<char> ss;
+            for (int j = i; j < n; ++j) {
+                ss.insert(s[j]);
+                bool ok = true;
+                for (auto& a : ss) {
+                    char b = a ^ 32;
+                    if (!(ss.count(a) && ss.count(b))) {
+                        ok = false;
+                        break;
+                    }
+                }
+                if (ok && mx < j - i + 1) {
+                    mx = j - i + 1;
+                    k = i;
+                }
             }
         }
+        return k == -1 ? "" : s.substr(k, mx);
     }
-    return ans;
-}
+};
 ```
 
-### **C++**
-
 ```cpp
 class Solution {
 public:
     string longestNiceSubstring(string s) {
         int n = s.size();
-        string ans = "";
+        int k = -1, mx = 0;
         for (int i = 0; i < n; ++i) {
             int lower = 0, upper = 0;
             for (int j = i; j < n; ++j) {
-                if (islower(s[j]))
-                    lower |= 1 << (s[j] - 'a');
-                else
-                    upper |= 1 << (s[j] - 'A');
-                if (lower == upper && j - i + 1 > ans.size()) ans = s.substr(i, j - i + 1);
+                char c = s[j];
+                if (islower(c)) lower |= 1 << (c - 'a');
+                else upper |= 1 << (c - 'A');
+                if (lower == upper && mx < j - i + 1) {
+                    mx = j - i + 1;
+                    k = i;
+                }
             }
         }
-        return ans;
+        return k == -1 ? "" : s.substr(k, mx);
     }
 };
 ```
 
 ### **Go**
 
 ```go
-func longestNiceSubstring(s string) (ans string) {
-	for i := range s {
-		lower, upper := 0, 0
-		for j := i; j < len(s); j++ {
+func longestNiceSubstring(s string) string {
+	n := len(s)
+	k, mx := -1, 0
+	for i := 0; i < n; i++ {
+		ss := map[byte]bool{}
+		for j := i; j < n; j++ {
+			ss[s[j]] = true
+			ok := true
+			for a := range ss {
+				b := a ^ 32
+				if !(ss[a] && ss[b]) {
+					ok = false
+					break
+				}
+			}
+			if ok && mx < j-i+1 {
+				mx = j - i + 1
+				k = i
+			}
+		}
+	}
+	if k < 0 {
+		return ""
+	}
+	return s[k : k+mx]
+}
+```
+
+```go
+func longestNiceSubstring(s string) string {
+	n := len(s)
+	k, mx := -1, 0
+	for i := 0; i < n; i++ {
+		var lower, upper int
+		for j := i; j < n; j++ {
 			if unicode.IsLower(rune(s[j])) {
 				lower |= 1 << (s[j] - 'a')
 			} else {
 				upper |= 1 << (s[j] - 'A')
 			}
-			if lower == upper && j-i+1 > len(ans) {
-				ans = s[i : j+1]
+			if lower == upper && mx < j-i+1 {
+				mx = j - i + 1
+				k = i
 			}
 		}
 	}
-	return
+	if k < 0 {
+		return ""
+	}
+	return s[k : k+mx]
+}
+```
+
+### **TypeScript**
+
+```ts
+function longestNiceSubstring(s: string): string {
+    const n = s.length;
+    let ans = '';
+    for (let i = 0; i < n; i++) {
+        let lower = 0,
+            upper = 0;
+        for (let j = i; j < n; j++) {
+            const c = s.charCodeAt(j);
+            if (c > 96) {
+                lower |= 1 << (c - 97);
+            } else {
+                upper |= 1 << (c - 65);
+            }
+            if (lower == upper && j - i + 1 > ans.length) {
+                ans = s.substring(i, j + 1);
+            }
+        }
+    }
+    return ans;
 }
 ```