记忆化搜索

P1288 - [蓝桥杯2016初赛]密码脱落 - New Online Judge (ecustacm.cn)

方法一：DP（线性DP）(（最长公共子序列模型）

求S和reverse(S)的最长公共子序列，用len(S)-最长公共子序列，就是需要增加的种子（即之前掉落种子)才能构成回文串

代码简单但不好想到这方面

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

string s, t;
int f[N][N];

int main()
{
    while(cin >> s)
    {
        memset(f, 0, sizeof f);
        t = s;
        reverse(t.begin(), t.end());
        s = "*" + s;
        t = "*" + t;
        int len = s.length();
        for(int i = 1; i < len; i ++ )
        {
            for(int j = 1; j < len; j ++ )
            {
                f[i][j] = max(f[i - 1][j], f[i][j - 1]);
                if(s[i] == t[j])    f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
            }
        }
        cout << len - 1 - f[len - 1][len - 1] << endl;
    }
    
    return 0;
}

方法二：DP（区间DP）

状态表示：F[L][R]

含义：在区间[L,R]内需要补F[L][R]个种子才能构成回文串
最小值MIN

状态分析：

s[L] == S[R]：左右端点的值相等，那么答案就是里面一层的种子数F[L+1][R-1]
s[L] != S[R]：左右端点的值不相等，说明需要加一个种子

加在左边，与右端点配对，那么里面一层就是dp[l][r] = dp[l+1][r-1];
加在右边，与左端点配对，那么里面一层就是dp[l][r] = min(dp[l+1][r] + 1, dp[l][r-1] + 1);

PS：

若使用dp来写，可以看出转移方程是自上而下递推而来的（L->L+1），所以区间起始点l需要从大到小枚举，并且在第一种情况需要加一个特判，因为l + 1可能 > r - 1，此时dp[l][r]应该为0

区间DP一般套路：区间总长度为n

枚举区间长度len
枚举左端点L = [0, n-len+1]
根据左端点求右端点R = L+len-1
状态转移

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N = 1005;
char str[N];
int dp[N][N];

int main()
{
    while(cin >> str + 1)
    {
        memset(dp, 0x3f, sizeof dp);
        int n = strlen(str + 1);
        for(int i = 0; i <= n; i ++ )   dp[i][i] = 0;
        for(int len = 2; len <= n; len ++)//枚举长度
        {
            for(int l = n - len + 1; l >= 1; l -- )//降序枚举左端点
            {
                int r = l + len - 1;//右端点
                if(str[l] == str[r])//左右端点相等，收缩区间
                {
                    if(l + 1 <= r - 1)
                        dp[l][r] = dp[l + 1][r - 1];
                    else//当区间长度为2时，不能收缩区间了，区间长度最小为2
                        dp[l][r] = 0;//只有两个种子且相等，dp[l][r]=0
                }
                else//不相等,脱落的种子数加一(用于修改端点)
                //因为脱落种子有两种可能,一种是左边，一种是右边
                //dp[l+1][r]相当于右边的种子脱落了
                //dp[l][r-1]相当于左边的种子脱落了
                    dp[l][r] = min(dp[l+1][r] + 1, dp[l][r-1] + 1);
            }
        }
        cout << dp[1][n] << endl;
    }

    return 0;
}

方法三：记忆化搜索

有点像归并排序

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

char str[N];
int dp[N][N];

int dfs(int l, int r)
{
    //需要先判断一下边界
    if(l >= r)  return dp[l][r] = 0;
    //return dp[l][r] = 0 <==> return 0 && dp[l][r] = 0
    
    if(dp[l][r] != 0x3f3f3f3f)  return dp[l][r];
    
    if(str[l] == str[r])    dp[l][r] = dfs(l + 1, r - 1);
    else    dp[l][r] = min(dfs(l, r - 1), dfs(l + 1, r)) + 1;
    return dp[l][r];
}

int main()
{
    while(cin >> str + 1)
    {
        memset(dp, 0x3f, sizeof dp);
        int n = strlen(str + 1);
        int res = dfs(1, n);
        cout << res << endl;
    }
    
    return 0;
}