20200807 练习：字符串

最新推荐文章于 2022-07-25 01:54:06 发布
最新推荐文章于 2022-07-25 01:54:06 发布
阅读量248 收藏 1
点赞数
分类专栏： 练习 # 矩阵乘法快速幂 -----字符串算法-----
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongkongreporter/article/details/107871433
版权

T1 P3193 [HNOI2008]GT考试

思路：
设 f i , j f_{i,j} fi,j​ 表示有 i i i 个号码，kmp 上匹配到第 j j j 位时的情况总数
g i , j g_{i,j} gi,j​ 表示 kmp 上第 i i i 个位置转移到第 j j j 个位置的总方案数
有 dp 方程：
f i , j = ∑ k = 0 m f i − 1 , k × g k , j f_{i,j}=\sum_{k=0}^{m} f_{i-1,k}\times g_{k,j} fi,j​=k=0∑m​fi−1,k​×gk,j​
时间复杂度： O ( n ) O(n) O(n)
考虑优化
发现 f f f 的第一维是递推关系，可以矩阵快速幂
最后的答案就是 [ 1 , 0...0 ] [1,0...0] [1,0...0] 乘上转移矩阵的 n n n 次方
就是转移矩阵的 n n n 次方的第零行和

代码：

#include <bits/stdc++.h>
using namespace std;
#define re register
namespace IO {
  char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                                 \
  (_p1 == _p2 &&                                                             \
   (_p2 = (_p1 = _buf) + fread(_buf, 1, 1 << 21, stdin), _p1 == _p2) \
   ? EOF                                                                 \
   : *_p1++)
  inline int in() {
    int s = 0, f = 1;
    char x = getchar();
    while (x < '0' || x > '9') {
      if (x == '-') f = -1;
      x = getchar();
    }
    while (x >= '0' && x <= '9') {
      s = (s * 10) + (x & 15);
      x = getchar();
    }
    return f = 1 ? s : -s;
  }
  char _buf_[1 << 21];
  int _p1_ = -1;
  inline void flush() {
    fwrite(_buf_, 1, _p1_ + 1, stdout);
    _p1_ = -1;
  }
  inline void pc(char x) {
    if (_p1_ == (1 << 21) - 1) flush();
    _buf_[++_p1_] = x;
  }
  inline void out(int x) {
    char k[20];
    int tot = 0;
    if (!x) {
      pc('0');
      return;
    }
    if (x < 0) {
      pc('-');
      x = -x;
    }
    while (x) {
      k[++tot] = (x % 10) | 48;
      x /= 10;
    }
    for (int i = tot; i; i--) pc(k[i]);
    return;
  }
}  // namespace IO
using namespace IO;

const int A = 50;
int n, m, mod;
char a[A];
int fail[A];
struct node {
  int s[A][A];
  inline void clean() {
    for (int i = 0; i < m; i++)
      for (int j = 0; j < m; j++) s[i][j] = 0;
    return;
  }
  inline friend node operator*(const node u, const node v) {
    node r;
    r.clean();
    for (int i = 0; i < m; i++)
      for (int j = 0; j < m; j++)
        for (int k = 0; k < m; k++)
          r.s[i][k] = (r.s[i][k] + u.s[i][j] * v.s[j][k] % mod) % mod;
    return r;
  }
} p;

inline void prepare() {
  for (int i = 1, j = 0; i <= m; i++) {
    while (j && a[i + 1] != a[j + 1]) j = fail[j];
    if (a[i + 1] == a[j + 1]) j++;
    fail[i + 1] = j;
  }
  for (int i = 0; i < m; i++) {
    for (int j = 0; j <= 9; j++) {
      int t = i;
      while (t && a[t + 1] != j + '0') t = fail[t];
      if (a[t + 1] == j + '0') t++;
      p.s[i][t]++;
    }
  }
  return;
}

inline node power(node u, int c) {
  node r;
  r.clean();
  for (int i = 0; i < m; i++) r.s[i][i] = 1;
  while (c) {
    if (c & 1) r = r * u;
    u = u * u;
    c >>= 1;
  }
  return r;
}

