2022杭电多校 2H / HDU 7157 - Keyboard Warrior （KMP）

Problem Link

题意

给定一个长度为 \(n\) 的字符串 \(S\) 及 \(m\) 次操作，初始时打字机为空

每次操作可以往打字机上的字符串尾部按顺序添加 \(k\) 次字符 \(ch\)，或是从打字机上的字符串尾部删去 \(k\) 次字符(即键盘 Backspace)

问是否存在一个时刻，使得字符串 \(S\) 是打字机上的字符串的子串？

\(1\le n,m\le 2\times 10^5\)

\(0\le k\le 10^9\)

思路

变量名就按照代码里写的来命名了

写在前面：

本文即思考一种方法来优化题解里说的反复弹跳，即下文 \(match\) 数组，用于记录 KMP 过程中的模式串下标 \(j\)，在往回弹跳后可直接继承变量来重做某位置的 KMP

UPD 22/07/25: 寄了QAQ

---

考虑按照顺序模拟每次操作，使用 \(pair(char,count)\) 形式来存储当前字符串

首先将输入的字符串 \(S\) 处理为该形式，存储于 \(bvec\) 内(例如，字符串 \(abbbaa\) 可用 \(vector\{(a,1),(b,3),(a,2)\}\) 来描述)

接下来维护打字机上的字符串，同样按照上述形式来存储于 \(svec\) 内，可以借助栈的方法来做到 \(O(n)\)，每次如果要往尾部插入字符，且字符与栈顶字符相同则直接让栈顶字符出现次数加上 \(k\)，否则需要再 push 进一个 pair；如果要删除字符，则每次与栈顶字符出现次数进行比较，视情况减去或 pop 即可

按照上述的存储方法，即使打字机上的字符串非常长，vector 内的 pair 对数也不会超过 \(m\) 对，因此可以同时对比 \(pair(char,count)\) 这个二元组，也就是在 \(svec\)(维护打字机上的字符串)内查找是否存在一个连续子序列，二元组能够与 \(bvec\)(维护原字符串)“相对应”

这里所说的“相对应”，对于原串而言代表子字符串，但对于二元组序列而言，只需要首部和尾部的字符出现数量大于等于原串出现数量即可，不需要保证完全一致；但内部字符出现数量需要保证严格一致

举个例子：

5 4
abbab
a 2
b 2
a 1
b 2

打字机四步后打出的字符串为 \(aabbabb\)，原串出现在了 \(2\sim 6\) 这段区间内。对于开头的字符 \(a\)，在 \(svec\) 内描述为 \((a,2)\)，而 \(bvec\) 内为 \((a,1)\)，我们只需要拿右端的字符来匹配，所以视作可行；结尾的字符 \(b\) 同理；但中间的 \((b,2),(a,1)\) 需要严格保证一致

---

如果我们的操作不带删除，每次只会往结尾加上 \(k\) 个字符 \(ch\) 的话，如何做这题呢

考虑 KMP，处理出 \(bvec\) 的 \(Next\) 数组，表示如果在某位置出现失配时，下一步在最优情况下应该拿哪一个二元组继续进行匹配；该数组处理方法与经典的 KMP 一致

但根据上面所述，开头和结尾需要特殊判断，不需要严格一致，因此在后续的匹配过程中需要稍加修改，这里我又开了一个 \(match\) 数组，\(match[i]\) 表示 \(svec\)(主串)内的 \(i\) 位置往前与 \(bvec\)(模式串)最长能够匹配的长度，也就是记录下 KMP 匹配过程中到达位置 \(i\) 时模式串的下标 \(j\) 所在位置

如果当前下标 \(j=0\)，则判断相等的条件应为 \(svec[i].count\ge bvec[0].count\)；否则，条件定为 \(svec[i].count=bvec[j].count\)

对于最后一个位置，也这样特判一下，如果能直接完全对应(即 \(match[i]=bvec.size\))直接 YES，否则如果就差一个位置对应(即 \(match[i-1]=bvec.size-1\))，如上判断即可

---

由于本题存在删除操作，因此 \(svec.size\) 是需要变化的

但发现 size 初始是从 \(0\) 开始，且每次就算是新增二元组也只加一个，因此每次只需要维护 \(i=svec.size\) 这个末位置

每次先置 \(match[svec.size]=match[svec.size-1]\)，继承上一个位置的匹配状态；如果一直不匹配，则令 \(match[svec.size]=Next[match[svec.size]]+1\)，将其指向失配后的位置

因为使用了 \(match\) 来存储 \(j\) 这个在 KMP 中一直变化的变量，所以这里也就是重做 KMP 中间的某一步

---

时间复杂度大致 \(O(n+m)\)，但二元组的维护常数会有点大

Code

// Problem: H - Keyboard Warrior
// Contest: Virtual Judge - Cosmic Training / 2022 HDU Round 2
// URL: https://vjudge.net/contest/506261#problem/H
// Memory Limit: 512 MB
// Time Limit: 2000 ms
// 
// Author: StelaYuri
// Import Time: 2022-07-22 14:23:10.349
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define closeSync ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define multiCase int T;cin>>T;for(int t=1;t<=T;t++)
#define rep(i,a,b) for(auto i=(a);i<=(b);i++)
#define repp(i,a,b) for(auto i=(a);i<(b);i++)
#define pb push_back
typedef pair<char,int> pii;

int n,m;
char s[200050];
vector<pii> bvec,svec;
int siz;
int match[200050];
int Next[200050];
void getNext()
{
    Next[0]=-1;
    int j=-1;
    repp(i,1,siz)
    {
        while(j>-1&&bvec[j+1]!=bvec[i])
            j=Next[j];
        if(bvec[j+1]==bvec[i])
            j++;
        Next[i]=j;
    }
}

void solve()
{
    bvec.clear();
    svec.clear();
    
    cin>>n>>m;
    cin>>s;
    
    bvec.pb(pii(s[0],1));
    repp(i,1,n)
    {
        if(s[i]==s[i-1])
            bvec.back().second++;
        else
            bvec.pb(pii(s[i],1));
    }
    siz=bvec.size();
    
    getNext();
    
    bool flag=false;
    while(m--)
    {
        char c; int t;
        cin>>c>>t;
        
        if(flag||t==0)
            continue;
        
        if(c=='-')
        {
            while(!svec.empty()&&t>0)
            {
                if(svec.back().second<=t)
                {
                    t-=svec.back().second;
                    svec.pop_back();
                }
                else
                {
                    svec.back().second-=t;
                    break;
                }
            }
        }
        else
        {
            if(!svec.empty()&&svec.back().first==c)
                svec.back().second+=t;
            else
                svec.pb(pii(c,t));
        }
        
        int len=svec.size();
        match[len]=0; // 重新判断 len 位置的匹配状态
        if(len==0)
            continue;
        else
        {
            match[len]=match[len-1];
            while(match[len]>0&&svec.back()!=bvec[match[len]])
                match[len]=Next[match[len]]+1;
            if(match[len]==0&&svec.back().first==bvec[match[len]].first&&svec.back().second>=bvec[match[len]].second
                ||match[len]>0&&svec.back()==bvec[match[len]])
                match[len]++;
        }
        
        if(match[len]==siz
            ||match[len-1]==siz-1
            &&svec.back().first==bvec.back().first
            &&svec.back().second>=bvec.back().second)
            flag=true;
    }
    cout<<(flag?"yes":"no")<<'\n';
}
signed main()
{
    closeSync;
    multiCase
    {
        solve();
    }
    return 0;
}