【题解】洛谷 P2353 背单词

文章介绍了一个基于KMP算法和前缀和的解决方案,用于计算学生在特定文本区间内背诵单词的出现次数,以应对老师的随机提问。

原题链接:P2353 背单词

题目背景

小明对英语一窍不通,令老师十分头疼。于是期末考试前夕,小明被逼着开始背单词……

题目描述

老师给了小明一篇长度为 n n n 的英语文章,然后让小明背 m m m 个单词。为了确保小明不会在背单词时睡着,老师会向他提 Q Q Q 个问题,每次老师随机选择一个区间 [ l , r ] [l,r] [l,r],小明要回答在这段文字中他背过的单词总共出现过多少次。

输入格式

第一行两个整数 m , Q m,Q m,Q 如前所述。第二行为英语文章。接下来 m m m 行每行一个需要背的单词。接下来 Q Q Q 行每行一个询问,包含两个整数 l , r l,r l,r(含端点),即给定的文字区间。

输出格式

Q Q Q 行,对每个询问输出一行表示答案。

样例 #1

样例输入 #1
3 3
abcabcbc
abc
bc
a
1 3
6 7
1 8
样例输出 #1
3
0
7

提示

数据范围:

对于 30 % 30\% 30% 的数据, 1 ≤ n ≤ 1 0 3 , 1 ≤ Q ≤ 1 0 3 1\le n\le 10^3,1\le Q\le 10^3 1n103,1Q103

对于 60 % 60\% 60% 的数据, 1 ≤ n ≤ 1 0 5 , 1 ≤ Q ≤ 1 0 5 1\le n\le 10^5,1\le Q\le 10^5 1n105,1Q105

对于 100 % 100\% 100% 的数据, 1 ≤ n ≤ 1 0 6 , 1 ≤ m ≤ 10 , 1 ≤ Q ≤ 1 0 6 , 1 ≤ 1\le n\le 10^6,1\le m\le 10,1\le Q\le 10^6,1\le 1n106,1m10,1Q106,1每个单词的长度 ≤ N , 1 ≤ l ≤ r ≤ n \le N,1\le l\le r\le n N,1lrn

提示:数据较大,请大家尽量采取高效率的读入输出方法。

知识点

KMP 字符串匹配,前缀和。

思路

观察数据范围,我们发现 Q ≤ 1 0 6 , m ≤ 10 Q \leq 10^6, m \leq 10 Q106,m10

于是考虑枚举每个小明背过的单词 p p p,跑 KMP 后开一个数组 f i , j f_{i,j} fi,j 记录原字符串 s s s 中模式串 p i p_i pi 完全匹配且匹配位置 左端点 s s s 前缀 [ 1 , j ] [1,j] [1,j] 中的 p i p_i pi 的个数。

不过接下来我们发现它不满足区间减法,也就是不能通过 f i , r − f i , l − 1 f_{i,r}-f_{i,l-1} fi,rfi,l1 直接求出。

这是因为尽管 p i p_i pi 左端点在区间 [ l , r ] [l,r] [l,r] 中,但不能保证右端点也在此区间中。

所以查询区间 [ l , r ] [l,r] [l,r] 的时候我们选择区间 [ l , r − ∣ p i ∣ + 1 ] [l,r-|p_i|+1] [l,rpi+1] 以保证这个字符串完整地在区间 [ l , r ] [l,r] [l,r] 中。

预处理时间复杂度 O ( M ∑ i = 1 M ∣ p i ∣ ) O(M\sum_{i=1}^{M}|p_i|) O(Mi=1Mpi),查询时间复杂度 O ( 1 ) O(1) O(1),可以接受。

代码

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1000010;

int M, Q;
char p[N], s[N];
int ne[N], cnt[N];
int f[11][N];

inline void get_next(char *p)
{
    int n = strlen(p + 1);
    memset(ne, 0, sizeof ne); // 多测需要清空
    for (int i = 2, j = 0; i <= n; i ++ )
    {
        while (j && p[i] != p[j + 1]) j = ne[j];
        if (p[i] == p[j + 1]) j ++ ;
        ne[i] = j;
    }
}

