294. 计算重复（算法竞赛进阶指南，倍增优化 DP）

最新推荐文章于 2025-03-02 15:58:18 发布

原创最新推荐文章于 2025-03-02 15:58:18 发布 · 334 阅读

1 ·

CC 4.0 BY-SA版权

倍增优化 DP 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一种算法，通过预处理和倍增技术，高效地找出使s2重复m次成为s1子序列的最大m值。使用二进制表示优化搜索过程，适用于字符串匹配和算法竞赛。

一.题目链接：

计算重复

二.题目大意：

题目简单易懂

三.分析：

题目要求最大的 m，使得 conn(s2, n2 * m) 是 conn(s1, n1) 的子序列.

等价于求最大的 h，使得 conn(s2, h) 是 conn(s1, n1) 的子序列

易知，m = h / n2.

第一想法是二分答案，可是 check 不好写，因此可以通过预处理 + 倍增求解.

由于在倍增枚举 k 时，如果能凑出来，那么需要知道应从当前点 s1[p] 跳多远

因此可以预处理出 f[i][j]: 从 s1[i] 开始，最少走多少，能包含 2^j 个 s2.

说的有点乱，详见代码.

四.代码实现：

/**
状态表示 f[i][j]: 从 s1[i] 开始，最少要走多少步，才能包含 2^j 个 s2
状态计算 f[i][j] = f[i][j - 1] + f[i + f[i][j - 1]][j - 1], j > 0
**/

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int M = (int)1e2;

int n1, n2;
char s1[M + 5], s2[M + 5];
ll f[M + 5][27];

ll work()
{
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    for(int i = 0; i < len1; ++i)
    {
        f[i][0] = 0;
        int p = i, c = 0;
        for(int j = 0; j < len2; ++j)
        {
            while(s1[p] != s2[j])
            {
                p = (p + 1) % len1;
                ++c;
                if(c == len1)
                {
                    return 0;
                }
            }
            f[i][0] += c + 1;
            c = 0;
            p = (p + 1) % len1;
        }
    }
    for(int j = 1; j <= 26; ++j)
    {
        for(int i = 0; i < len1; ++i)
        {
            f[i][j] = f[i][j - 1] + f[(i + f[i][j - 1]) % len1][j - 1];
        }
    }
    ll p = 0, m = 0;
    for(int k = 26; k >= 0; --k)
    {
        if(p + f[p % len1][k] <= n1 * len1)
        {
            m |= (1<<k);
            p += f[p % len1][k];
        }
    }
    return m / n2;
}

int main()
{
//    freopen("input.txt", "r", stdin);
    while(~scanf("%s %d %s %d", s2, &n2, s1, &n1))
    {
        printf("%lld\n", work());
    }
    return 0;
}