LC-1638. 统计只差一个字符的子串数目（中心扩散法）

1638. 统计只差一个字符的子串数目

难度中等62

给你两个字符串 s 和 t ，请你找出 s 中的非空子串的数目，这些子串满足替换 一个不同字符 以后，是 t 串的子串。换言之，请你找到 s 和 t 串中 恰好 只有一个字符不同的子字符串对的数目。

比方说， "computer" and "computation" 只有一个字符不同： 'e'/'a' ，所以这一对子字符串会给答案加 1 。

请你返回满足上述条件的不同子字符串对数目。

一个 子字符串 是一个字符串中连续的字符。

示例 1：

输入：s = "aba", t = "baba"
输出：6
解释：以下为只相差 1 个字符的 s 和 t 串的子字符串对：
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
("aba", "baba")
加粗部分分别表示 s 和 t 串选出来的子字符串。

示例 2：

输入：s = "ab", t = "bb"
输出：3
解释：以下为只相差 1 个字符的 s 和 t 串的子字符串对：
("ab", "bb")
("ab", "bb")
("ab", "bb")
加粗部分分别表示 s 和 t 串选出来的子字符串。

示例 3：

输入：s = "a", t = "a"
输出：0

示例 4：

输入：s = "abe", t = "bbc"
输出：10

提示：

• 1 <= s.length, t.length <= 100
• s 和 t 都只包含小写英文字母。

暴力

1. 枚举 s 中每个字母开头的子串
2. 在 1 的基础上枚举 t 中的每个字母开头的子串
3. 循环判断他们是否对应位最多只有一位不同

class Solution {
    public int countSubstrings(String s, String t) {
        char[] cs = s.toCharArray();
        char[] ct = t.toCharArray();
        int ans = 0;
        for(int i = 0; i < cs.length; i++){
            for(int j = 0; j < ct.length; j++){
                int w = 0;
                for(int k = 0; k < Math.min(cs.length-i, ct.length-j);k++){
                    if(cs[i + k] != ct[j + k])
                        w += 1;
                    if(w == 1){
                        ans += 1;
                    }else if(w > 1){
                        break;
                    }
                }
            }
        }
        return ans;
    }
}

中心扩散法

题解：https://leetcode.cn/problems/count-substrings-that-differ-by-one-character/solution/shen-zhi-4zhong-xun-huan-bu-jin-tong-guo-sset/

class Solution {
    public int countSubstrings(String s, String t) {
        // 二重遍历枚举两个字符串，如果二者相等，那么continue
        // 当二者不等，分别以s[i]与t[j]为中心同步向左或向右扩散，
        // 扩散条件是二者的左/右字符相同，每扩散一次表示答案加一
        // (i, j) 贡献的答案为(1 + end) * (1 + start)
        // end 是以s[i-1]为终点的最长相同后缀长度； start 是以s[i+1]为起点的最长相同后缀长度
        char[] cs = s.toCharArray();
        char[] ct = t.toCharArray();
        // start[i][j] 表示 以s[i]与t[j]开头，相同的字符串长度
        int[][] start = new int[cs.length][ct.length];
        for(int i = cs.length-1; i >= 0; i--){
            for(int j = ct.length-1; j >= 0; j--){
                if(cs[i] != ct[j]) continue;
                if(i == cs.length - 1 || j == ct.length - 1){
                    start[i][j] = 1;
                }else{ // s[i] = t[j] ,此时相同字符串长度 = 前面长度+1
                    start[i][j] = start[i+1][j+1] + 1;
                }
            }
        }
        // end[i][j] 表示 以s[i]与t[j]结尾，相同的字符串长度
        int[][] end = new int[cs.length][ct.length];
        for(int i = 0; i < cs.length; i++){
            for(int j = 0; j < cs.length; j++){
                if(cs[i] != ct[j]) continue;
                if(i == 0 || j == 0){
                    end[i][j] = 1;
                }else{
                    end[i][j] = end[i-1][j-1] + 1;
                }
            }
        }
        // 统计答案：当二者不等，(i, j) 贡献的答案为(1 + end) * (1 + start)
        int count = 0; // res
        for(int i = 0; i < cs.length; i++){
            for(int j = 0; j < ct.length; j++){
                if(cs[i] == ct[j]) continue;
                //end 是以s[i-1]为终点的最长相同后缀长度
                int left = i > 0 && j > 0 ? end[i-1][j-1] : 0;
                //start 是以s[i+1]为起点的最长相同后缀长度
                int right = i < cs.length-1 && j < ct.length-1 ? start[i+1][j+1] : 0;
                count += (1 + left) * (1 + right); // 乘法法则
            }
        }
        return count;

    }
}