signed main() {
  n = in(), m = in(), mod = in();
  scanf("%s", a + 1);
  prepare();
  p = power(p, n);
  int res = 0;
  for (int i = 0; i < m; i++) res = (res + p.s[0][i]) % mod;
  out(res), pc('\n');
  flush();
  return 0;
}

T2 P3715 [BJOI2017]魔法咒语

上面那道题的加强版（加强了不止一个档次吧……

思路：
观察数据范围，分层做

对于前 60pts：
对禁止串建 ACM，对于每一个点预处理出每个串转移后的点
然后 AC自动机 上 dp 即可

对于后 40pts：
先考虑基本词汇长度为 1 的情况
类似上一道题，得出 dp 方程：
f i , j = ∑ k = 0 t o t f i − 1 , k × g k , j f_{i,j}=\sum_{k=0}^{tot}f_{i-1,k}\times g_{k,j} fi,j​=k=0∑tot​fi−1,k​×gk,j​
于是可以矩阵快速幂优化

考虑毒瘤的长度为 1,2 的情况
对于一组 f i f_i fi​ 可以由 f i − 1 , f i − 2 f_{i-1},f_{i-2} fi−1​,fi−2​ 转移
发现类似斐波那契数列的转移
类比斐波那契数列的矩阵
∣ f i , 0 f i , 1 . . . f i , t o t f i − 1 , 0 f i − 1 , 1 . . . f i − 1 , t o t ∣ ⇓ ∣ f i + 1 , 0 f i + 1 , 1 . . . f i + 1 , t o t f i , 0 f i , 1 . . . f i , t o t ∣ \left| \begin{matrix} f_{i,0} & f_{i,1} & ... & f_{i,tot} & f_{i-1,0} & f_{i-1,1} & ... & f_{i-1,tot}\\ \end{matrix} \right|\\ \Downarrow\\ \left| \begin{matrix} f_{i+1,0} & f_{i+1,1} & ... & f_{i+1,tot} &f_{i,0} & f_{i,1} & ... & f_{i,tot}\\ \end{matrix} \right|\\ ∣∣​fi,0​​fi,1​​...​fi,tot​​fi−1,0​​fi−1,1​​...​fi−1,tot​​∣∣​⇓∣∣​fi+1,0​​fi+1,1​​...​fi+1,tot​​fi,0​​fi,1​​...​fi,tot​​∣∣​
建出转移矩阵
在这里插入图片描述
手玩理解
然后矩阵快速幂即可

代码：

#include <bits/stdc++.h>
using namespace std;
#define re register
#define int long long
namespace IO {
char _buf[1 << 21], *_p1 = _buf, *_p2 = _buf;
#define ch()                                                                 \
  (_p1 == _p2 &&                                                             \
           (_p2 = (_p1 = _buf) + fread(_buf, 1, 1 << 21, stdin), _p1 == _p2) \
       ? EOF                                                                 \
       : *_p1++)
inline int in() {
  int s = 0, f = 1;
  char x = getchar();
  while (x < '0' || x > '9') {
    if (x == '-') f = -1;
    x = getchar();
  }
  while (x >= '0' && x <= '9') {
    s = (s * 10) + (x & 15);
    x = getchar();
  }
  return f = 1 ? s : -s;
}
char _buf_[1 << 21];
int _p1_ = -1;
inline void flush() {
  fwrite(_buf_, 1, _p1_ + 1, stdout);
  _p1_ = -1;
}
inline void pc(char x) {
  if (_p1_ == (1 << 21) - 1) flush();
  _buf_[++_p1_] = x;
}
inline void out(int x) {
  char k[20];
  int tot = 0;
  if (!x) {
    pc('0');
    return;
  }
  if (x < 0) {
    pc('-');
    x = -x;
  }
  while (x) {
    k[++tot] = (x % 10) | 48;
    x /= 10;
  }
  for (int i = tot; i; i--) pc(k[i]);
  return;
}
}  // namespace IO
using namespace IO;

const int A = 210;
const int mod = 1e9 + 7;
int n, m, L;

