第380场周赛挑战：二分，数位dp和KMP算法的综合运用

比赛地址

卡在第三题了，应该看看第4题kmp套模版的

一、最大频率元素计数 

class Solution:
    def maxFrequencyElements(self, nums: List[int]) -> int:
            frequency = {}  # 哈希表用于统计频率
            max_freq = 0    # 存储最大频率

            # 统计每个元素的频率
            for num in nums:
                if num in frequency:
                    frequency[num] += 1
                else:
                    frequency[num] = 1
                max_freq = max(max_freq, frequency[num])

            # 计算具有最大频率的元素的总频率
            total = 0
            for freq in frequency.values():
                if freq == max_freq:
                    total += freq

            return total

二、找出数组中的美丽下标 I

class Solution:
    def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
        # 找出所有子字符串a和b的出现位置
        indices_a = [i for i in range(len(s) - len(a) + 1) if s[i:i + len(a)] == a]
        indices_b = [i for i in range(len(s) - len(b) + 1) if s[i:i + len(b)] == b]

        beautiful_indices = []

        # 检查每个a的出现位置是否存在满足条件的b的出现位置
        for i in indices_a:
            for j in indices_b:
                if abs(j - i) <= k:
                    beautiful_indices.append(i)
                    break

        return beautiful_indices

三、 价值和小于等于 K 的最大数字

1. 二分查找：findMaximumNumber 函数使用二分查找法来查找符合条件的最大 num。它初始化左边界 left 为 0，右边界 right 为 (k + 1) << (x - 1)。这个右边界是一个估计值，确保 num 的上界足够高。二分查找在满足条件 left + 1 < right 的情况下迭代，通过比较 countDigitOne(mid) 和 k 来调整 left 和 right。

2. 递归函数 dfs：这是一个深度优先搜索函数，用于计算在 1 到 num 的范围内，满足特定条件的设置位的总数。它采用记忆化搜索来优化性能，减少重复计算。参数 i 是当前正在处理的二进制位的位置，cnt1 是当前累计的设置位数量，isLimit 表示是否受到 num 的限制。

3. 记忆化搜索：在 dfs 函数中，如果不受 num 的限制且已经计算过该状态，则直接返回存储的结果（memo[i][cnt1]）。这样避免了重复计算，提高了效率。

4. 计算设置位的数量：dfs 函数枚举在当前位置 i 可能的数字（0 或 1），并递归计算接下来的位。如果当前位是设置位且满足 (i + 1) % x == 0 的条件，则 cnt1 增加。这样累加所有满足条件的设置位数量。

5. 寻找最大 num：通过二分查找和 dfs 函数的结合，最终确定出使得从 1 到 num 的所有整数的价值和小于等于 k 的最大 num。

class Solution {
    private int x;
    private long num;
    private long memo[][];

    // 主方法：找到最大的num，使得从1到num的所有整数的价值和小于等于k
    public long findMaximumNumber(long k, int x) {
        this.x = x;
        // 使用二分查找法来找到满足条件的最大num
        // 初始右边界是一个估计值，足够大以涵盖可能的解，左闭右开区间，寻找右侧边界
        long left = 0;
        long right = k << x;
        while (left < right) {
            long mid = left + (right - left) / 2;
            if (countDigitOne(mid) < k) {
                left = mid+1;
            } else if(countDigitOne(mid) == k){
                left = mid+1;
            }else{
                 right = mid;
            }
        }
        return left-1;
    }

    // 计算从1到num的所有整数的价值和
    public long countDigitOne(long num) {
        this.num = num; // 将类变量num设置为当前处理的数字
        int m = 64 - Long.numberOfLeadingZeros(num); // 计算num的二进制表示的长度
        memo = new long[m][m + 1]; // 初始化记忆化数组，用于存储中间结果
        for (long[] row : memo) {
            Arrays.fill(row, -1); // 将记忆化数组的每个元素初始化为-1，表示未计算
        }
        return dfs(m - 1, 0, true); // 调用深度优先搜索函数计算设置位的数量
    }


    // 深度优先搜索计算设置位的数量
    // i 是当前处理的位的索引，cnt1 是当前累计的设置位数量，isLimit 表示是否受到num的限制
    long dfs(int i, int cnt1, boolean isLimit) {
        if (i < 0) return cnt1; // 如果索引小于0，返回累计的设置位数量
        
        if (!isLimit && memo[i][cnt1] != -1) return memo[i][cnt1]; // 记忆化搜索，避免重复计算
        
        int up = isLimit ? (int) (num >> i & 1) : 1; // 受限的话，上限取决于num的第i位，不受限的话上限为1
        long res = 0;
        for (int d = 0; d <= up; d++) { // 枚举要填入的数字d
            res += dfs(i - 1, cnt1 + (d == 1 && (i + 1) % x == 0 ? 1 : 0), isLimit && d == up);
        }
        if (!isLimit) memo[i][cnt1] = res; // 更新记忆化存储
        return res;
    }
}

如果k=10000100 (8位数),x=6，对于2<<6 即100000（6位数） 第6为确定为1的画后面有2^(6-1)个组合方案。

二分的上界取多少合适

四、找出数组中的美丽下标 II

普通的算法会超时需要用到二分法和KMP算法

