CF1363F_动态规划（最长公共子序列变种）

题目大意：

有两个长度为$n(\le 2000)$的字符串$s$，$t$，每次可以对s的一个子串$[l,r]$中的字符进行顺时针移动，即：$[s_l,s_{l+1},...,s_{r-1},s_r]\to [s_r,s_l,s_{l+1},...,s_{r-1}]$，最少进行多少次操作可以将字符串$s$变为$t$，如果不行，则输出$-1$

解题思路：

• 首先判断是否可行，可行的充要条件是：$s$和$t$中每种字符的个数都相同，因为每次对长度为2的子串进行操作，就相当于交换相邻的元素，那么这样一定可行

• 题目的顺时针移动，其实就相当于选择一个元素，往前面的任意位置插入

• 首先看个简单版本的问题：如果是选择一个元素往任意位置插入，最少操作次数是多少呢
  $$\begin{gathered} 答案是：长度-最长公共子序列 \\ 因为最长公共子序列不用动，只要把剩下的字符往对应位置插入即可 \end{gathered}$$

• 那么这题就可以用类似的想法来实现，因为只能往前面插入，所以当$s[i]=t[j]$时，还要判断$s[i+1,...,n]$中每种字符的个数都大于等于$t[j+1,...,n]$，才可以递推$dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1)$

$$\begin{gathered} 可以反证来证明：假设存在某种字符x小于的话 \\ 因为只能往前插字符，所以s[i+1,...,n]一定无法凑出足够个数的x，使得s[i+1,...,n]中x的个数等于t[j+1,...,n]中x的个数 \\ 那么这样的话就是不合法的情况，所以就不能进行递推 \end{gathered}$$

AC代码：

#include <bits/stdc++.h>
#define ft first
#define sd second
#define pb push_back
#define IOS ios::sync_with_stdio(false), cin.tie(0), cout.tie(0) //不能跟puts混用
#define seteps(N) fixed << setprecision(N)
#define endl "\n"
const int maxn = 2e3 + 10;
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
int _, n;
int dp[maxn][maxn], suf_s[maxn][26], suf_t[maxn][26];
char s[maxn], t[maxn];
void init() {
    for (int i = 1; i <= n; i++) 
        for (int j = 0; j < 26; j++)
            suf_s[i][j] = suf_t[i][j] = 0;
    for (int i = 1; i <= n; i++) dp[0][i] = dp[i][0] = 0;
}
int main() {
    IOS;
    cin >> _;
    while (_--) {
        cin >> n >> s + 1 >> t + 1;
        init();
        for (int i = n; i >= 1; i--)
            for (int j = 0; j < 26; j++)
                suf_s[i][j] = suf_s[i + 1][j] + (s[i] - 'a' == j);
        for (int i = n; i >= 1; i--)
            for (int j = 0; j < 26; j++)
                suf_t[i][j] = suf_t[i + 1][j] + (t[i] - 'a' == j);
        bool ok = true;
        for (int i = 0; i < 26; i++) if (suf_t[1][i] != suf_s[1][i]) ok = false;
        if (!ok) cout << -1 << endl;
        else {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                    if (s[i] == t[j]) {
                        bool ok = true;
                        for (int k = 0; k < 26; k++) if (suf_s[i][k] < suf_t[j][k]) ok = false;
                        if (ok) dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
                    }
                }
            }
            cout << n - dp[n][n] << endl;
        }
    }
    return 0;
}