feat: add solutions to lc problem: No.2911 (doocs#1874)

No.2911.Minimum Changes to Make K Semi-palindromes

Author: yanglbme

solution/2600-2699/2698.Find the Punishment Number of an Integer/README.md

@@ -60,7 +60,7 @@
 
 枚举结束，返回答案即可。
 
-时间复杂度 $O(n \times \log^2 n)$，空间复杂度 $O(\log n)$。其中 $n$ 为给定的正整数。
+时间复杂度 $O(n^{1 + 2 \log_{10}^2})$，空间复杂度 $O(\log n)$。其中 $n$ 为给定的正整数。
 
 <!-- tabs:start -->
 

solution/2900-2999/2911.Minimum Changes to Make K Semi-palindromes/README.md

@@ -66,27 +66,219 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minimumChanges(self, s: str, k: int) -> int:
+        n = len(s)
+        g = [[inf] * (n + 1) for _ in range(n + 1)]
+        for i in range(1, n + 1):
+            for j in range(i, n + 1):
+                m = j - i + 1
+                for d in range(1, m):
+                    if m % d == 0:
+                        cnt = 0
+                        for l in range(m):
+                            r = (m // d - 1 - l // d) * d + l % d
+                            if l >= r:
+                                break
+                            if s[i - 1 + l] != s[i - 1 + r]:
+                                cnt += 1
+                        g[i][j] = min(g[i][j], cnt)
+
+        f = [[inf] * (k + 1) for _ in range(n + 1)]
+        f[0][0] = 0
+        for i in range(1, n + 1):
+            for j in range(1, k + 1):
+                for h in range(i - 1):
+                    f[i][j] = min(f[i][j], f[h][j - 1] + g[h + 1][i])
+        return f[n][k]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int minimumChanges(String s, int k) {
+        int n = s.length();
+        int[][] g = new int[n + 1][n + 1];
+        int[][] f = new int[n + 1][k + 1];
+        final int inf = 1 << 30;
+        for (int i = 0; i <= n; ++i) {
+            Arrays.fill(g[i], inf);
+            Arrays.fill(f[i], inf);
+        }
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                int m = j - i + 1;
+                for (int d = 1; d < m; ++d) {
+                    if (m % d == 0) {
+                        int cnt = 0;
+                        for (int l = 0; l < m; ++l) {
+                            int r = (m / d - 1 - l / d) * d + l % d;
+                            if (l >= r) {
+                                break;
+                            }
+                            if (s.charAt(i - 1 + l) != s.charAt(i - 1 + r)) {
+                                ++cnt;
+                            }
+                        }
+                        g[i][j] = Math.min(g[i][j], cnt);
+                    }
+                }
+            }
+        }
+        f[0][0] = 0;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= k; ++j) {
+                for (int h = 0; h < i - 1; ++h) {
+                    f[i][j] = Math.min(f[i][j], f[h][j - 1] + g[h + 1][i]);
+                }
+            }
+        }
+        return f[n][k];
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int minimumChanges(string s, int k) {
+        int n = s.size();
+        int g[n + 1][n + 1];
+        int f[n + 1][k + 1];
+        memset(g, 0x3f, sizeof(g));
+        memset(f, 0x3f, sizeof(f));
+        f[0][0] = 0;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j <= n; ++j) {
+                int m = j - i + 1;
+                for (int d = 1; d < m; ++d) {
+                    if (m % d == 0) {
+                        int cnt = 0;
+                        for (int l = 0; l < m; ++l) {
+                            int r = (m / d - 1 - l / d) * d + l % d;
+                            if (l >= r) {
+                                break;
+                            }
+                            if (s[i - 1 + l] != s[i - 1 + r]) {
+                                ++cnt;
+                            }
+                        }
+                        g[i][j] = min(g[i][j], cnt);
+                    }
+                }
+            }
+        }
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 1; j <= k; ++j) {
+                for (int h = 0; h < i - 1; ++h) {
+                    f[i][j] = min(f[i][j], f[h][j - 1] + g[h + 1][i]);
+                }
+            }
+        }
+        return f[n][k];
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func minimumChanges(s string, k int) int {
+	n := len(s)
+	g := make([][]int, n+1)
+	f := make([][]int, n+1)
+	const inf int = 1 << 30
+	for i := range g {
+		g[i] = make([]int, n+1)
+		f[i] = make([]int, k+1)
+		for j := range g[i] {
+			g[i][j] = inf
+		}
+		for j := range f[i] {
+			f[i][j] = inf
+		}
+	}
+	f[0][0] = 0
+	for i := 1; i <= n; i++ {
+		for j := i; j <= n; j++ {
+			m := j - i + 1
+			for d := 1; d < m; d++ {
+				if m%d == 0 {
+					cnt := 0
+					for l := 0; l < m; l++ {
+						r := (m/d-1-l/d)*d + l%d
+						if l >= r {
+							break
+						}
+						if s[i-1+l] != s[i-1+r] {
+							cnt++
+						}
+					}
+					g[i][j] = min(g[i][j], cnt)
+				}
+			}
+		}
+	}
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= k; j++ {
+			for h := 0; h < i-1; h++ {
+				f[i][j] = min(f[i][j], f[h][j-1]+g[h+1][i])
+			}
+		}
+	}
+	return f[n][k]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
 
+### **TypeScript**
+
+```ts
+function minimumChanges(s: string, k: number): number {
+    const n = s.length;
+    const g = Array.from({ length: n + 1 }, () => Array.from({ length: n + 1 }, () => Infinity));
+    const f = Array.from({ length: n + 1 }, () => Array.from({ length: k + 1 }, () => Infinity));
+    f[0][0] = 0;
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= n; ++j) {
+            const m = j - i + 1;
+            for (let d = 1; d < m; ++d) {
+                if (m % d === 0) {
+                    let cnt = 0;
+                    for (let l = 0; l < m; ++l) {
+                        const r = (((m / d) | 0) - 1 - ((l / d) | 0)) * d + (l % d);
+                        if (l >= r) {
+                            break;
+                        }
+                        if (s[i - 1 + l] !== s[i - 1 + r]) {
+                            ++cnt;
+                        }
+                    }
+                    g[i][j] = Math.min(g[i][j], cnt);
+                }
+            }
+        }
+    }
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= k; ++j) {
+            for (let h = 0; h < i - 1; ++h) {
+                f[i][j] = Math.min(f[i][j], f[h][j - 1] + g[h + 1][i]);
+            }
+        }
+    }
+    return f[n][k];
+}
 ```
 
 ### **...**