inline void kmp(int id, char *s, char *p)
{
    int n = strlen(p + 1), m = strlen(s + 1);
    for (int i = 1, j = 0; i <= m; i ++ )
    {
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j ++ ;
        if (j == n) f[id][i - j + 1] ++ ; // 如果完全匹配则在左端点为 i - j + 1 的位置 + 1
    }
}

int main()
{
    scanf("%d%d", &M, &Q);
    scanf("%s", s + 1);
    int m = strlen(s + 1);

    for (int i = 1; i <= M; i ++ )
    {
        scanf("%s", p + 1); // 读入每个模式串 p
        get_next(p); // 处理 p 的 next 数组
        kmp(i, s, p); // KMP 并处理 f 数组
        cnt[i] = strlen(p + 1); // cnt 记录 p 的长度
        for (int j = 1; j <= m; j ++ )
            f[i][j] += f[i][j - 1]; // 前缀和
    }

    int l, r;
    while (Q -- )
    {
        scanf("%d%d", &l, &r);
        int res = 0;
        for (int i = 1; i <= M; i ++ )
            if (r - cnt[i] + 1 > l - 1) // 当且仅当左端点最晚出现位置在 l - 1 之后才计入答案
                res += f[i][r - cnt[i] + 1] - f[i][l - 1];
        printf("%d\n", res);
    }

    return 0;
}
洛谷 P2516 题目涉及的是一个与字符串处理和动态规划相关的挑战。题目要求对一个由数字组成的字符串进行分割,使得每个分割出的数字子串能构成一个递增序列,并且每部分对应的数值都比前一部分大。以下是解题思路及实现方法。 ### 问题解析 - 输入是一个长度不超过 **40** 的纯数字字符串。 - 目标是将该字符串分割成若干个非空数字子串,这些子串所表示的数值形成一个严格递增序列。 - 每个分割出来的子串必须满足其数值大于前一个子串的数值。 - 最终输出所有可能的合法分割方案的数量。 ### 解法概述 此问题可以通过 **深度优先搜索 (DFS)** 或 **回溯法** 来解决: - 使用递归的方式尝试在每一个位置进行分割。 - 对于每一次分割,提取当前子串并转换为整数,然后判断它是否大于上一次分割得到的值。 - 如果符合递增条件,则继续递归处理剩余的字符串部分。 - 当遍历完整个字符串并且满足所有分割条件时,计数器加一。 ### 实现细节 - 因为输入字符串长度最大为 **40**,所以需要考虑大数问题(超过 `int` 范围),建议使用 `long long` 类型或 Python 中的 `int` 类型自动处理大整数。 - 在分割过程中,确保没有前导零(除非子串长度为 1)。 - 递归终止条件是字符串已经被完全分割。 ### 示例代码 (C++) ```cpp #include <iostream> #include <string> using namespace std; int count = 0; // 将字符串 s 的 [start, end) 子串转换为整数 long long to_number(const string &s, int start, int end) { long long num = 0; for (int i = start; i < end; ++i) { num = num * 10 + (s[i] - '0'); } return num; } // DFS 函数:从 pos 位置开始分割,last_num 表示上一次分割出的数 void dfs(const string &s, int pos, long long last_num) { if (pos == s.size()) { count++; return; } for (int i = pos + 1; i <= s.size(); ++i) { // 剪枝:如果子串长度大于1且以0开头,则跳过 if (i - pos > 1 && s[pos] == '0') break; long long current = to_number(s, pos, i); if (current > last_num) { dfs(s, i, current); } } } int main() { string s; cin >> s; dfs(s, 0, -1); // 初始时 last_num 设置为 -1,保证第一个数可以任意选择 cout << count << endl; return 0; } ``` ### 算法复杂度分析 - 时间复杂度:最坏情况下为指数级 $O(2^n)$,因为每次递归都有多个分支。 - 空间复杂度:主要取决于递归栈深度,最多为 $O(n)$。 这种方法适用于题目给定的数据规模(字符串长度 ≤ 40),通过适当的剪枝优化,可以在合理时间内完成计算。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星河依旧长明

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值