限制公共子序列计数 [动态规划]

$限制公共子序列计数$

---

$color{red}{正解部分}$

设 $F[i, j]$ 表示 $S$ 序列前 $i$ 项, $T$ 序列前 $j$ 项, $i$ 与 $j$ 共同作为 公共子序列 末尾的方案数,
首先有一个很显然的状态转移方程,

$F[i, j] = [S_i==T_j] imes left(sumlimits_{k=0}^{i-1}sumlimits_{p=0}^{j-1} F[k, p] ight)$ ,时间复杂度 $O(N^4)$,

对于这种 $S_i = T_j$ 时才生效的状态, 可以在 $S_i ot = T_j$ 时, 直接继承, 所以不妨直接省掉一维,

先 从小到大 枚举 $i$, 设 $F[j]$ 表示以 $T_j, S_i$ 这个 值 结尾, 与 $S$ 前 $i$ 项构成 公共子序列 的方案数量,

有 $F[j] = sum_{k=0}^{j-1} F[k]$, 意为 以 $T_k$ 这个 值 为末尾 转移到 以 $(T_j=S_i)$ 这个 值 为末尾,

• 可以发现 $S_i$ 在枚举 $j$ 时是不变的, 因此可以方便的维护限制条件,
• 随着 $j$ 从小到大 枚举, 在枚举时不断使用当前 $F[j]$ 完善决策集合即可实现后面 $O(1)$ 转移 .

时间复杂度 $O(N^2)$ .

---

$color{red}{实现部分}$

#include<bits/stdc++.h>
#define reg register

int read(){
        char c;
        int s = 0, flag = 1;
        while((c=getchar()) && !isdigit(c))
                if(c == '-'){ flag = -1, c = getchar(); break ; }
        while(isdigit(c)) s = s*10 + c-'0', c = getchar();
        return s * flag;
}

const int maxn = 3005;
const int mod = 1e9 + 7;

int N;
int M;
int K;
int Len;
int Ans;
int num0;
int S[maxn];
int T[maxn];
int B[maxn<<1];
int F[maxn<<1];

bool is[maxn<<1][maxn<<1];

int main(){
        N = read(), M = read(), K = read();
        for(reg int i = 1; i <= N; i ++) B[++ Len] = S[i] = read();
        for(reg int i = 1; i <= M; i ++) B[++ Len] = T[i] = read();
        std::sort(B+1, B+Len+1);
        Len = std::unique(B+1, B+Len+1) - B-1;
        for(reg int i = 1; i <= N; i ++) S[i] = std::lower_bound(B+1, B+Len+1, S[i])-B;
        for(reg int i = 1; i <= M; i ++) T[i] = std::lower_bound(B+1, B+Len+1, T[i])-B;
        for(reg int i = 1; i <= K; i ++){
                int s = read(), t = read();
                int p = std::lower_bound(B+1, B+Len+1, s)-B;
                if(p == Len+1 || B[p] != s) continue ; s = p;
                p = std::lower_bound(B+1, B+Len+1, t)-B;
                if(p == Len+1 || B[p] != t) continue ; t = p;
                if(is[s][t]) continue ; is[s][t] = 1;
        }
        for(reg int i = 1; i <= N; i ++)
                for(reg int j = 1, s = 1; j <= M; j ++){
                        int ts = s;
                        if(is[T[j]][S[i]]) s = (s + F[j]) % mod; // 可以转移到后面.
                        if(S[i] != T[j]) continue ;
                        Ans = (Ans + ts) % mod; F[j] = (F[j] + ts) % mod;
                }
        printf("%d
", Ans);
        return 0;
}