2022秋招京东笔试——小红的漂亮串

题目

小红定义"漂亮串"为:至少有两个 red 子串。例如redcred为漂亮串， 但reedred则不是漂亮串，小红想知道，长度为 \(n\) 的、仅包含小写字母的字符串中，共有多少种不同的漂亮串?

思路

这道题我们正着考虑发现很难，那么本着正难则反的原则，我们反向攻破。漂亮串的总数等于总的方案数-没有red的方案数-只有一个red的方案数，我们可以利用动态规划来求。

求没有red的方案数

1. 定义dp[N][4],
   • dp[i][1]: 长度为 i,以 r 结尾的方案数
   • dp[i][2]: 长度为 i,以 e 结尾的方案数
   • dp[i][3]: 长度为 i,以 e 结尾的方案数
   • dp[i][0]: 长度为 i,以其他小写字母结尾的方案数
2. 很容易得到转移方程：
   • \(dp[i][0] = 23*\sum_{j=0}^4dp[i][j]\)
   • \(dp[i][1] = \sum_{j=0}^3dp[i][j]\)
   • \(dp[i][2] = \sum_{j=0}^3dp[i][j]\)
   • \(dp[i][3] = \sum_{j=0}^3dp[i][j]-dp[i-2][1]\)

那么最后没有red的方案数 $ res1 = \sum_{j=0}^3dp[n][j]$

只有一个red的方案数

我们利用上面的dp数组来求，枚举red的位置i，然后red的左右两侧的方案数相乘
\(res2 = \sum_{i=1}^{n-2}(\sum_{j=0}^3dp[i-1][j] * \sum_{j=0}^3dp[n-3-(i-1)][j])\)
最后的答案就是：
\(26^n - res1 - res2\)

点击查看代码

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e6 + 9;
const int mod = 1e9 + 7;
ll dp[N][4];
int qmi(int x, int k)
{
    int res = 1;
    while (k)
    {
        if (k & 1)
            res = 1ll * res * x % mod;
        k >>= 1;
        x = 1ll * x * x % mod;
    }
    return res;
}
int main()
{
    int n;
    cin >> n;
    ll res1 = 0, res2 = 0,ans=0;
    dp[1][0] = 23;
    dp[1][1] = 1, dp[1][2] = 1, dp[1][3] = 1;
    dp[2][1] = 26, dp[2][2] = 26, dp[2][3] = 26;
    dp[2][0] = 26 * 23;
    for (int i = 3; i <= n; ++i)
    {
        ll tmp = (dp[i - 1][0] + dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3]) % mod;
        dp[i][0] = 23 * tmp % mod;
        dp[i][1] = tmp % mod;
        dp[i][2] = tmp % mod;
        dp[i][3] = ((tmp - dp[i - 2][1]) % mod + mod) % mod;
    }
    for (int i = 0; i <= 3; ++i)
        res1 = (res1 + dp[n][i]) % mod;
    for (int i = 1; i <= n - 2; ++i)
    {
        ll tmp = (dp[i - 1][0] + dp[i - 1][1] + dp[i - 1][2] + dp[i - 1][3]) % mod;
        int x = n - 2 - i;
        ll tmp2 = (dp[x][0] + dp[x][1] + dp[x][2] + dp[x][3]) % mod;
        //注意这里tmp=dp[0][0~4]时为0，所以要和1取一个max
        tmp = max(1ll, tmp), tmp2 = max(1ll, tmp2);
        res2 = (res2 + tmp * tmp2 % mod) % mod;
    }
    ans = (qmi(26, n) - res1-res2) % mod;
    ans = (ans + mod) % mod;
    cout << ans;
    return 0;
}

/*
in:
189999
out:
438952839
in:
1000000
out:
562818096
 */