2023-07-29：给你一个由数字组成的字符串 s，返回 s 中独特子字符串数量。
其中的每一个数字出现的频率都相同。
答案2023-07-29：
# 大体步骤如下：
1.初始化变量base为固定值1000000007，用于计算哈希码。
2.创建一个空的哈希集合set，用于存储独特子字符串的哈希码。
3.创建一个长度为10的整数数组cnts，用于记录数字出现的频率。
4.循环遍历字符串s的每个字符，使用变量l来表示当前子字符串的起始位置。
5.在循环开始时，将数组cnts的所有元素初始化为0。
6.初始化哈希码hashCode为0。
7.初始化变量curVal、maxCnt、maxKinds和allKinds为0，分别表示当前数字值、最大频率、最大频率的数字种类数和所有数字种类数。
8.开始内层循环，依次遍历从l位置开始的子字符串的每个字符，使用变量r表示当前字符的索引。
9.将当前字符转换为整数curVal，同时计算哈希码hashCode，基于base的乘法运算，并加上curVal+1。
10.将cnts[curVal]加1表示当前数字curVal的频率增加了一次。
11.如果cnts[curVal]等于1，说明新出现了一种数字，将allKinds加1，表示所有数字的种类数增加了一种。
12.如果cnts[curVal]大于maxCnt，表示当前数字的频率超过了之前的最大频率，将maxCnt更新为cnts[curVal]，并将maxKinds重置为1，表示找到一种新的最大频率数字。
13.如果cnts[curVal]等于maxCnt，表示当前数字的频率和最大频率相同，将maxKinds加1，表示累计的最大频率数字种类数增加了一种。
14.若maxKinds等于allKinds，表示当前子字符串中每种数字都出现了最大频率次数，将当前子字符串的哈希码hashCode添加到集合set中。
15.循环结束后，更新l的值，进入下一个子字符串的计算。
16.返回集合set的大小，即独特子字符串的数量。
17.在main函数中，定义字符串s为"11223"，调用equalDigitFrequency函数计算结果，并打印输出。
时间复杂度：
该算法的时间复杂度为O(N^2)，其中N是字符串s的长度。外层循环遍历字符串s的每个字符，内层循环遍历以每个字符为起始位置的子字符串。因此，总的时间复杂度可以近似为N*(N+1)/2，即O(N^2)。
空间复杂度：
该算法的空间复杂度为O(1)，因为除了常数个变量之外，没有额外使用大量的空间。集合set的空间取决于独特子字符串的数量，但最坏情况下独特子字符串的数量是固定的，最多只有10个数字种类。因此，可以看作是常数级的空间复杂度，即O(1)。
# go完整代码如下：
```go
package main
import (
"fmt"
"strconv"
)
func equalDigitFrequency(s string) int {
base := int64(1000000007)
set := make(map[int64]bool)
cnts := make([]int, 10)
for l := 0; l < len(s); l++ {
for i := 0; i < 10; i++ {
cnts[i] = 0
}
hashCode := int64(0)
curVal, maxCnt, maxKinds, allKinds := 0, 0, 0, 0
for r := l; r < len(s); r++ {
curVal, _ = strconv.Atoi(string(s[r]))
hashCode = hashCode*base + int64(curVal+1)
cnts[curVal]++
if cnts[curVal] == 1 {
allKinds++
}
if cnts[curVal] > maxCnt {
maxCnt = cnts[curVal]
maxKinds = 1
} else if cnts[curVal] == maxCnt {
maxKinds++
}
if maxKinds == allKinds {
set[hashCode] = true
}
}
}
return len(set)
}
func main() {
s := "11223"
result := equalDigitFrequency(s)
fmt.Println(result)
}
```
# rust完整代码如下：
```rust
use std::collections::HashSet;
fn equal_digit_frequency(s: &str) -> usize {
let base: i64 = 1_000_000_007;
let mut set: HashSet<i64> = HashSet::new();
let mut cnts: [i64; 10];
let ss = s.as_bytes();
for l in 0..ss.len() {
cnts = [0; 10];
let mut hash_code = 0;
let mut cur_val;
let (mut max_cnt, mut max_kinds, mut all_kinds) = (0, 0, 0);
let mut r = l;
while r < ss.len() {
cur_val = ss[r] as i64 - '0' as i64;
hash_code = (hash_code as i64).wrapping_mul(base as i64) + cur_val + 1;
cnts[cur_val as usize] += 1;
if cnts[cur_val as usize] == 1 {
all_kinds += 1;
}
if cnts[cur_val as usize] > max_cnt {
max_cnt = cnts[cur_val as usize];
max_kinds = 1;
} else if cnts[cur_val as usize] == max_cnt {
max_kinds += 1;
}
if max_kinds == all_kinds {
set.insert(hash_code);
}
r += 1;
}
}
set.len()
}
fn main() {
let s = "11223";
let result = equal_digit_frequency(s);
println!("{}", result);
}
```
# c++完整代码如下：
```cpp
#include <iostream>
#include <unordered_set>
#include <vector>
int equalDigitFrequency(std::string s) {
const long long base = 1000000007;
std::unordered_set<long long> set;
std::vector<int> cnts(10, 0);
for (int l = 0; l < s.length(); l++) {
std::fill(cnts.begin(), cnts.end(), 0);
long long hashCode = 0;
int curVal, maxCnt = 0, maxKinds = 0, allKinds = 0;
for (int r = l; r < s.length(); r++) {
curVal = s[r] - '0';
hashCode = hashCode * base + curVal + 1;
cnts[curVal]++;
if (cnts[curVal] == 1) {
allKinds++;
}
if (cnts[curVal] > maxCnt) {
maxCnt = cnts[curVal];
maxKinds = 1;
}
else if (cnts[curVal] == maxCnt) {
maxKinds++;
}
if (maxKinds == allKinds) {
set.insert(hashCode);
}
}
}
return set.size();
}
int main() {
std::string s = "11223";
int result = equalDigitFrequency(s);
std::cout << result << std::endl;
return 0;
}
```
# c完整代码如下：
```c
#include <stdio.h>
#include <stdbool.h>
#define BASE 1000000007
#define MAX_DIGITS 10
int equalDigitFrequency(char* s) {
unsigned long long set[MAX_DIGITS] = { 0 };
int cnts[MAX_DIGITS] = { 0 };
int setSize = 0;
for (int l = 0; s[l] != '\0'; l++) {
for (int i = 0; i < MAX_DIGITS; i++) {
cnts[i] = 0;
}
unsigned long long hashCode = 0;
int curVal, maxCnt = 0, maxKinds = 0, allKinds = 0;
for (int r = l; s[r] != '\0'; r++) {
curVal = s[r] - '0';
hashCode = hashCode * BASE + curVal + 1;
cnts[curVal]++;
if (cnts[curVal] == 1) {
allKinds++;
}
if (cnts[curVal] > maxCnt) {
maxCnt = cnts[curVal];
maxKinds = 1;
}
else if (cnts[curVal] == maxCnt) {
maxKinds++;
}
if (maxKinds == allKinds) {
bool exists = false;
for (int i = 0; i < setSize; i++) {
if (set[i] == hashCode) {
exists = true;
break;
}
}
if (!exists) {
set[setSize++] = hashCode;
}
}
}
}
return setSize;
}
int main() {
char s[] = "11223";
int result = equalDigitFrequency(s);
printf("%d\n", result);
return 0;
}
```
