LeetCode 1177. 构建回文串检测

算法白菜

于 2024-07-15 21:31:23 发布

阅读量793

点赞数 19

文章标签： leetcode 算法职场和发展开发语言 java python

本文链接：https://blog.csdn.net/m0_56090828/article/details/140448866

版权

1177. 构建回文串检测

给你一个字符串 s，请你对 s 的子串进行检测。

每次检测，待检子串都可以表示为 queries[i] = [left, right, k]。我们可以 重新排列子串 s[left], ..., s[right]，并从中选择最多 k 项替换成任何小写英文字母。

如果在上述检测过程中，子串可以变成回文形式的字符串，那么检测结果为 true，否则结果为 false。

返回答案数组 answer[]，其中 answer[i] 是第 i 个待检子串 queries[i] 的检测结果。

注意：在替换时，子串中的每个字母都必须作为 独立的 项进行计数，也就是说，如果 s[left..right] = "aaa" 且 k = 2，我们只能替换其中的两个字母。（另外，任何检测都不会修改原始字符串 s，可以认为每次检测都是独立的）

示例：

输入：s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
输出：[true,false,false,true,true]
解释：
queries[0] : 子串 = "d"，回文。
queries[1] : 子串 = "bc"，不是回文。
queries[2] : 子串 = "abcd"，只替换 1 个字符是变不成回文串的。
queries[3] : 子串 = "abcd"，可以变成回文的 "abba"。 也可以变成 "baab"，先重新排序变成 "bacd"，然后把 "cd" 替换为 "ab"。
queries[4] : 子串 = "abcda"，可以变成回文的 "abcba"。

提示：

1 <= s.length, queries.length <= 10^5
0 <= queries[i][0] <= queries[i][1] < s.length
0 <= queries[i][2] <= s.length
s 中只有小写英文字母

提示 1

Since we can rearrange the substring, all we care about is the frequency of each character in that substring.

提示 2

How to find the character frequencies efficiently ?

提示 3

As a preprocess, calculate the accumulate frequency of all characters for all prefixes of the string.

提示 4

How to check if a substring can be changed to a palindrome given its characters frequency ?

提示 5

Count the number of odd frequencies, there can be at most one odd frequency in a palindrome.

解法1：前缀数组 + 哈希

提示 1
由于我们可以重新排列子串，因此我们只需关心该子串中每个字符的频率。

提示 2
如何高效地找到字符频率？

提示 3
作为预处理，计算字符串所有前缀的所有字符的累积频率。

提示 4
如何根据一个子串的字符频率来检查它是否可以变为一个回文字符串？

提示 5
计算奇数频率的数量，在一个回文中最多只能有一个奇数频率。

遍历所有 queries，待检子串都可以表示为 [left,right,k]。

利用前缀和数组，可以得到待检子串每一个字母的奇偶性。出现偶数次的字母，可以对称放在字符串两侧，构成回文串，剩下的出现奇数次字母配对后，还会剩余，需要从中选择最多 k 项替换成任何小写英文字母。替换 k 次，可以保证使得长度最长为 2*k+1 的字符串变成回文串。所以我们只需要判断，待检子串的奇数次字母的数量，是否小于等于 2*k+1 即可。

最后返回所有 queries 的结果作为答案。

Java版：

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[][] prefix = new int[n + 1][26];
        for (int i = 0; i < n; i++) {
            System.arraycopy(prefix[i], 0, prefix[i + 1], 0, 26);
            prefix[i + 1][s.charAt(i) - 'a']++;
        }
        int m = queries.length;
        List<Boolean> ans = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            int odd = 0;
            int left = queries[i][0];
            int right = queries[i][1];
            int k = queries[i][2];
            for (int j = 0; j < 26; j++) {
                odd += (prefix[right + 1][j] - prefix[left][j]) % 2 == 0 ? 0 : 1;
            }
            ans.add(odd <= 2 * k + 1);
        }
        return ans;
    }
}

Python3版：

class Solution:
    def canMakePaliQueries(self, s: str, queries: List[List[int]]) -> List[bool]:
        n = len(s) 
        prefix = [[0] * 26 for _ in range(n + 1)]
        print(prefix)
        for i, c in enumerate(s):
            prefix[i + 1] = prefix[i].copy()
            prefix[i + 1][ord(c) - ord('a')] += 1
        m = len(queries)
        ans = []
        for i in range(m):
            odd = 0
            left = queries[i][0]
            right = queries[i][1]
            k = queries[i][2]
            for j in range(26):
                odd += 0 if (prefix[right + 1][j] - prefix[left][j]) % 2 == 0 else 1
            
            ans.append(True if odd <= 2 * k + 1 else False) 
            
        return ans

复杂度分析

时间复杂度：O(n+m)，其中 n 是字符串 s 的长度，m 是 queries 的长度。忽略统计位 1 的个数的时间复杂度。

空间复杂度：O(n+m)，其中 n 是字符串 s 的长度，m 是 queries 的长度。

解法2: 前缀数组 + 位运算

移位运算。

其中 << 表示左移, >> 表示右移。注：左移 i 位相当于乘以 2^i ，右移 i 位相当于除以 2^i 。

将 26 个英文字母，对应 26 个位来表示。比如字母 a 对应 1<<0, 字母 b 对应 1<<1，字母 c 对应 1<<2，以此类推。

这样可以将字符串 s 看成一个数组，然后统计数组的异或前缀和 prefix，这样就可以统计每一个字母的奇偶性。

遍历所有 queries，待检子串都可以表示为 [left,right,k]。利用异或前缀和数组，可以得到待检子串每一个字母的奇偶性。出现偶数次的字母，可以对称放在字符串两侧，构成回文串，剩下的出现奇数次字母配对后，还会剩余，需要从中选择最多 k 项替换成任何小写英文字母。替换 k 次，可以保证使得长度最长为 2*k+1 的字符串变成回文串。所以我们只需要判断，待检子串的为 1 数位，是否小于等于 2*k+1 即可。

最后返回所有 queries 的结果作为答案。

Java版：

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[] prefix = new int[n + 1];
        for (int i = 0; i < n; i++) {
            prefix[i + 1] = prefix[i] ^ (1 << (s.charAt(i) - 'a'));
        }
        int m = queries.length;
        List<Boolean> ans = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            int left = queries[i][0];
            int right = queries[i][1];
            int k = queries[i][2];
            int bits = Integer.bitCount(prefix[right + 1] ^ prefix[left]);
            ans.add(bits <= 2 * k + 1);
        }
        return ans;
    }
}

Python3版：

class Solution:
    def canMakePaliQueries(self, s: str, queries: List[List[int]]) -> List[bool]:
        n = len(s)
        prefix = [0] * (n + 1)
        for i, c in enumerate(s):
            prefix[i + 1] = prefix[i] ^ (1<< (ord(c) - ord('a')))

        ans = []
        for left, right, k in queries:
            bits = (prefix[right + 1] ^ prefix[left]).bit_count()
            ans.append(bits <= 2 * k + 1)
        return ans

复杂度分析