char a[55][A], b[A];
int s[A];
int tr[A][26], tot;
int tag[A], fail[A];
inline void add() {
  int len = strlen(b + 1);
  int p = 0;
  for (int i = 1; i <= len; i++) {
    if (!tr[p][b[i] - 'a']) tr[p][b[i] - 'a'] = ++tot;
    p = tr[p][b[i] - 'a'];
  }
  tag[p] = 1;
  return;
}
inline void build() {
  queue<int> q;
  int p = 0;
  for (int i = 0; i < 26; i++) {
    p = tr[0][i];
    if (!p) continue;
    q.push(p);
  }
  while (!q.empty()) {
    int x = q.front();
    q.pop();
    for (int i = 0; i < 26; i++) {
      p = tr[x][i];
      if (!p) {
        tr[x][i] = tr[fail[x]][i];
        continue;
      }
      q.push(p);
      fail[p] = tr[fail[x]][i];
    }
    if (tag[fail[x]]) tag[x] = 1;
  }
  return;
}

namespace Sub1 {
int to[A][A], f[A][A];
inline void prepare() {
  for (int i = 0; i <= tot; i++)
    for (int j = 1; j <= n; j++) {
      int p = i, len = strlen(a[j] + 1);
      for (int k = 1; k <= len; k++) {
        p = tr[p][a[j][k] - 'a'];
        if (tag[p]) {
          p = -1;
          break;
        }
      }
      to[i][j] = p;
    }
  return;
}
inline void DP() {
  f[0][0] = 1;
  for (int i = 0; i < L; i++)
    for (int j = 0; j <= tot; j++)
      for (int k = 1; k <= n; k++)
        if (to[j][k] != -1)
          f[i + s[k]][to[j][k]] = (f[i + s[k]][to[j][k]] + f[i][j]) % mod;
  return;
}
inline void work() {
  prepare();
  DP();
  int res = 0;
  for (int i = 0; i <= tot; i++) res = (res + f[L][i]) % mod;
  out(res), pc('\n');
  flush();
  exit(0);
}
}  // namespace Sub1

namespace Sub2 {
struct Mat {
  int a[A][A];
  inline void clean() {
    for (int i = 0; i < (tot + 1) * 2; i++)
      for (int j = 0; j < (tot + 1) * 2; j++) a[i][j] = 0;
    return;
  }
  inline friend Mat operator*(Mat u, Mat v) {
    Mat r;
    r.clean();
    for (int i = 0; i < (tot + 1) * 2; i++)
      for (int j = 0; j < (tot + 1) * 2; j++)
        for (int k = 0; k < (tot + 1) * 2; k++)
          r.a[i][j] = (r.a[i][j] + u.a[i][k] * v.a[k][j] % mod) % mod;
    return r;
  }
} mx;
inline void prepare() {
  for (int i = 0; i <= tot; i++) {
    for (int j = 1; j <= n; j++) {
      if (s[j] == 1) {
        int p = tr[i][a[j][1] - 'a'];
        if (!tag[p]) mx.a[i][p]++;
      } else {
        int p = tr[i][a[j][1] - 'a'];
        if (tag[p]) continue;
        p = tr[p][a[j][2] - 'a'];
        if (!tag[p]) mx.a[i + tot + 1][p]++;
      }
    }
  }
  for (int i = 0; i <= tot; i++) mx.a[i][i + tot + 1] = 1;
  return;
}
inline Mat power(Mat s, int c) {
  Mat r;
  r.clean();
  for (int i = 0; i < (tot + 1) * 2; i++) r.a[i][i] = 1;
  while (c) {
    if (c & 1) r = r * s;
    s = s * s;
    c >>= 1;
  }
  return r;
}
inline void work() {
  prepare();
  mx = power(mx, L);
  int res = 0;
  for (int i = 0; i <= tot; i++) res = (res + mx.a[0][i]) % mod;
  out(res), pc('\n');
  flush();
  exit(0);
}
}  // namespace Sub2

