Pieces HDU - 4628(状压 DP + 回文序列预处理)

题目链接

题意

1. 给我们一个长度小于等于 16 的字符串 S，每次操作我们可以删除 S 中的一个回文子序列，问最少需要多少次操作可以将完全 S 删除。

思路

1. 数据范围比较少，可以考虑状压 dp。
2. 接着怎么考虑状压？其实我们可以确定，这题可能有一个或者多个最有删除顺序， 对于某个最优的删除顺序，如下图：
   
3. 我们可以从上图可以看出，一个大集合的最有拆分操作次数答案，我们不知道，但是我们可以通过去把这个大集合暴力枚举拆分成两个小集合，通过两个小的集合的最优解，拼凑出我们的答案的最优解，
4. 对于差分出的小集合，我们同样把小集合拆分成更小的两个集合，去求解最优值，
5. 对于集合拆分我们可以用下面的代码：
6. 对于状态状态转移方程：dp [i] 表示二进制状态集合为 i 的时候的最小删除次数，
7. 状态转移方程为：

代码

#include <bits/stdc++.h>
using namespace std;
#define db  double
#define ll  long long
#define sc  scanf
#define pr  printf
#define fi  first
#define se  second
#define pb  push_back
#define m_p make_pair
#define Pir pair<int, int>
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
/*==========ACMer===========*/
const int N = 16;
char s[N];
int n, dp[1 << N];

void init()
{
    int a[N], p;
    for (int i = 1; i < (1 << n); i ++)
    {
        p = 0;
        for (int j = 0; j < n; j ++)
        {
            if (i & (1 << j))
            {
                a[++ p] = j;
            }
        }
        
        dp[i] = 1;
        for (int l = 1, r = p; l < r; l ++, r --)
        {
            if (s[a[l]] != s[a[r]])
            {
                dp[i] = inf;
                break;
            }
        }
    }
}

int main()
{
    int T; sc("%d", &T);
    while (T --)
    {
        sc("%s", s);
        n = strlen(s);
        init();                 //预处理某个状态是不是回文串, 并初始化 dp 数组
        int S = (1 << n) - 1;
        for (int i = 1; i <= S; i ++)
        {
            for (int j = i; j; j = i & (j - 1))     //暴力枚举 i 集合的子集j，k 为 i 与 j 的补集
            {
                int k = i ^ j;
                dp[i] = min(dp[i], dp[j] + dp[k]);
            }
        }

        pr("%d\n", dp[S]);
    }

    return 0;
}