feat: add solutions to lc problem: No.1698

yanglbme · yanglbme · commit be6cd6090790 · 2023-01-02T10:19:50.000+08:00
No.1698.Number of Distinct Substrings in a String
diff --git a/solution/1600-1699/1694.Reformat Phone Number/README.md b/solution/1600-1699/1694.Reformat Phone Number/README.md
@@ -97,7 +97,7 @@
 
 最后将所有组之间加上破折号，返回结果字符串即可。
 
-时间复杂度 $O(n)$。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串长度。
 
 <!-- tabs:start -->
 
diff --git a/solution/1600-1699/1698.Number of Distinct Substrings in a String/README.md b/solution/1600-1699/1698.Number of Distinct Substrings in a String/README.md
@@ -42,6 +42,24 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：暴力枚举**
+
+枚举所有子串，使用哈希表记录不同子串的个数。
+
+时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为字符串长度。
+
+**方法二：字符串哈希**
+
+**字符串哈希**是把一个任意长度的字符串映射成一个非负整数，并且其冲突的概率几乎为 0。字符串哈希用于计算字符串哈希值，快速判断两个字符串是否相等。
+
+取一固定值 BASE，把字符串看作是 BASE 进制数，并分配一个大于 0 的数值，代表每种字符。一般来说，我们分配的数值都远小于 BASE。例如，对于小写字母构成的字符串，可以令 a=1, b=2, ..., z=26。取一固定值 MOD，求出该 BASE 进制对 M 的余数，作为该字符串的 hash 值。
+
+一般来说，取 BASE=131 或者 BASE=13331，此时 hash 值产生的冲突概率极低。只要两个字符串 hash 值相同，我们就认为两个字符串是相等的。通常 MOD 取 2^64，C++ 里，可以直接使用 unsigned long long 类型存储这个 hash 值，在计算时不处理算术溢出问题，产生溢出时相当于自动对 2^64 取模，这样可以避免低效取模运算。
+
+除了在极特殊构造的数据上，上述 hash 算法很难产生冲突，一般情况下上述 hash 算法完全可以出现在题目的标准答案中。我们还可以多取一些恰当的 BASE 和 MOD 的值（例如大质数），多进行几组 hash 运算，当结果都相同时才认为原字符串相等，就更加难以构造出使这个 hash 产生错误的数据。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 为字符串长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -55,6 +73,25 @@ class Solution:
         return len({s[i:j] for i in range(n) for j in range(i + 1, n + 1)})
 ```
 
+```python
+class Solution:
+    def countDistinct(self, s: str) -> int:
+        base = 131
+        n = len(s)
+        p = [0] * (n + 10)
+        h = [0] * (n + 10)
+        p[0] = 1
+        for i, c in enumerate(s):
+            p[i + 1] = p[i] * base
+            h[i + 1] = h[i] * base + ord(c)
+        ss = set()
+        for i in range(1, n + 1):
+            for j in range(i, n + 1):
+                t = h[j] - h[i - 1] * p[j - i + 1]
+                ss.add(t)
+        return len(ss)
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -74,6 +111,30 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int countDistinct(String s) {
+        int base = 131;
+        int n = s.length();
+        long[] p = new long[n + 10];
+        long[] h = new long[n + 10];
+        p[0] = 1;
+        for (int i = 0; i < n; ++i) {
+            p[i + 1] = p[i] * base;
+            h[i + 1] = h[i] * base + s.charAt(i);
+        }
+        Set<Long> ss = new HashSet<>();
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                long t = h[j] - h[i - 1] * p[j - i + 1];
+                ss.add(t);
+            }
+        }
+        return ss.size();
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -94,14 +155,60 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int countDistinct(string s) {
+        using ull = unsigned long long;
+        int n = s.size();
+        ull p[n + 10];
+        ull h[n + 10];
+        int base = 131;
+        p[0] = 1;
+        for (int i = 0; i < n; ++i) {
+            p[i + 1] = p[i] * base;
+            h[i + 1] = h[i] * base + s[i];
+        }
+        unordered_set<ull> ss;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                ss.insert(h[j] - h[i - 1] * p[j - i + 1]);
+            }
+        }
+        return ss.size();
+    }
+};
+```
+
 ### **Go**
 
 ```go
 func countDistinct(s string) int {
-	ss := map[string]bool{}
+	ss := map[string]struct{}{}
 	for i := range s {
 		for j := i + 1; j <= len(s); j++ {
-			ss[s[i:j]] = true
+			ss[s[i:j]] = struct{}{}
+		}
+	}
+	return len(ss)
+}
+```
+
+```go
+func countDistinct(s string) int {
+	n := len(s)
+	p := make([]int, n+10)
+	h := make([]int, n+10)
+	p[0] = 1
+	base := 131
+	for i, c := range s {
+		p[i+1] = p[i] * base
+		h[i+1] = h[i]*base + int(c)
+	}
+	ss := map[int]struct{}{}
+	for i := 1; i <= n; i++ {
+		for j := i; j <= n; j++ {
+			ss[h[j]-h[i-1]*p[j-i+1]] = struct{}{}
 		}
 	}
 	return len(ss)
diff --git a/solution/1600-1699/1698.Number of Distinct Substrings in a String/README_EN.md b/solution/1600-1699/1698.Number of Distinct Substrings in a String/README_EN.md
@@ -48,6 +48,25 @@ class Solution:
         return len({s[i:j] for i in range(n) for j in range(i + 1, n + 1)})
 ```
 
+```python
+class Solution:
+    def countDistinct(self, s: str) -> int:
+        base = 131
+        n = len(s)
+        p = [0] * (n + 10)
+        h = [0] * (n + 10)
+        p[0] = 1
+        for i, c in enumerate(s):
+            p[i + 1] = p[i] * base
+            h[i + 1] = h[i] * base + ord(c)
+        ss = set()
+        for i in range(1, n + 1):
+            for j in range(i, n + 1):
+                t = h[j] - h[i - 1] * p[j - i + 1]
+                ss.add(t)
+        return len(ss)
+```
+
 ### **Java**
 
 ```java
@@ -65,6 +84,30 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int countDistinct(String s) {
+        int base = 131;
+        int n = s.length();
+        long[] p = new long[n + 10];
+        long[] h = new long[n + 10];
+        p[0] = 1;
+        for (int i = 0; i < n; ++i) {
+            p[i + 1] = p[i] * base;
+            h[i + 1] = h[i] * base + s.charAt(i);
+        }
+        Set<Long> ss = new HashSet<>();
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                long t = h[j] - h[i - 1] * p[j - i + 1];
+                ss.add(t);
+            }
+        }
+        return ss.size();
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -85,14 +128,60 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int countDistinct(string s) {
+        using ull = unsigned long long;
+        int n = s.size();
+        ull p[n + 10];
+        ull h[n + 10];
+        int base = 131;
+        p[0] = 1;
+        for (int i = 0; i < n; ++i) {
+            p[i + 1] = p[i] * base;
+            h[i + 1] = h[i] * base + s[i];
+        }
+        unordered_set<ull> ss;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                ss.insert(h[j] - h[i - 1] * p[j - i + 1]);
+            }
+        }
+        return ss.size();
+    }
+};
+```
+
 ### **Go**
 
 ```go
 func countDistinct(s string) int {
-	ss := map[string]bool{}
+	ss := map[string]struct{}{}
 	for i := range s {
 		for j := i + 1; j <= len(s); j++ {
-			ss[s[i:j]] = true
+			ss[s[i:j]] = struct{}{}
+		}
+	}
+	return len(ss)
+}
+```
+
+```go
+func countDistinct(s string) int {
+	n := len(s)
+	p := make([]int, n+10)
+	h := make([]int, n+10)
+	p[0] = 1
+	base := 131
+	for i, c := range s {
+		p[i+1] = p[i] * base
+		h[i+1] = h[i]*base + int(c)
+	}
+	ss := map[int]struct{}{}
+	for i := 1; i <= n; i++ {
+		for j := i; j <= n; j++ {
+			ss[h[j]-h[i-1]*p[j-i+1]] = struct{}{}
 		}
 	}
 	return len(ss)
diff --git a/solution/1600-1699/1698.Number of Distinct Substrings in a String/Solution.go b/solution/1600-1699/1698.Number of Distinct Substrings in a String/Solution.go
@@ -1,8 +1,8 @@
 func countDistinct(s string) int {
-	ss := map[string]bool{}
+	ss := map[string]struct{}{}
 	for i := range s {
 		for j := i + 1; j <= len(s); j++ {
-			ss[s[i:j]] = true
+			ss[s[i:j]] = struct{}{}
 		}
 	}
 	return len(ss)

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`	`1`	`func countDistinct(s string) int {`
`2`		`- ss := map[string]bool{}`
	`2`	`+ ss := map[string]struct{}{}`
`3`	`3`	`for i := range s {`
`4`	`4`	`for j := i + 1; j <= len(s); j++ {`
`5`		`- ss[s[i:j]] = true`
	`5`	`+ ss[s[i:j]] = struct{}{}`
`6`	`6`	`}`
`7`	`7`	`}`
`8`	`8`	`return len(ss)`