signed main() {
  n = in(), m = in(), L = in();
  for (int i = 1; i <= n; i++) {
    scanf("%s", a[i] + 1);
    s[i] = strlen(a[i] + 1);
  }
  for (int i = 1; i <= m; i++) {
    scanf("%s", b + 1);
    add();
  }
  build();
  if (L <= 100)
    Sub1::work();
  else
    Sub2::work();
  return 0;
}
ハルカナソラヘ
关注
专栏目录
Python 课课练 (五)：字符串课后练习题
Amo Xiang的博客
03-22 4735
目录一、字符串课后练习题 练习前置知识 Chapter One : 开启 Python 之旅 Chapter Two : Python 语言基础、运算符与表达式、程序的控制结构合集 Chapter Three : Python 序列之字符串操作详解 一、字符串课后练习题 (1) 下列关于字符串的分割说法正确的是（）。 A. 分割是将字符串分割成任意序列 B. 指定了 split() 方法的最大分割次数，就必须分割这么多次 C. 在使用 split() 方法进行分割字符串时，如果不指定分隔符，就不能指定分
Java基础篇之查找与排序
桃花er的博客
03-23 1461
1. 二分查找(⭐) 要求 能够用自己语言描述二分查找算法 能够手写二分查找代码 能够解答一些变化后的考法 二分查找代码算法思路 前提：有已排序数组 A（假设已经做好） 定义左边界 L、右边界 R，确定搜索范围，循环执行二分查找（3、4两步） 获取中间索引 M = (L+R) /2 中间索引的值 A[M] 与待搜索的值 T 进行比较 ① A[M] == T 表示找到，返回中间索引 ② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为
Java运算符之&、|、&&、||、！
Together_CZ的博客
02-23 3201
在学习Java运算符的时候接触到&、&&、|、||几个容易混淆的逻辑运算符，在这里记录下来备忘     在这里先简单介绍一下：&是长路与或者按位与；&&是短路与；|是长路或；||是短路或；！是异或，直接解释不太好说明白而且，也不一定能理解，在这里我就用简单的程序来解释一下，相信大家看完之后很快都会明白短路与、或与长路与、或之间的区别了。 public class Luoji1 { publi
ACWing 状态机模型 && 状态压缩DP day39
qq_23852555的博客
07-25 280
训练记录
Java中逻辑运算符&&和&的区别,以及||的作用
wh445306
12-17 1444
Java中&&和&都是表示与的逻辑运算符，都表示逻辑运输符and，当两边的表达式都为true的时候，整个运算结果才为true，否则为false。 &&的短路功能，当第一个表达式的值为false的时候，则不再计算第二个表达式；&则两个表达式都执行。 &可以用作位运算符，当&两边的表达式不是Boolean类型的时候，&表示按位...
BAPC2014 J&&HUNNU11590:Jury Jeopardy
ACM！荣耀之路！
08-13 3725
题意： 一个迷宫，人一开始处在出口位置，要求遍历一次迷宫之后，回到初始位置，现在给出行走的方案，要出画出迷宫 人一开始面向右边 F：往前走一步 R：右转并往前走一步 L：左转并往前走一步 B：后转并往前走一步 思路： 直接模拟即可 #include #include #include #include #include #include #includ
第4关：字符串处理
JIACHENGCODE的博客
12-12 1800
include<stdio.h> #include<string.h> int main(void) { /*********Begin*********/ char arr1[1000]; char arr2[1000]; int n; char arr3[1000]={'\0'}; gets(arr1); gets(arr2); scanf("%d",&n); int i; int j; .
python/educoder 第1关：字符串基本操作
weixin_56636204的博客
10-26 3096
本关任务的目的是了解字符类型的特点，熟悉字符串的一些基本操作，包括赋值、拼接、重复、长度、索引、查找、替换、反转等常用操作。字符串最常见的一种基本数据类型。字符串是许多单个子串组成的序列，其主要是用来表示文本。注意：字符串是不可变数据类型，也就是说你要改变原字符串内的元素，只能是新建另一个字符串。 任务1 字符串拼接 依次输入两个字符串赋值给s1和s2，并将s1中所有英文字母转换为大写后连接到s2后面，并将拼接的结果赋值给s3，输出s3的值。 提示：应用“+”运算和字符串的upper()方法。 任务2
ES6: 模板字符串
热门推荐
gao_zhennan的博客
07-07 1万+
模板字符串主要用于插入表达式！
day08 17 Arrays练习：字符串倒序排列
08-31
day08_17_Arrays练习_字符串倒序排列
Python 编程难题：字符串练习.pptx
11-13
Python 编程难题：字符串练习是一个关于 Python 编程语言的难题题目，旨在检查给定列表中第 n-1 个字符串是否是第 n 个字符串的适当子字符串。下面是该难题的详细解释和解决方案。 问题描述 给定一个字符串列表，...
每日一题：字符串高效查找-前缀树
06-21
在实际编程练习中，通常会给出一些具体的字符串集合作为输入，然后检查前缀树的构建是否正确，以及查找操作是否准确。 至于标签“python”，这表明我们关注的是使用Python语言实现前缀树。Python的字典操作速度快且...
C语言基础练习题：素数判定与字符串反转实现
最新发布
09-19
内容概要：本文档提供了两道C语言练习题及其详细解法——素数判断和字符串反转。习题1通过定义函数isPrime，利用循环与模运算来验证任意一正整数是否属于质数之列，并巧妙地缩减检查范围来提升运行效能。习题2则展示...
Python编程练习：字符串操作与列表字典应用
本资源是一份Python练习题文档，包含了几个基础的编程题目，主要涉及Python语言的字符串处理和列表与字典操作。以下是对这些知识点的详细说明： **1. 字符串处理** - **字符串中数字个数统计**：该部分代码通过`...
20191012 练习：强连通分量
hongkongreporter
10-18 1117
总览： 就是生成搜索树，然后找返祖边。 模板： vector <int> ljb[N]; int dfn[N],low[N],tim,num,belong[N]; bool ex[N]; stack <int> st; void tarjan(int x) { dfn[x]=low[x]=++tim; st.push(x); ex[x]=1; for(int y...
20191025 练习：网络流（最大流最小割）
hongkongreporter
10-25 353
废话不说，直接上题 T1 P2756 飞行员配对方案问题 （https://www.luogu.org/problem/P2756） 题目背景 第二次世界大战时期… 题目描述 英国皇家空军从沦陷国征募了大量外籍飞行员。由皇家空军派出的每一架飞机都需要配备在航行技能和语言上能互相配合的222名飞行员，其中111名是英国飞行员，另111名是外籍飞行员。在众多的飞行员中，每一名外籍飞行员都可以与其他若干...
20191023 练习：dp
hongkongreporter
10-23 326
T1 P1060 开心的金明 NOIP 2006 普及组 第二题 0/1背包 代码： #include<bits/stdc++.h> using namespace std; #define in Read() int in{ int s=0;char x; for(x=getchar();!isdigit(x);x=getchar()); for( ;isdigit(x);x...
20200727 练习：生成函数（咕）
hongkongreporter
07-28 285
T1 CF438E The Child and Binary Tree 思路： 首先写出 dp 方程 枚举根节点的权值，拼接左右子树 f1=1fm=∑i=1mgi∑j=1m−ifjfm−i−j(m>1) f_1=1\\ f_m=\sum_{i=1}^mg_i\sum_{j=1}^{m-i}f_jf_{m-i-j}(m>1) f1​=1fm​=i=1∑m​gi​j=1∑m−i​fj​fm−i−j​(m>1) 其中 fif_ifi​ 为权值和为 i 时的种类数，gig_igi​ 为是否存在 c
20191030 练习：多源最短路
hongkongreporter
10-30 274
第二道黑题祭~~~ P5304 [GXOI/GZOI2019]旅行者 （P5304 [GXOI/GZOI2019]旅行者） 题目描述 JJJ 国有 nnn 座城市，这些城市之间通过 mmm 条单向道路相连，已知每条道路的长度。 一次，居住在 JJJ 国的 RainbowRainbowRainbow 邀请 VaniVaniVani 来作客。不过，作为一名资深的旅行者，VaniVaniVani 只对 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值