2023-11-11：用go语言，字符串哈希+二分的例题。

给定长为 n 的源串 s，以及长度为 m 的模式串 p，

要求查找源串中有多少子串与模式串匹配，

s' 与 s 匹配，当且仅当 s' 与 s 长度相同，且最多有 k 个位置字符不同。

其中 1 <= n, m <= 10^6，0 <= k <= 5。

来自左程云。

答案2023-11-11：

go代码用灵捷3.5编写。

大体过程如下：

算法1：

遍历源串 s 中所有长度为 m 的子串，判断子串与模式串的不同字符数量是否小于等于 k，若是，将统计的子串数量加1。具体地：

1.首先计算源串 s 的长度 n 和模式串 p 的长度 m。

2.若 n < m，则返回0。

3.将源串 s 和模式串 p 转换为 rune 类型的切片，方便进行字符比较。

4.遍历源串 s 中所有长度为 m 的子串，判断子串与模式串的不同字符数量是否小于等于 k，若是，将统计的子串数量加1。

5.返回统计的子串数量。

算法2：

计算源串 s 的哈希值和模式串 p 的哈希值，然后遍历源串 s 中所有长度为 m 的子串，判断子串与模式串的哈希值是否相等，若是则比较子串与模式串的每个字符是否相同，最多允许 k 个字符不同。具体地：

1.首先计算源串 s 的长度 n 和模式串 p 的长度 m。

2.若 n < m，则返回0。

3.将源串 s 和模式串 p 转换为 rune 类型的切片，方便进行哈希操作。

4.计算源串 s 的哈希值和模式串 p 的哈希值，分别保存在 hashs 和 hashp 数组中。

5.遍历源串 s 中所有长度为 m 的子串，判断子串与模式串的哈希值是否相等，若是则比较子串与模式串的每个字符是否相同，最多允许 k 个字符不同。

6.比较子串与模式串的每个字符是否相同，最多允许 k 个字符不同的具体实现：遍历子串中每个字符，二分查找在模式串中与该字符相同的位置，若找到了，则比较子串和模式串中该位置的字符是否相同，否则允许 k 的值加1。如果 k 的值大于了允许的最大值，那么返回 false。

7.返回 true。

时间复杂度和空间复杂度分析：

算法1：

时间复杂度：代码中主要的时间复杂度来源于遍历源串 s 中所有长度为 m 的子串，遍历次数为 O(n-m+1)，每次遍历需要比较 m 个字符，因此总的时间复杂度为 O((n-m+1)*m)。由于 n 和 m 的值均不超过 10^6，因此算法1的总的时间复杂度为 O(10^12)，在实际情况中运算速度较慢。

空间复杂度：算法1只需要占用 O(n+m) 的额外空间，用于存储源串 s 和模式串 p。

算法2：

时间复杂度：代码中主要的时间复杂度来源于计算源串 s 和模式串 p 的哈希值，以及遍历源串 s 中所有长度为 m 的子串，遍历次数为 O(n-m+1)，每次需要计算哈希值和比较 m 个字符，因此总的时间复杂度为 O((n-m+1)*(m+logn))。由于 n 和 m 的值均不超过 10^6，因此算法2的总的时间复杂度为 O(10^12)，与算法1的时间复杂度相同，但实际速度更快。

空间复杂度：算法2需要占用 O(n+m) 的额外空间，用于存储源串 s 和模式串 p 的哈希值，以及 O(n) 的额外空间，用于存储哈希值计算过程中的幂 base^i(i<=n)。

总结：

算法1和算法2的时间复杂度都为 O(10^12)，但实际运算速度可能存在很大的差异，具体取决于实现过程中的细节。在实际应用中，算法2比算法1更为常用，因为哈希算法能够在较快的时间内完成字符串的比较。

go完整代码如下：

package main

import (
	"fmt"
	"math/rand"
)

func howMany1(str1 string, str2 string, k int) int {
	n := len(str1)
	m := len(str2)
	if n < m {
		return 0
	}
	s := []rune(str1)
	p := []rune(str2)
	ans := 0
	for i := 0; i <= n-m; i++ {
		if diffLessK1(s, i, p, k, m) {
			ans++
		}
	}
	return ans
}

func diffLessK1(s []rune, i int, p []rune, k int, m int) bool {
	diff := 0
	for j := 0; j < m; j++ {
		if s[i+j] != p[j] {
			diff++
		}
	}
	return diff <= k
}

const MAXN = 100001
const base = 1000000007

var pow []int64 = make([]int64, MAXN)
var hashs []int64 = make([]int64, MAXN)
var hashp []int64 = make([]int64, MAXN)

func buildHash(s []rune, n int, p []rune, m int) {
	hashs[0] = int64(s[0] - 'a' + 1)
	for j := 1; j < n; j++ {
		hashs[j] = hashs[j-1]*base + int64(s[j]-'a'+1)
	}
	hashp[0] = int64(p[0] - 'a' + 1)
	for j := 1; j < m; j++ {
		hashp[j] = hashp[j-1]*base + int64(p[j]-'a'+1)
	}
}

func howMany2(str1 string, str2 string, k int) int {
	n := len(str1)
	m := len(str2)
	if n < m {
		return 0
	}
	s := []rune(str1)
	p := []rune(str2)
	buildHash(s, n, p, m)
	ans := 0
	for i := 0; i <= n-m; i++ {
		if diffLessK2(i, i+m-1, 0, m-1, k) {
			ans++
		}
	}
	return ans
}

func diffLessK2(l1 int, r1 int, l2 int, r2 int, k int) bool {
	diff := 0
	for l1 <= r1 && diff <= k {
		l, r := 1, r1-l1+1
		len := 0
		for l <= r {
			m := (l + r) / 2
			if ok(l1, l2, m) {
				len = m
				l = m + 1
			} else {
				r = m - 1
			}
		}
		if l1+len <= r1 {
			diff++
		}
		l1 += len + 1
		l2 += len + 1
	}
	return diff <= k
}

func ok(l1 int, l2 int, len int) bool {
	return hash(hashs, l1, l1+len-1) == hash(hashp, l2, l2+len-1)
}

func hash(hash []int64, l int, r int) int64 {
	ans := hash[r]
	if l == 0 {
		return ans
	}
	ans -= hash[l-1] * pow[r-l+1]
	return ans
}

func init() {
	pow[0] = 1
	for j := 1; j < MAXN; j++ {
		pow[j] = pow[j-1] * base
	}
}

// 生成随机子串
func randomString(len int, rangeNum int) string {
	b := make([]byte, len)
	for i := 0; i < len; i++ {
		b[i] = byte(rand.Intn(rangeNum) + 'a')
	}
	return string(b)
}

func main() {
	N := 100
	M := 50
	K := 10
	// a b c
	// R =4 abcd
	R := 3
	testTimes := 10000
	fmt.Println("测试开始")
	for i := 0; i < testTimes; i++ {
		n := rand.Intn(N) + 1
		m := rand.Intn(M) + 1
		k := rand.Intn(K)
		str1 := randomString(n, R)
		str2 := randomString(m, R)
		ans1 := howMany1(str1, str2, k)
		ans2 := howMany2(str1, str2, k)
		if ans1 != ans2 {
			fmt.Println("出错了！")
		}
	}
	fmt.Println("测试结束")
}