feat: add solutions to lc problem: No.3597

No.3697.Partition String

Author: yanglbme

solution/3500-3599/3597.Partition String/README.md

@@ -188,32 +188,339 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3597.Pa
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：哈希表 + 模拟
+
+我们可以用一个哈希表 $\textit{vis}$ 来记录已经出现过的段。然后我们遍历字符串 $s$，逐字符构建当前段 $t$，直到该段之前未曾出现过。每当我们构建出一个新的段时，就将其加入到结果列表中，并将其标记为已经出现过。
+
+遍历结束后，返回结果列表即可。
+
+时间复杂度 $O(n \times \sqrt{n})$，空间复杂度 $O(n)$，其中 $n$ 是字符串 $s$ 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def partitionString(self, s: str) -> List[str]:
+        vis = set()
+        ans = []
+        t = ""
+        for c in s:
+            t += c
+            if t not in vis:
+                vis.add(t)
+                ans.append(t)
+                t = ""
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public List<String> partitionString(String s) {
+        Set<String> vis = new HashSet<>();
+        List<String> ans = new ArrayList<>();
+        String t = "";
+        for (char c : s.toCharArray()) {
+            t += c;
+            if (vis.add(t)) {
+                ans.add(t);
+                t = "";
+            }
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
+class Solution {
+public:
+    vector<string> partitionString(string s) {
+        unordered_set<string> vis;
+        vector<string> ans;
+        string t = "";
+        for (char c : s) {
+            t += c;
+            if (!vis.contains(t)) {
+                vis.insert(t);
+                ans.push_back(t);
+                t = "";
+            }
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func partitionString(s string) (ans []string) {
+	vis := make(map[string]bool)
+	t := ""
+	for _, c := range s {
+		t += string(c)
+		if !vis[t] {
+			vis[t] = true
+			ans = append(ans, t)
+			t = ""
+		}
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function partitionString(s: string): string[] {
+    const vis = new Set<string>();
+    const ans: string[] = [];
+    let t = '';
+    for (const c of s) {
+        t += c;
+        if (!vis.has(t)) {
+            vis.add(t);
+            ans.push(t);
+            t = '';
+        }
+    }
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- solution:start -->
+
+### 方法二：字符串哈希 + 哈希表 + 模拟
 
+我们可以使用字符串哈希来加速段的查找。具体地，我们可以为每个段计算一个哈希值，并将其存储在一个哈希表中。这样，我们就可以在常数时间内判断一个段是否已经出现过。
+
+具体地，我们首先根据字符串 $s$ 创建一个字符串哈希类 $\textit{Hashing}$，该类支持计算字符串的哈希值。然后，我们遍历字符串 $s$，用两个指针 $l$ 和 $r$ 来表示当前段的起始和结束位置（下标从 $1$ 开始）。每次扩展 $r$，我们计算当前段的哈希值 $x$，如果该哈希值不在哈希表中，则将其加入结果列表，并将其哈希值标记为已经出现过。否则，我们继续扩展 $r$，直到找到一个新的段。
+
+遍历结束后，返回结果列表即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$，其中 $n$ 是字符串 $s$ 的长度。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Hashing:
+    __slots__ = ["mod", "h", "p"]
+
+    def __init__(
+        self, s: Union[str, List[str]], base: int = 13331, mod: int = 998244353
+    ):
+        self.mod = mod
+        self.h = [0] * (len(s) + 1)
+        self.p = [1] * (len(s) + 1)
+        for i in range(1, len(s) + 1):
+            self.h[i] = (self.h[i - 1] * base + ord(s[i - 1])) % mod
+            self.p[i] = (self.p[i - 1] * base) % mod
+
+    def query(self, l: int, r: int) -> int:
+        return (self.h[r] - self.h[l - 1] * self.p[r - l + 1]) % self.mod
+
+
+class Solution:
+    def partitionString(self, s: str) -> List[str]:
+        hashing = Hashing(s)
+        vis = set()
+        l = 1
+        ans = []
+        for r, c in enumerate(s, 1):
+            x = hashing.query(l, r)
+            if x not in vis:
+                vis.add(x)
+                ans.append(s[l - 1 : r])
+                l = r + 1
+        return ans
+```
+
+#### Java
+
+```java
+class Hashing {
+    private final long[] p;
+    private final long[] h;
+    private final long mod;
+
+    public Hashing(String word) {
+        this(word, 13331, 998244353);
+    }
+
+    public Hashing(String word, long base, int mod) {
+        int n = word.length();
+        p = new long[n + 1];
+        h = new long[n + 1];
+        p[0] = 1;
+        this.mod = mod;
+        for (int i = 1; i <= n; i++) {
+            p[i] = p[i - 1] * base % mod;
+            h[i] = (h[i - 1] * base + word.charAt(i - 1)) % mod;
+        }
+    }
+
+    public long query(int l, int r) {
+        return (h[r] - h[l - 1] * p[r - l + 1] % mod + mod) % mod;
+    }
+}
+
+class Solution {
+    public List<String> partitionString(String s) {
+        Hashing hashing = new Hashing(s);
+        Set<Long> vis = new HashSet<>();
+        List<String> ans = new ArrayList<>();
+        for (int l = 1, r = 1; r <= s.length(); ++r) {
+            long x = hashing.query(l, r);
+            if (vis.add(x)) {
+                ans.add(s.substring(l - 1, r));
+                l = r + 1;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Hashing {
+private:
+    vector<long long> p;
+    vector<long long> h;
+    long long mod;
+
+public:
+    Hashing(const string& word, long long base = 13331, long long mod = 998244353) {
+        int n = word.size();
+        p.resize(n + 1);
+        h.resize(n + 1);
+        p[0] = 1;
+        this->mod = mod;
+        for (int i = 1; i <= n; i++) {
+            p[i] = (p[i - 1] * base) % mod;
+            h[i] = (h[i - 1] * base + word[i - 1]) % mod;
+        }
+    }
+
+    long long query(int l, int r) const {
+        return (h[r] - h[l - 1] * p[r - l + 1] % mod + mod) % mod;
+    }
+};
+
+class Solution {
+public:
+    vector<string> partitionString(const string& s) {
+        Hashing hashing(s);
+        unordered_set<long long> vis;
+        vector<string> ans;
+        int l = 1;
+        for (int r = 1; r <= (int) s.size(); ++r) {
+            long long x = hashing.query(l, r);
+            if (!vis.contains(x)) {
+                vis.insert(x);
+                ans.push_back(s.substr(l - 1, r - l + 1));
+                l = r + 1;
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+type Hashing struct {
+	p, h []int64
+	mod  int64
+}
+
+func NewHashing(s string, base, mod int64) *Hashing {
+	n := len(s)
+	p := make([]int64, n+1)
+	h := make([]int64, n+1)
+	p[0] = 1
+	for i := 1; i <= n; i++ {
+		p[i] = p[i-1] * base % mod
+		h[i] = (h[i-1]*base + int64(s[i-1])) % mod
+	}
+	return &Hashing{p, h, mod}
+}
+
+func (hs *Hashing) Query(l, r int) int64 {
+	return (hs.h[r] - hs.h[l-1]*hs.p[r-l+1]%hs.mod + hs.mod) % hs.mod
+}
+
+func partitionString(s string) (ans []string) {
+	n := len(s)
+	hashing := NewHashing(s, 13331, 998244353)
+	vis := make(map[int64]bool)
+	l := 1
+	for r := 1; r <= n; r++ {
+		x := hashing.Query(l, r)
+		if !vis[x] {
+			vis[x] = true
+			ans = append(ans, s[l-1:r])
+			l = r + 1
+		}
+	}
+	return
+}
+```
 
+#### TypeScript
+
+```ts
+class Hashing {
+    private p: bigint[];
+    private h: bigint[];
+    private mod: bigint;
+
+    constructor(s: string, base: bigint = 13331n, mod: bigint = 998244353n) {
+        const n = s.length;
+        this.mod = mod;
+        this.p = new Array<bigint>(n + 1).fill(1n);
+        this.h = new Array<bigint>(n + 1).fill(0n);
+        for (let i = 1; i <= n; i++) {
+            this.p[i] = (this.p[i - 1] * base) % mod;
+            this.h[i] = (this.h[i - 1] * base + BigInt(s.charCodeAt(i - 1))) % mod;
+        }
+    }
+
+    query(l: number, r: number): bigint {
+        return (this.h[r] - ((this.h[l - 1] * this.p[r - l + 1]) % this.mod) + this.mod) % this.mod;
+    }
+}
+
+function partitionString(s: string): string[] {
+    const n = s.length;
+    const hashing = new Hashing(s);
+    const vis = new Set<string>();
+    const ans: string[] = [];
+    let l = 1;
+    for (let r = 1; r <= n; r++) {
+        const x = hashing.query(l, r).toString();
+        if (!vis.has(x)) {
+            vis.add(x);
+            ans.push(s.slice(l - 1, r));
+            l = r + 1;
+        }
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->