检查是否可以将一个字符串拆分为两个具有相同 K 频字符数的字符串

问题描述

给定一个字符串，判断是否能将其分成两个子串，使得每个子串中都包含具有相同出现次数的 K 个字符（K 为任意正整数）。

解决方案

方案一：暴力枚举

首先考虑最朴素的做法，枚举 K 以及两个子串分割点位置，然后遍历每个子串，记录每个字符出现的次数，最后比较两个子串中每个字符出现次数是否相同。

时间复杂度：$O(n^3)$，其中 $n$ 为字符串长度。

bool canSplitIntoTwoEqualKFrequencySubstring(string s) {
    int n = s.size();
    for (int k = 1; k <= n; k++) { // 枚举 K
        if (n % k != 0) continue;
        bool flag = true;
        for (int i = 0; i < n && flag; i += k) {
            unordered_map<char, int> mp1, mp2;
            for (int j = 0; j < k; j++) { // 统计两个子串中每个字符出现的次数
                mp1[s[i+j]]++;
                mp2[s[i+j+k]]++;
            }
            for (auto x : mp1) { // 比较两个子串中每个字符出现次数是否相同
                if (x.second != mp2[x.first]) {
                    flag = false;
                    break;
                }
            }
        }
        if (flag) return true;
    }
    return false;
}

方案二：哈希表优化

我们发现，在方案一中，每次统计两个子串中每个字符出现的次数时，都使用一个哈希表来记录，这样在枚举 K 时，会有很多重复的计算。因此我们可以用一个二维数组 $cnt_{i,j}$ 来记录求解 $[0,i)$ 和 $[0,j)$ 两个前缀中每个字符出现的次数，那么对于任意一组左右端点 $(l,r)$，我们只需要 $O(1)$ 的时间就可求出 $[l,r)$ 区间中每个字符出现的次数，从而计算出两个子串中每个字符出现的次数。

时间复杂度：$O(n^2)$，其中 $n$ 为字符串长度。

bool canSplitIntoTwoEqualKFrequencySubstring(string s) {
    int n = s.size();
    vector<vector<int>> cnt(n+1, vector<int>(26)); // cnt[i][j] 表示前缀 [0,i) 中字符 j 出现的次数
    for (int i = 0; i < n; i++) {
        cnt[i+1] = cnt[i];
        cnt[i+1][s[i]-'a']++;
    }
    for (int k = 1; k <= n; k++) {
        if (n % k != 0) continue;
        bool flag = true;
        for (int i = 0; i < n && flag; i += k) {
            vector<int> diff(26); // diff[j] 表示两个子串中字符 j 出现次数的差值
            for (int j = 0; j < 26; j++) {
                diff[j] = cnt[i+k][j] - cnt[i][j] - cnt[i+2*k][j] + cnt[i+k][j];
            }
            for (int j = 0; j < 26; j++) {
                if (diff[j] != 0 && diff[j] != k) {
                    flag = false;
                    break;
                }
            }
        }
        if (flag) return true;
    }
    return false;
}

方案三：前缀和优化

在方案二中，我们使用了二维数组来记录前缀中每个字符的出现次数，但是对于同一字符的出现次数，其实只有和前一个位置的状态有关系，因此我们可以使用一个一维数组 $cnt_i$ 来记录 $[0,i)$ 前缀中每个字符出现的次数，这样在更新 $cnt_i$ 时，只需要累加前一个位置的状态即可。

时间复杂度：$O(n^2)$，其中 $n$ 为字符串长度。

bool canSplitIntoTwoEqualKFrequencySubstring(string s) {
    int n = s.size();
    vector<int> cnt(26); // cnt[j] 表示前缀 [0,i) 中字符 j 出现的次数
    for (int i = 0; i < n; i++) {
        cnt[s[i]-'a']++;
        if (i % 2 == 1) { // 分割点必须在奇数位置
            bool flag = true;
            for (int j = 1; j <= i/2; j++) {
                if (cnt[s[j]-'a'] != cnt[s[j+i/2]-'a']) {
                    flag = false;
                    break;
                }
            }
            if (flag) return true;
        }
    }
    return false;
}

总结

本文介绍了三种解决方案来检查是否可以将一个字符串拆分为两个具有相同 K 频字符数的字符串。方案一是最朴素的做法，时间复杂度较高；方案二通过使用哈希表优化，时间复杂度得到了优化；方案三使用前缀和来优化哈希表，使得时间复杂度进一步降低。