• 用 KMP 求出 aaa 在 sss 中的所有出现位置，记作 posA 。
• 用 KMP 求出 bbb 在 sss 中的所有出现位置，记作 posB。
• 遍历 posA  中的下标 ，在 posB 中二分查找离 i 最近的 j。如果 ∣i−j∣≤k ，则把 i 加入答案。

class Solution:
    def beautifulIndices(self, s: str, a: str, b: str, k: int) -> List[int]:
        # 使用KMP算法找出字符串a和b在s中所有的出现位置
        pos_a = self.kmp(s, a)
        pos_b = self.kmp(s, b)

        ans = []
        # 遍历a在s中的每个出现位置
        for i in pos_a:
            # 使用二分查找在b的出现位置中找到大于等于i的最小索引
            bi = bisect_left(pos_b, i)
            # 检查找到的b的位置是否满足与a的位置距离不超过k的条件
            if (bi < len(pos_b) and pos_b[bi] - i <= k) or \
               (bi > 0 and i - pos_b[bi - 1] <= k):
                ans.append(i)  # 如果满足条件，将a的位置添加到结果列表中
        return ans



    def kmp(self, text: str, pattern: str) -> List[int]:
        # 初始化部分匹配表
        m = len(pattern)
        pi = [0] * m

        # 构建部分匹配表
        c = 0
        for i in range(1, m):
            while c and pattern[c] != pattern[i]:
                c = pi[c - 1]
            if pattern[c] == pattern[i]:
                c += 1
            pi[i] = c

        # 在文本中搜索模式
        res = []
        c = 0
        for i, v in enumerate(text):
            while c and pattern[c] != v:
                c = pi[c - 1]
            if pattern[c] == v:
                c += 1
            if c == m:
                res.append(i - m + 1)  # 找到一个匹配，记录其开始位置
                c = pi[c - 1]  # 继续搜索下一个可能的匹配
        return res

• bi < len(pos_b)：这个条件确保 bi 是 pos_b 中的有效索引。由于 bisect_left 返回的 bi 是 pos_b 中第一个大于或等于 i 的元素的索引，可能会出现 bi 等于 pos_b 的长度的情况，这意味着所有 b 的出现位置都在 i 之前。在这种情况下，尝试访问 pos_b[bi] 会导致数组越界。因此，需要检查 bi < len(pos_b) 来确保访问是安全的。
•  bi > 0：这个条件用于检查 pos_b[bi - 1] 是否是有效访问。当 bi 为 0 时，bi - 1 会变成 -1，这在 Python 中是有效的倒数第一个元素的索引，但在某些编程语言中可能会导致错误。在这里，bi > 0 确保我们不会尝试访问列表的负索引，这对于理解代码逻辑和避免潜在错误是重要的。

对应的java写法

class Solution {
    public List beautifulIndices(String s, String a, String b, int k) {
        char[] text = s.toCharArray();
        List posA = kmp(text, a.toCharArray());
        List posB = kmp(text, b.toCharArray());

        List ans = new ArrayList<>();
        for (int i : posA) {
            int bi = lowerBound(posB, i);
            if (bi < posB.size() && posB.get(bi) - i <= k ||
                bi > 0 && i - posB.get(bi - 1) <= k) {
                ans.add(i);
            }
        }
        return ans;
    }

    private List kmp(char[] text, char[] pattern) {
        int m = pattern.length;
        int[] pi = new int[m];
        int c = 0;
        for (int i = 1; i < m; i++) {
            char v = pattern[i];
            while (c > 0 && pattern[c] != v) {
                c = pi[c - 1];
            }
            if (pattern[c] == v) {
                c++;
            }
            pi[i] = c;
        }

        List res = new ArrayList<>();
        c = 0;
        for (int i = 0; i < text.length; i++) {
            char v = text[i];
            while (c > 0 && pattern[c] != v) {
                c = pi[c - 1];
            }
            if (pattern[c] == v) {
                c++;
            }
            if (c == m) {
                res.add(i - m + 1);
                c = pi[c - 1];
            }
        }
        return res;
    }
    

    private int lowerBound(List nums, int target) {
        int left = 0, right = nums.size(); // 开区间 (left, right)
        while (left  < right) { // 区间不为空
            // 循环不变量：
            // nums[left] < target
            // nums[right] >= target
            int mid = (left + right) >>> 1;
            //不要写成   int mid = left + (right - left) >>> 1; 会超时
            if (nums.get(mid) < target) {
                left = mid+1; // 范围缩小到 [mid+1, right)
            } else {
                right = mid;  // 范围缩小到 (left, mid)
            }
        }
   
        return right;
    }
}

数位 DP相关问题

2719. 统计整数数目 入门题
788. 旋转数字（题解）
902. 最大为 N 的数字组合（题解）1990
233. 数字 1 的个数（题解）
面试题 17.06. 2 出现的次数（题解）
600. 不含连续 1 的非负整数（题解）
2376. 统计特殊整数（题解）2120
1012. 至少有 1 位重复的数字（题解）2230
357. 统计各位数字都不同的数字个数
2999. 统计强大整数的数目
2827. 范围中美丽整数的数目 2324
2801. 统计范围内的步进数字数目 2367
1397. 找到所有好字符串 2667
1742. 盒子中小球的最大数量 *非暴力做法