同位字符串连接的最小长度。用go语言，给定一个字符串s，由字符串t和t的多个同位字符串连接而成。
要求计算出字符串t的最小可能长度。
同位字符串是指通过重新排列原单词得到的新字符串，其中原单词的每个字符在新字符串中仅使用一次。
1 <= s.length <= 100000。
s 只包含小写英文字母。
输入：s = "abba"。
输出：2。
解释：
一个可能的字符串 t 为 "ba" 。
大体步骤如下：
1.定义一个函数check，用于检查给定长度m是否满足字符串t的条件。函数内部通过比较字符出现的次数来判断是否为同位字符串。
2.在主函数中，我们通过迭代i从1到字符串s长度n，尝试不同的长度i来找到最小可能长度。
3.检查每个可能的长度i，如果n能整除i且满足check函数的条件，则返回当前长度i作为结果。
4.如果无法找到合适的长度i，则返回字符串s的长度n作为最小可能长度。
总的时间复杂度：
- 外层循环遍历长度i，复杂度为O(n)。
- 内部调用
check函数的时间复杂度为O(n/m)，其中m为当前长度。
因此，总的时间复杂度为O(n^2)。
总的额外空间复杂度：
- 代码中使用了两个长度为26的数组，每次存储字符出现的次数，空间复杂度为O(26) = O(1)。
- 没有额外使用与输入规模相关的空间，因此总的额外空间复杂度为O(1)。
Go完整代码如下：
package main
import (
"fmt"
)
func minAnagramLength(s string) int {
n := len(s)
check := func(m int) bool {
var count0 [26]int
for j := 0; j < n; j += m {
var count1 [26]int
for k := j; k < j+m; k++ {
count1[s[k]-'a']++
}
if j > 0 && count0 != count1 {
return false
}
count0 = count1
}
return true
}
for i := 1; i < n; i++ {
if n%i != 0 {
continue
}
if check(i) {
return i
}
}
return n
}
func main() {
s := "abba"
fmt.Println(minAnagramLength(s))
}
Rust完整代码如下：
fn min_anagram_length(s: &str) -> usize {
let n = s.len();
let check = |m: usize| -> bool {
let mut count0 = [0; 26];
for j in (0..n).step_by(m) {
let mut count1 = [0; 26];
for k in j..j+m {
count1[s.chars().nth(k).unwrap() as usize - 'a' as usize] += 1;
}
if j > 0 && count0 != count1 {
return false;
}
count0 = count1;
}
true
};
for i in 1..n {
if n % i != 0 {
continue;
}
if check(i) {
return i;
}
}
n
}
fn main() {
let s = "abba";
let result = min_anagram_length(s);
println!("{}", result);
}
