Codeforces 1050D Three Religions (dp+序列自动机)

题意：

给一个1e5的串str，然后有三个起始空串，不超过1000次操作，对三个字符串的一个尾部加一个字符或者减一个字符，保证每个字符不会超过250

每次操作之后询问你这三个串是不是可以组成str的子序列，

比如ab,cd,ef可以组成acgbdef的子序列

思路：

dp[i][j][k]为三个串分别匹配到i,j,k的时候组成的子序列的最后一个字符在str中的位置，如果dp[strlen(str1)][strlen(str2)][strlen(str3)]>n则输出no

对每一次询问我们可以处理出dp[i][j][k]，

用序列自动机加速，nx[i][j]表示str中i位置的下一个字符j出现在什么位置(不包括i)，没出现则为n+1

则状态转移方程

if(i)dp[i][j][k] = min(dp[i][j][k],nx[dp[i-1][j][k]][v[1][i-1]-'a']);
if(j)dp[i][j][k] = min(dp[i][j][k],nx[dp[i][j-1][k]][v[2][j-1]-'a']);
if(k)dp[i][j][k] = min(dp[i][j][k],nx[dp[i][j][k-1]][v[3][k-1]-'a']);

注意序列自动机要同样处理处nx[0][j]和nx[n+1][j]，因为状态转移方程中可能会出现

复杂度O(250^3)

但这一题有q次询问，而且三个串在不停改变，我们不能每次都250^3处理，

当操作为“+”的时候，如果添加的是str1，若str1的长度由m变为m+1，可以发现，dp方程改变的只有dp[m+1][j][k]，而其他的都没有改变（因为只是在尾部操作）

所以我们对每一次询问可以O(250^2)更新dp数组

而当操作为"-"的时候，我们并不需要更新dp数组，因为我们只能用到dp[m-1][j][k]，而这之前已经处理好了，我们下一次“+”的时候，自然会覆盖dp[m][j][k]

所以总的复杂度为$O(26n+250^2q)$

代码：

题解的写法学会了✔

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<stack>
#include<queue>
#include<deque>
#include<set>
#include<vector>
#include<map>
#include<functional>

#define fst first
#define sc second
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define lc root<<1
#define rc root<<1|1
#define lowbit(x) ((x)&(-x)) 

using namespace std;

typedef double db;
typedef long double ldb;
typedef long long ll;
typedef long long LL;
typedef unsigned long long ull;
typedef pair<int,int> PI;
typedef pair<ll,ll> PLL;

const db eps = 1e-;
const int mod = 1e9+;
const int maxn = 1e6+;
const int maxm = 2e6+;
const int inf = 0x3f3f3f3f;
const db pi = acos(-1.0);

int n, q;
int dp[][][];
vector<char>v[];
int nx[maxn][];
char str[maxn];
void init(){
    for(int i = ; i < ; i++){
        nx[n][i] = n+;
        nx[n+][i]=n+;
    }
    for(int i = n-; i >= ; i--){
        for(int j = ; j < ; j++){
            if(str[i+]-'a'==j){
                nx[i][j] = i+;
            }
            else nx[i][j] = nx[i+][j];
        }
    }
}int mi[],mx[];
int main(){
    scanf("%d %d" ,&n, &q);
    scanf("%s",str+);
    init();
    while(q--){
        char op[];
        scanf("%s",op+);
        int x;
        scanf("%d",&x);
        if(op[]=='+'){
            char gao[];
            scanf("%s",gao+);
            char c = gao[];
            v[x].pb(c);

            for(int i = ; i <= ; i++){
                mi[i] = ;
                mx[i] = v[i].size();
            }
            mi[x] = mx[x];
            for(int i = mi[]; i <= mx[]; i++){
                for(int j = mi[]; j <= mx[]; j++){
                    for(int k = mi[]; k <= mx[]; k++){
                        if(i+j+k==)continue;
                        dp[i][j][k] = n+;
                        if(i)dp[i][j][k] = min(dp[i][j][k],nx[dp[i-][j][k]][v[][i-]-'a']);
                        if(j)dp[i][j][k] = min(dp[i][j][k],nx[dp[i][j-][k]][v[][j-]-'a']);
                        if(k)dp[i][j][k] = min(dp[i][j][k],nx[dp[i][j][k-]][v[][k-]-'a']);
                    }
                }
            }

        }
        else{

            v[x].pop_back();
        }
        if(dp[v[].size()][v[].size()][v[].size()]<=n){
            printf("YES\n");
        }
        else printf("NO\n");
    }
    return ;
}
/*
 */