求解固定长度的回文子序列数目

最新推荐文章于 2023-11-26 13:10:36 发布

慢指针

最新推荐文章于 2023-11-26 13:10:36 发布

阅读量280

点赞数

分类专栏：常见算法汇总文章标签：算法 c++ 开发语言数据结构

本文链接：https://blog.csdn.net/weixin_43876403/article/details/128064845

版权

常见算法汇总专栏收录该内容

13 篇文章 1 订阅

订阅专栏

前言：有半年时间没有写博客了，今天写题目的时候遇到了一个之前完全没有见过的题目，因此前来记录一下。

问题描述

对于字符串 $s$ ，需要计算其中长度为 $k$ 的 回文子序列 数目，通常 $\le 5$ 。

1. $k = 2$

先简化问题，当 $k = 2$ 时，回文子序列的个数即为 $s$ 中的相同字符对，采用一次遍历便可以完成计算

long long solve(string s){
	int cnt[26] = {0};
	long long ans = 0;
	for(char c : s){
		int x = c - 'a';
		ans += cnt[x];
		cnt[x]++;
	}
	return ans;
}

时间复杂度： $O (n)$ ， $n$ 为字符串 $s$ 的长度。

2. $k = 3$

进一步考虑 $k = 3$ 的情况，由于 $k$ 为奇数，枚举 $s$ 中的每一个字符 $c$ 作为中心字符，同时枚举第一个字符的可能取值。
实现细节：当下标为 $i$ 时，需要考虑 $i$ 的左右两部分，即分别进行前缀和后缀计数。首先逆向遍历 $s$ ，统计每个字符出现的数目 $s u f [a]$ ，再正向遍历，统计 $p r e [a]$ 的同时更新 $s u f$ ，实现前后缀同步。
题目示范：L.C. 1930. 长度为 3 的不同回文子序列

class Solution {
public:
    int countPalindromicSubsequence(string s) {
        int n = s.size();
        int suf[26] = {0}, pre[26] = {0};
        for(int i = 0; i < n; ++i){
            suf[s[i] - 'a']++;
        }
        int ans[26][26];
        memset(ans, 0, sizeof(ans));
        
        for(int i = 0; i < n; ++i){
            int x = s[i] - 'a';
            suf[x]--;
            for(int j = 0; j < 26; ++j){
                if(pre[j] > 0 && suf[j] > 0)
                    ans[x][j] = 1;
            }
            pre[x]++;
        }
        int ret = 0;
        for(int i = 0; i < 26; ++i){
            for(int j = 0; j < 26; ++j){
                ret += ans[i][j];
            }
        }
        return ret;
    }
};

时间复杂度： $\left | \Sigma \right |)$ ， $n$ 为字符串 $s$ 的长度， $\left | \Sigma \right |$ 为字符集大小

3. $\in [4, 5]$

难度升级，考虑 $\in [4, 5]$ 的情况。对于 $\in [4, 5]$ ，可以分别从 $k = 2$ 和 $k = 3$ 的情况实现进一步递推。
对于 $\in [2, 3]$ ，我们枚举右边的一个字符，因此对于 $\in [4, 5]$ ，我们需要枚举右边的两个字符。
实现细节：
- 首先逆向遍历 $s$ ，统计每一个字符出现的数目 $s u f [a]$ 和两个字符的组合数目 $s u f 2 [a] [b]$ 。
- 再正向遍历 $s$ ，同样维护两个数组 $p r e [a]$ 和 $p r e 2 [a] [b]$ ，并在遍历过程中枚举两个字符的所有组合。
题目示范：L.C. 6251. 统计回文子序列数目

class Solution {
public:
    const int mod = 1e9 + 7;

    int suf2[10][10], suf[10];
    int pre2[10][10], pre[10];
    
    int countPalindromes(string s) {
        int n = s.size();
        
        for(int i = n - 1; i >= 0; --i){
            int x = s[i] - '0';
            for(int j = 0; j < 10; ++j){
                suf2[x][j] = (suf2[x][j] + suf[j]) % mod;
            }
            suf[x]++;
        }
        
        int ans = 0;
        for(char c : s){
            int x = c - '0';
            // 撤销后缀
            suf[x]--;
            for(int j = 0; j < 10; ++j){
                suf2[x][j] = (suf2[x][j] - suf[j] + mod) % mod;
            }
            // 枚举两个字符的所有可能情况
            for(int j = 0; j < 10; ++j){
                for(int k = 0; k < 10; ++k){
                    ans = (ans + (1LL * pre2[j][k] * suf2[j][k]) % mod) % mod;
                }
            }
            // 计算前缀
            for(int j = 0; j < 10; ++j){
                pre2[x][j] = (pre2[x][j] + pre[j]) % mod;
            }
            pre[x]++;
        }      
        return ans;
    }
};

时间复杂度： $\left | \Sigma \right |^2)$ ， $n$ 为字符串 $s$ 的长度， $\left | \Sigma \right |$ 为字符集大小
注意：对于 $k = 4$ 和 $k = 5$ 虽然在算法的具体思路上是相似的，但是在实现细节上有些许不同：
- 对于 $k = 5$ ，需要枚举中心字符，因此当遍历到下标 $i$ 时，需要先撤销后缀，再枚举字符组合，最后更新前缀，总是仅覆盖 $n - 1$ 个字符。
- 对于 $k = 4$ ，由于不存在中心字符，因此可以 在撤销后缀的同时更新前缀，再枚举字符组合，覆盖 $n$ 个字符。
$k = 4$ 的部分代码

 for(char c : s){
    int x = c - '0';
    // 撤销后缀 + 更新前缀
    suf[x]--;
    for(int j = 0; j < 10; ++j){
        suf2[x][j] = (suf2[x][j] - suf[j] + mod) % mod;
        pre2[x][j] = (pre2[x][j] + pre[j]) % mod;
    }
    pre[x]++;
    // 枚举两个字符的所有可能情况
    for(int j = 0; j < 10; ++j){
        for(int k = 0; k < 10; ++k){
            ans = (ans + (1LL * pre2[j][k] * suf2[j][k]) % mod) % mod;
        }
    }
}