codeforces 1063D Mysterious Code AC自动机+dp

点我看题

题意：
给出字符串A，B，C。
A中有‘ * ’可以替换成任意小写字母。
要求你找出一种替换，是的替换后的A中B出现的次数与C出现的次数差值最大。

解题思路：
靠直觉觉得需要用DP，这种字符串中找子串匹配的题型很像是ac自动机上跑DP。
思考如何把这两个东西套在一起。
考虑A和B的长度均小于50 所以自动机上的状态节点很少，考虑以这个作为一维状态DP。
设dp[i][j] 表示 匹配到A的第i位，目前状态为自动机上的j状态的差值最大值。
状态转移也很简单
dp[i][a]=max(dp[i-1][b]+val[a]) b为所有可以直接转移到a的状态。val 为节点权值。
考虑val 该如何求解。 有如下思路：

1. ac.insert( B ) 时 叶子节点直接赋值为1
2. ac.insert( C )时 叶子结点赋值为-1
3. 但这样构建的val是不全的，有遗漏。因为B（C）中可能有C（B）的子串。 这个时候，fail链就能解决这个问题。
   在构建fail数组的时候顺带处理一下就可以了。如果这里不懂，可以去复习一下fail数组的含义。
   然后这道题就写完了。
   复杂度是O（26*（|A|）*（|C|+|B|）） 完全可以接受

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <iostream>
#define lson id<<1,l,mid
#define rson id<<1|1,mid+1,r
#define lowbit(x) x&-x
#define mp make_pair
#define pb push_back
using namespace std;
typedef long long ll;
typedef long long LL;
const int SIGMA_SIZE = 30;
const int MAXNODE =5e4;
const int MAXS = 1005;
struct ACautomata {

    int ch[MAXNODE][SIGMA_SIZE];
    int f[MAXNODE];    // fail函数
    int val[MAXNODE];  // 每个字符串的结尾结点都有一个非0的val
    int last[MAXNODE]; // 输出链表的下一个结点
    int sz;
    //int d[MAXNODE];
    void init() {
        sz = 1;
        memset (ch[0], 0, sizeof (ch[0]) );
        //memset(d, 0, sizeof(d));
    }
    // 字符c的编号
    inline int idx (char c) {
        return c-'a';
    }
    // 插入字符串。v必须非0
    void insert (char *s,int ids) {
        int u = 0, n = strlen (s);
        for (int i = 0; i < n; i++) {
            int c = idx (s[i]);
            //printf("%c", s[i]);
            if (!ch[u][c]) {
                memset (ch[sz], 0, sizeof (ch[sz]) );
                val[sz] = 0;
                ch[u][c] = sz++;
            }
            u = ch[u][c];
        }
        val[u] +=ids;
    }

    // 递归打印匹配文本串str[i]结尾的后缀,以结点j结尾的所有字符串
    void print (int i, int j) {
        if (j) {
            print (i, last[j]);
        }
    }
    // 计算fail函数
    void getFail() {
        queue<int> q;
        f[0] = 0;
        // 初始化队列
        for (int c = 0; c < SIGMA_SIZE; c++) {
            int u = ch[0][c];
            if (u) {
                f[u] = 0;
                q.push (u);
                last[u] = 0;
            }
        }
        // 按BFS顺序计算fail
        while (!q.empty() ) {
            int r = q.front();
            q.pop();
            for (int c = 0; c < SIGMA_SIZE; c++) {
                int u = ch[r][c];
                if (!u) {
                    ch[r][c] = ch[f[r]][c];
                    continue;
                }
                q.push (u);
                int v = f[r];
                while (v && !ch[v][c]) v = f[v];
                f[u] = ch[v][c];
                last[u] = val[f[u]] ? f[u] : last[f[u]];
            }
            val[r]+=val[f[r]];
        }
    }
} ac;
char str1[1005],str2[100],str3[100];
int dp[1005][105];
int main() {
    scanf("%s %s %s",str1,str2,str3);
    ac.init();
    ac.insert(str2,1);
    ac.insert(str3,-1);
    ac.getFail();
    int len = strlen(str1);
    memset(dp,128,sizeof dp);
    dp[0][0]=0;
    int ans = -1e9;
    for(int i=0;i<len;i++){
        for(int j=0;j<ac.sz;j++){
            if(str1[i]=='*'){
                for(int k=0;k<26;k++){
                    int id = ac.ch[j][k];
                    dp[i+1][id]=max(dp[i+1][id],dp[i][j]+ac.val[id]);
                    //printf("dp[%d][%d]=%d\n",i+1,id,dp[i+1][id]);
                }
            }else{
                int id = ac.ch[j][str1[i]-'a'];
                dp[i+1][id]=max(dp[i+1][id],dp[i][j]+ac.val[id]);
            }
        }
    }
    for(int i=0;i<ac.sz;i++){
        ans=max(ans,dp[len][i]);
    }
    cout<<ans<<endl;
    return 0;
}