2019南昌邀请赛网络预选赛 M. Subsequence

传送门

M. Subsequence（思维）

•题意

　　给出一个只包含小写字母的字符串 $s$；

　　接下来给你和 n 个 串 $t_{1,2,...,n}$，判断第 i 个串 $t_i$ 是否为 串 s 的子序列；

　　如果是，输出"YES"，反之，输出"NO"；

•题解

　　将 $s$ 中 26 个字母出现的位置分别记录下来；

　　我放在了 vector<> 中；

 int n=strlen(s+);///个人习惯，s下标从1开始
 for(int i=;i <= n;++i)
     v[s[i]-'a'].push_back(i);

　　假设当前要找的串 $t$ 长度为 m；

　　那么，在匹配 $t_1$ 时，只需判断一下 $v[t_1 -\ 'a'].size()$ 是否大于 0 即可；

　　如果 > 0 ，那么 $t_1$ 就匹配 $s$ 中的 $v[t_1 -\ 'a'][0]$ 位置；

　　并定义 $pre=v[t_1 -\ 'a'][0]$，记录一下之前匹配好的位置；

　　接下来匹配 $t_2$，类似 $t_1$ 的匹配；

　　但是这次不仅要判断  $v[t_2 -\ 'a'].size()$ 是否大于 0，还需要找到 $v[t_2 -\ 'a']$ 是否存在 > pre 的值；

　　因为 $t_2$ 在 $s$ 中匹配的位置势必要在 $t_1$ 之后，如果找到，更新 pre = $t_2$ 匹配的位置；

　　然后，根据如上方式匹配 $t_2 , t_3 , \cdots , t_m$；

　　存在匹配不成功的地方，就返回 false；

　　我是将这个匹配方式放到了 Find() 函数里的；

　　定义数组 a，$a_i$ 表示 $'a'+i$ 字符在 v 中匹配到的位置；

 bool Find()
 {
     int m=strlen(t+);

     mem(a,);
     int pre=;
     for(int i=;i <= m;++i)
     {
         int x=t[i]-'a';
         ///在v[x]中查找第一个 > pre 的位置
         for(;a[x] < v[x].size() && v[x][a[x]] <= pre;a[x]++);

         ///匹配失败，返回false
         if(a[x] == v[x].size())
             return false;
         ///匹配成功，更新pre
         pre=v[x][a[x]];
     }
     return true;
 }

•Code

　　2019南昌邀请赛网络预选赛M.cpp

•坑点

　　起初，Find() 函数里，在 v[x] 中查找第一个 > pre 的位置时我用的方法是在 v[x] 中二分查找；

 auto it=upper_bound(v[x].begin(),v[x].end(),pre);

　　每次判断 it 是否为 v[x].end();

　　一直TLE可还行；

　　

　　这种题就是用来卡二分的么，可记住了；

•相似题（分割线：2019.6.21）

　　类比Codeforces #565C 这道题，发现，这两道题有异曲同工之妙；

　　首先，再分析一下本题的做法：

　　在 s串中找 t串，如果找到，输出 "YES"，反之，输出 "NO"；

　　如果将题意改为查找 s串 中最多有多少个 t串 呢？

　　在类比一下Codeforces这道题，是不是发现两者的做法一样呢？

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define memF(a,b,n) for(int i=0;i <= n;a[i++]=b);
 const int maxn=1e5+;

 char s[maxn];
 char t[maxn];
 int a[];
 vector<int >p[];///存储字母在s中出现的位置

 char *Solve()
 {
     memF(a,,);

     int len=strlen(t+);
     int cur=;
     for(int i=;i <= len;++i)
     {
         int index=t[i]-'a';
         for(;a[index] < p[index].size() && p[index][a[index]] <= cur;a[index]++);
         if(a[index] == p[index].size())
             return "NO";
         cur=p[index][a[index]];
     }
     return "YES";
 }
 void Init()
 {
     for(int i=;i < ;++i)
         p[i].clear();
     int len=strlen(s+);
     for(int i=;i <= len;++i)
         p[s[i]-'a'].push_back(i);
 }
 int main()
 {
     scanf("%s",s+);
     Init();

     int test;
     scanf("%d",&test);
     while(test--)
     {
         scanf("%s",t+);
         puts(Solve());
     }
     return ;
 }