feat: add solutions to lc problem: No.3144 (#3436)

Author: yanglbme

solution/3100-3199/3144.Minimum Substring Partition of Equal Character Frequency/README.md

@@ -82,7 +82,7 @@ tags:
 
 为了避免重复计算，我们使用记忆化搜索。
 
-时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 $s$ 的长度。
+时间复杂度 $O(n^2)$，空间复杂度 $O(n \times |\Sigma|)$。其中 $n$ 为字符串 $s$ 的长度，而 $|\Sigma|$ 表示字符集的大小，本题中 $|\Sigma| = 26$。
 
 <!-- tabs:start -->
 
@@ -165,7 +165,7 @@ public:
         int n = s.size();
         int f[n];
         memset(f, -1, sizeof(f));
-        function<int(int)> dfs = [&](int i) {
+        auto dfs = [&](auto&& dfs, int i) -> int {
             if (i >= n) {
                 return 0;
             }
@@ -186,12 +186,12 @@ public:
                 ++cnt[k];
                 ++freq[cnt[k]];
                 if (freq.size() == 1) {
-                    f[i] = min(f[i], 1 + dfs(j + 1));
+                    f[i] = min(f[i], 1 + dfs(dfs, j + 1));
                 }
             }
             return f[i];
         };
-        return dfs(0);
+        return dfs(dfs, 0);
     }
 };
 ```
@@ -276,4 +276,320 @@ function minimumSubstringsInPartition(s: string): number {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：记忆化搜索（优化）
+
+我们可以对方法一进行优化，不需要维护 $\textit{freq}$ 哈希表，只需要维护一个哈希表 $\textit{cnt}$，表示当前子字符串中每个字符出现的次数。另外，维护两个变量 $k$ 和 $m$ 分别表示当前子字符串中的字符种类数和出现次数最多的字符的出现次数。对于一个子串 $s[i..j]$，如果 $j-i+1 = m \times k$，那么这个子串就是一个平衡子串。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n \times |\Sigma|)$。其中 $n$ 为字符串 $s$ 的长度，而 $|\Sigma|$ 表示字符集的大小，本题中 $|\Sigma| = 26$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minimumSubstringsInPartition(self, s: str) -> int:
+        @cache
+        def dfs(i: int) -> int:
+            if i >= n:
+                return 0
+            cnt = defaultdict(int)
+            m = 0
+            ans = n - i
+            for j in range(i, n):
+                cnt[s[j]] += 1
+                m = max(m, cnt[s[j]])
+                if j - i + 1 == m * len(cnt):
+                    ans = min(ans, 1 + dfs(j + 1))
+            return ans
+
+        n = len(s)
+        ans = dfs(0)
+        dfs.cache_clear()
+        return ans
+```
+
+#### Java
+
+```java
+class Solution {
+    private int n;
+    private char[] s;
+    private Integer[] f;
+
+    public int minimumSubstringsInPartition(String s) {
+        n = s.length();
+        f = new Integer[n];
+        this.s = s.toCharArray();
+        return dfs(0);
+    }
+
+    private int dfs(int i) {
+        if (i >= n) {
+            return 0;
+        }
+        if (f[i] != null) {
+            return f[i];
+        }
+        int[] cnt = new int[26];
+        int ans = n - i;
+        int k = 0, m = 0;
+        for (int j = i; j < n; ++j) {
+            k += ++cnt[s[j] - 'a'] == 1 ? 1 : 0;
+            m = Math.max(m, cnt[s[j] - 'a']);
+            if (j - i + 1 == k * m) {
+                ans = Math.min(ans, 1 + dfs(j + 1));
+            }
+        }
+        return f[i] = ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int minimumSubstringsInPartition(string s) {
+        int n = s.size();
+        int f[n];
+        memset(f, -1, sizeof(f));
+        auto dfs = [&](auto&& dfs, int i) -> int {
+            if (i >= n) {
+                return 0;
+            }
+            if (f[i] != -1) {
+                return f[i];
+            }
+            f[i] = n - i;
+            int cnt[26]{};
+            int k = 0, m = 0;
+            for (int j = i; j < n; ++j) {
+                k += ++cnt[s[j] - 'a'] == 1 ? 1 : 0;
+                m = max(m, cnt[s[j] - 'a']);
+                if (j - i + 1 == k * m) {
+                    f[i] = min(f[i], 1 + dfs(dfs, j + 1));
+                }
+            }
+            return f[i];
+        };
+        return dfs(dfs, 0);
+    }
+};
+```
+
+#### Go
+
+```go
+func minimumSubstringsInPartition(s string) int {
+	n := len(s)
+	f := make([]int, n)
+	for i := range f {
+		f[i] = -1
+	}
+	var dfs func(int) int
+	dfs = func(i int) int {
+		if i >= n {
+			return 0
+		}
+		if f[i] != -1 {
+			return f[i]
+		}
+		cnt := [26]int{}
+		f[i] = n - i
+		k, m := 0, 0
+		for j := i; j < n; j++ {
+			x := int(s[j] - 'a')
+			cnt[x]++
+			if cnt[x] == 1 {
+				k++
+			}
+			m = max(m, cnt[x])
+			if j-i+1 == k*m {
+				f[i] = min(f[i], 1+dfs(j+1))
+			}
+		}
+		return f[i]
+	}
+	return dfs(0)
+}
+```
+
+#### TypeScript
+
+```ts
+function minimumSubstringsInPartition(s: string): number {
+    const n = s.length;
+    const f: number[] = Array(n).fill(-1);
+    const dfs = (i: number): number => {
+        if (i >= n) {
+            return 0;
+        }
+        if (f[i] !== -1) {
+            return f[i];
+        }
+        const cnt: number[] = Array(26).fill(0);
+        f[i] = n - i;
+        let [k, m] = [0, 0];
+        for (let j = i; j < n; ++j) {
+            const x = s.charCodeAt(j) - 97;
+            k += ++cnt[x] === 1 ? 1 : 0;
+            m = Math.max(m, cnt[x]);
+            if (j - i + 1 === k * m) {
+                f[i] = Math.min(f[i], 1 + dfs(j + 1));
+            }
+        }
+        return f[i];
+    };
+    return dfs(0);
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- solution:start -->
+
+### 方法三：动态规划
+
+我们可以将记忆化搜索转换为动态规划，定义状态 $f[i]$ 对前 $i$ 个字符进行分割的最少子字符串数量。初始时 $f[0] = 0$，其余 $f[i] = +\infty$ 或者 $f[i] = n$。
+
+接下来我们枚举 $i$ 从 $0$ 到 $n-1$，对于每个 $i$，我们维护一个哈希表 $\textit{cnt}$，表示当前子字符串中每个字符出现的次数。另外，我们维护两个变量 $k$ 和 $m$ 分别表示当前子字符串中的字符种类数和出现次数最多的字符的出现次数。对于一个子串 $s[j..i]$，如果 $i-j+1 = m \times k$，那么这个子串就是一个平衡子串。此时我们可以从 $j$ 开始分割，那么 $f[i+1] = \min(f[i+1], f[j] + 1)$。
+
+最终答案为 $f[n]$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n + |\Sigma|)$。其中 $n$ 为字符串 $s$ 的长度，而 $|\Sigma|$ 表示字符集的大小，本题中 $|\Sigma| = 26$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minimumSubstringsInPartition(self, s: str) -> int:
+        n = len(s)
+        f = [inf] * (n + 1)
+        f[0] = 0
+        for i in range(n):
+            cnt = defaultdict(int)
+            m = 0
+            for j in range(i, -1, -1):
+                cnt[s[j]] += 1
+                m = max(m, cnt[s[j]])
+                if i - j + 1 == len(cnt) * m:
+                    f[i + 1] = min(f[i + 1], f[j] + 1)
+        return f[n]
+```
+
+#### Java
+
+```java
+class Solution {
+    public int minimumSubstringsInPartition(String s) {
+        int n = s.length();
+        char[] cs = s.toCharArray();
+        int[] f = new int[n + 1];
+        Arrays.fill(f, n);
+        f[0] = 0;
+        for (int i = 0; i < n; ++i) {
+            int[] cnt = new int[26];
+            int k = 0, m = 0;
+            for (int j = i; j >= 0; --j) {
+                k += ++cnt[cs[j] - 'a'] == 1 ? 1 : 0;
+                m = Math.max(m, cnt[cs[j] - 'a']);
+                if (i - j + 1 == k * m) {
+                    f[i + 1] = Math.min(f[i + 1], 1 + f[j]);
+                }
+            }
+        }
+        return f[n];
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int minimumSubstringsInPartition(string s) {
+        int n = s.size();
+        vector<int> f(n + 1, n);
+        f[0] = 0;
+        for (int i = 0; i < n; ++i) {
+            int cnt[26]{};
+            int k = 0, m = 0;
+            for (int j = i; ~j; --j) {
+                k += ++cnt[s[j] - 'a'] == 1;
+                m = max(m, cnt[s[j] - 'a']);
+                if (i - j + 1 == k * m) {
+                    f[i + 1] = min(f[i + 1], f[j] + 1);
+                }
+            }
+        }
+        return f[n];
+    }
+};
+```
+
+#### Go
+
+```go
+func minimumSubstringsInPartition(s string) int {
+	n := len(s)
+	f := make([]int, n+1)
+	for i := range f {
+		f[i] = n
+	}
+	f[0] = 0
+	for i := 0; i < n; i++ {
+		cnt := [26]int{}
+		k, m := 0, 0
+		for j := i; j >= 0; j-- {
+			x := int(s[j] - 'a')
+			cnt[x]++
+			if cnt[x] == 1 {
+				k++
+			}
+			m = max(m, cnt[x])
+			if i-j+1 == k*m {
+				f[i+1] = min(f[i+1], 1+f[j])
+			}
+		}
+	}
+	return f[n]
+}
+```
+
+#### TypeScript
+
+```ts
+function minimumSubstringsInPartition(s: string): number {
+    const n = s.length;
+    const f: number[] = Array(n + 1).fill(n);
+    f[0] = 0;
+    for (let i = 0; i < n; ++i) {
+        const cnt: number[] = Array(26).fill(0);
+        let [k, m] = [0, 0];
+        for (let j = i; ~j; --j) {
+            const x = s.charCodeAt(j) - 97;
+            k += ++cnt[x] === 1 ? 1 : 0;
+            m = Math.max(m, cnt[x]);
+            if (i - j + 1 === k * m) {
+                f[i + 1] = Math.min(f[i + 1], 1 + f[j]);
+            }
+        }
+    }
+    return f[n];
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->