acwing1222. 密码脱落

题目链接

acwing1222. 密码脱落

可以使用区间 DP 来解决这个问题。

定义状态

我们可以使用 $f(i,j)$ 表示区间 $[i,j]$ 内删除的字符个数，使得该区间成为镜像字符串。

转移方程

如果 $s_i=s_j$，那么 $f(i,j)=f(i+1,j-1)$。

如果 $s_i\ne s_j$，那么我们可以删除 $s_i$ 或者 $s_j$，然后递归处理剩下的区间。因此，我们有
$$f(i,j)=\min f(i+1,j),f(i,j-1)+1$$

边界条件

当 $i=j$ 时，$f(i,j)=0$。

答案

答案即为 $f(0,n-1)$，其中 $n$ 是字符串的长度。

C++ 代码实现

以下是使用区间 DP 来解决该问题的 C++ 代码实现：

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    string s;
    cin >> s;

    int n = s.size();
    vector<vector<int>> f(n, vector<int>(n, 0));
    for (int len = 2; len <= n; len++) {
        for (int i = 0, j = i+len-1; j < n; i++, j++) {
            if (s[i] == s[j]) {
                f[i][j] = f[i+1][j-1];
            } else {
                f[i][j] = min(f[i+1][j], f[i][j-1]) + 1;
            }
        }
    }

    cout << f[0][n-1] << endl;

    return 0;
}

这个算法的正确性如何证明？

我们可以使用数学归纳法来证明该算法的正确性。

首先，当区间长度为 1 时，即 $i=j$，此时 $f(i,j)=0$，显然满足条件。

然后，我们假设对于任意的区间长度 $len\le k$，算法都能够正确计算出对应的删除字符个数。我们需要证明当区间长度为 $len=k+1$ 时，算法也能够正确计算出对应的删除字符个数。

对于区间 $[i,j]$，如果 $s_i=s_j$，那么我们可以将 $s_i$ 和 $s_j$ 分别看成字符串的开头和结尾，然后递归计算 $f(i+1,j-1)$ 即可。由于 $f(i+1,j-1)$ 也是一个区间的解，根据归纳假设，我们可以认为 $f(i+1,j-1)$ 已经计算正确。因此，当 $s_i=s_j$ 时，$f(i,j)$ 肯定能够被正确计算出。

如果 $s_i\ne s_j$，那么我们可以删除 $s_i$ 或者 $s_j$，然后递归处理剩下的区间。由于 $s_i$ 和 $s_j$ 是两个不同的字符，因此我们可以将 $s_i$ 和 $s_j$ 分别看成字符串的开头和结尾，然后递归计算 $f(i+1,j)$ 和 $f(i,j-1)$。由于 $f(i+1,j)$ 和 $f(i,j-1)$ 都是区间的解，根据归纳假设，我们可以认为它们已经被正确计算出。因此，当 $s_i\ne s_j$ 时，$f(i,j)$ 肯定能够被正确计算出。

综上所述，使用数学归纳法可以证明该算法的正确性。

具体讲讲$f[i][j]=min(f[i+1][j],f[i][j-1])+1$;

对于状态 $f(i,j)$，如果 $s_i=s_j$，那么 $f(i,j)$ 的值与 $f(i+1,j-1)$ 的值相同。因此，我们只需要考虑 $s_i\ne s_j$ 的情况。

由于 $s_i\ne s_j$，我们只能删除 $s_i$ 或者 $s_j$ 中的一个字符，然后递归计算 $f(i+1,j)$ 或者 $f(i,j-1)$。那么，我们需要选择删除哪一个字符呢？

我们可以考虑两种情况：

如果删除 $s_i$，那么 $s_{i+1}$ 和 $s_j$ 可能成为镜像字符串的开头和结尾，因此我们需要计算 $f(i+1,j)$。
如果删除 $s_j$，那么 $s_i$ 和 $s_{j-1}$ 可能成为镜像字符串的开头和结尾，因此我们需要计算 $f(i,j-1)$。
由于我们希望计算出的是最少的删除字符个数，因此我们需要取上述两种情况的最小值，即 $f(i,j)=\min f(i+1,j),f(i,j-1)+1$。

该转移方程的含义是，我们选择删除 $s_i$ 或者 $s_j$ 中的一个字符，然后递归计算剩下的区间的删除字符个数，再加上删除的这个字符。我们需要选择删除字符个数最少的那种情况。

因此，状态转移方程 $f(i,j)=\min f(i+1,j),f(i,j-1)+1$ 是合理的。

---

len为啥要从2开始

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    string s;
    cin >> s;

    int n = s.size();
    vector<vector<int>> f(n, vector<int>(n, 0));
    for (int len = 2; len <= n; len++)
    {
        for (int i = 0, j = i + len - 1; j < n; i++, j++)
        {
            if (s[i] == s[j])
            {
                f[i][j] = f[i + 1][j - 1];//j>=1 -> i+len-1>=1,i>=0 ->  len-1>=1 -> len>=2  
            }
            else
            {
                f[i][j] = min(f[i + 1][j], f[i][j - 1]) + 1;
            }
        }
    }

    cout << f[0][n - 1] << endl;

    return 0;
}

该算法的时间复杂度为 $O(n^2)$，其中 $n$ 是字符串的长度。由于第一个 for 循环的循环次数为 $n-1$，第二个 for 循环的循环次数为 $n-len+1$，因此总的循环次数为：

$$\sum _{len=2}^n(n-len+1)=\frac{n(n-1)}{2}$$

因此，该算法的时间复杂度为 $O(n^2)$。