HDU 4628 Pieces（DP + 状态压缩）

Pieces

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4628

题目大意：给定一个字符串s，如果子序列中有回文，可以一步删除掉它，求把整个序列删除所需要的最少步数。比如： axbyczbea 可以一次删除掉 abcba 得到 xyze

Sample Input

2

aa

abb

 

Sample Output

1

2

分析：这道题目刚出来时居然有超过一半的人AC，是我太弱了吗？

　　到底不会，先贴出标程，再慢慢消化好了

　　

　　集合上的动态规划。。。和点集配对很像，这里我先求出所有的回文串，然后dp。

　　设d[S]表示将集合S中的字母删除需要多少步，结果就是d[(1<<n)-1]；

　　枚举所有的S，枚举所有S的子集sub；

　　状态转移方程：d[S] = min(d[S], d[S^sub)] + 1]（如果sub是回文串～这样才算能减一步呀）；

 

代码如下：

# include<cstdio>
# include<cstring>
# include<algorithm>

using namespace std;

const int maxn = 16 + 1;
const int INF = 0xffffff;
char s[maxn];
bool ispal[1<<maxn];    //ispal[i]表示状态i是否是回文，2进制时1表示选择这个字符，0表示不选择这个字符
int d[1<<maxn];        //d[S]表示将集合S中的字母删除需要多少步，结果就是d[(1<<n)-1]
int n;

void getPal()       //求出所有的回文串
{
    int S, i, j;
    for(S = 0; S < (1<<n); S++){    //状态S是否回文
        bool ok = 1;
        int m = 0, buf[maxn];    //临时存储提取出来的字符
        for(i = 0; i < n; i++) if((1<<i) & S){    //提取对应字符
            buf[m++] = s[i];
        }
        for(i = 0, j = m-1; i < j; i++, j--){ //判断回文
            if(buf[i] != buf[j]){
                ok = 0;
                break;
            }
        }
        ispal[S] = ok;
    }
}

void dp(){
    int S, sub;
    d[0] = 0;
    for(S = 1; S < (1<<n); S++){
        d[S] = INF;
        for(sub = S; sub > 0; sub = (sub-1) & S){    //sub = (sub-1) & S)保证是集合S中的字母
            if(ispal[sub]) d[S] = min(d[S], d[S^sub] + 1);    //S^sub就是剩下的字符
        }
    }
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%s", s);
        n = strlen(s);
        getPal();
        dp();
        printf("%d\n", d[(1<<n)-1]);
    }
    return 0;
}

 

附贴标程：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int min(int a,int b){
    return a<b ?a :b;
}

const int MAX_N = 16, INF = 0xffffff;
int n;
int dp[1 << MAX_N][MAX_N][MAX_N]; //rest,i,j
char s[MAX_N + 1];
void work() {
    int i,j,k;
    scanf("%s", s);
    n = strlen(s);

    for (i = 0; i < n; i++) {
        for (j = i; j < n; j++) {
            dp[0][i][j] = 0;
        }
    }

    for (int rest = 1; rest < (1 << n); rest++) {
        for (i = n - 1; i >= 0; i--) {
            for (j = i; j < n; j++) {
                //rest,i,j
                int &ret = dp[rest][i][j] = INF;
                if (i < j)
                    ret = min(dp[rest][i + 1][j], dp[rest][i][j - 1]);
                if (s[i] == s[j] && ((rest >> i) & 1) && ((rest >> j) & 1)) {
                    int nrest = rest & (~(1 << i)) & (~(1 << j));
                    if (nrest == 0)
                        ret = min(ret, dp[nrest][i][j] + 1);
                    else
                        ret = min(ret, dp[nrest][i][j]);
                }
            }
        }
        for (i = n - 1; i >= 0; i--) {
            for (int j = i; j < n; j++) {
                dp[rest][i][j] = min(dp[rest][i][j], dp[rest][0][n - 1] + 1);
            }
        }
    }

    cout << dp[(1 << n) - 1][0][n - 1] << endl;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        work();
    }
}