题目描述
给你一个字符串 s ，返回 s 中 同质子字符串 的数目。由于答案可能很大，只需返回对 109 + 7 取余 后的结果。
同质字符串 的定义为：如果一个字符串中的所有字符都相同，那么该字符串就是同质字符串。
子字符串 是字符串中的一个连续字符序列。
示例 1：
输入：s = "abbcccaa"
输出：13
解释：同质子字符串如下所列：
"a" 出现 3 次。
"aa" 出现 1 次。
"b" 出现 2 次。
"bb" 出现 1 次。
"c" 出现 3 次。
"cc" 出现 2 次。
"ccc" 出现 1 次。
3 + 1 + 2 + 1 + 3 + 2 + 1 = 13
示例 2：
输入：s = "xy"
输出：2
解释：同质子字符串是 "x" 和 "y" 。
示例 3：
输入：s = "zzzzz"
输出：15
提示：
1 <= s.length <= 105s 由小写字符串组成。
解法
方法一：双指针
遍历字符串 $s$，用指针 $i$ 指向当前字符，指针 $j$ 指向下一个不同的字符，那么 $[i,..j-1]$ 区间内的字符都是相同的，假设 $cnt=j-i$，那么该区间内的同构子字符串个数为 $\frac{(1 + cnt) \times cnt}{2}$，将其累加到答案中即可。继续遍历，直到指针 $i$ 到达字符串末尾。
遍历完字符串 $s$ 后，返回答案即可。注意答案的取模操作。
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为字符串 $s$ 的长度。
1
2
3
4
5
6
7
8
9
10
11
12
13
14 | class Solution:
def countHomogenous(self, s: str) -> int:
mod = 10**9 + 7
i, n = 0, len(s)
ans = 0
while i < n:
j = i
while j < n and s[j] == s[i]:
j += 1
cnt = j - i
ans += (1 + cnt) * cnt // 2
ans %= mod
i = j
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | class Solution {
private static final int MOD = (int) 1e9 + 7;
public int countHomogenous(String s) {
int n = s.length();
long ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
j = i;
while (j < n && s.charAt(j) == s.charAt(i)) {
++j;
}
int cnt = j - i;
ans += (long) (1 + cnt) * cnt / 2;
ans %= MOD;
}
return (int) ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 | class Solution {
public:
const int mod = 1e9 + 7;
int countHomogenous(string s) {
int n = s.size();
long ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
j = i;
while (j < n && s[j] == s[i]) ++j;
int cnt = j - i;
ans += 1ll * (1 + cnt) * cnt / 2;
ans %= mod;
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14 | func countHomogenous(s string) (ans int) {
n := len(s)
const mod int = 1e9 + 7
for i, j := 0, 0; i < n; i = j {
j = i
for j < n && s[j] == s[i] {
j++
}
cnt := j - i
ans += (1 + cnt) * cnt / 2
ans %= mod
}
return
}
|
1
2
3
4
5
6
7
8
9
10
11
12 | function countHomogenous(s: string): number {
const mod = 1e9 + 7;
const n = s.length;
let ans = 0;
for (let i = 0, j = 0; j < n; j++) {
if (s[i] !== s[j]) {
i = j;
}
ans = (ans + j - i + 1) % mod;
}
return ans;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | impl Solution {
pub fn count_homogenous(s: String) -> i32 {
const MOD: usize = (1e9 as usize) + 7;
let s = s.as_bytes();
let n = s.len();
let mut ans = 0;
let mut i = 0;
for j in 0..n {
if s[i] != s[j] {
i = j;
}
ans = (ans + j - i + 1) % MOD;
}
ans as i32
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | public class Solution {
public int CountHomogenous(string s) {
long MOD = 1000000007;
long ans = 0;
for (int i = 0, j = 0; i < s.Length; i = j) {
j = i;
while (j < s.Length && s[j] == s[i]) {
++j;
}
int cnt = j - i;
ans += (long) (1 + cnt) * cnt / 2;
ans %= MOD;
}
return (int) ans;
}
}
|
| int countHomogenous(char* s) {
int MOD = 1e9 + 7;
int ans = 0;
for (int i = 0, j = 0; s[j]; j++) {
if (s[i] != s[j]) {
i = j;
}
ans = (ans + j - i + 1) % MOD;
}
return ans;
}
|
方法二