Pieces HDU - 4628

You heart broke into pieces.My string broke into pieces.But you will recover one day,and my string will never go back. 
Given a string s.We can erase a subsequence of it if this subsequence is palindrome in one step. We should take as few steps as possible to erase the whole sequence.How many steps do we need? 
For example, we can erase abcba from axbyczbea and get xyze in one step.

Input

The first line contains integer T,denote the number of the test cases. Then T lines follows,each line contains the string s (1<= length of s <= 16). 
T<=10.

Output

For each test cases,print the answer in a line.

Sample Input

2
aa
abb

Sample Output

1
2

题意:

给一个字符串，每次可以删除一个回文子序列（顺序一定，但不一定是连续的），问最少可以删多少次可以将字符串删完。

思路：状态压缩dp之子集枚举

与一般的状态压缩dp不同（每次可以改变一个位置的状态），对于每一个子集，可以改变多个状态。

即每一个状态，是由多个状态转移过来的。

状态表示：dp[mask]表示状态为mask的最小值

状态转移：dp[mask]=min{dp[mask-sub]+1};  其中，sub是mask的子集，sub也可以等于mask.

 

暴力解决，时间复杂度：2^n * 2^n，时间超限

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

int t,n,dp[1<<20],a[1<<20],b[20];
const int INF=100;

string  s;

bool judge(int mask){//判断mask状态是否为回文
    int len=0;
    for(int i=0; i<n; i++){
       if(mask&(1<<i)){
          b[++len]=n-1-i;
       }
    }
    for(int i=1; i<=len/2; i++){
        if(s[b[i]]!=s[b[len+1-i]])
            return false;
    }
    return true;

}
int main()
{
    cin>>t;
    while(t--){
      cin>>s;
      n=s.size();
      for(int i=0; i<(1<<n); i++){
          a[i]=judge(i);
          dp[i]=INF;
      }
      dp[0]=0;
      for(int mask=1;mask<(1<<n); mask++){
         for(int sub=0;sub<=mask; sub++){
            if(mask&sub==sub&&a[sub]==1){//假如sub是回文串并且sub是mask的子集
                dp[mask]=min(dp[mask-sub]+1,dp[mask]);
            }
         }
      }
      cout<<dp[(1<<n)-1]<<endl;
    }
    return 0;
}
//时间复杂度：2^n * 2^n，时间超限

事实上，可以再进行优化，只需要对以下代码进行优化。

 for(int sub=0;sub<=mask; sub++)

改成

 for(int sub=mask;sub>0; sub=mask&(sub-1))

这句代码可以将子集精确定位它的子集，啥意思呢，比如mask=10101，那么只要比10101小的就是它的子集，但是比如10011，也比mask小，mask的位置1是0，

而10011位置1处变成了1，sub虽是mask子集但是不符合条件。

因此，可以去掉这些不符合条件的子集，将sub-1后与原来的mask做与操作，就可以精确得到符合条件的子集。

完整代码如下：

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

int t,n,dp[1<<20],a[1<<20],b[20];
const int INF=100;

string  s;

bool judge(int mask){//判断mask状态是否为回文
    int len=0;
    for(int i=0; i<n; i++){
       if(mask&(1<<i)){
          b[++len]=n-1-i;
       }
    }
    for(int i=1; i<=len/2; i++){
        if(s[b[i]]!=s[b[len+1-i]])
            return false;
    }
    return true;

}
int main()
{
    cin>>t;
    while(t--){
      cin>>s;
      n=s.size();
      memset(a,0,sizeof(a));
      for(int i=0; i<(1<<n); i++){
          a[i]=judge(i);
          dp[i]=INF;
      }
      dp[0]=0;
      for(int mask=1;mask<(1<<n); mask++){
         for(int sub=mask;sub>0; sub=mask&(sub-1)){//只修改了这里
            if(a[sub]==1){
                dp[mask]=min(dp[mask-sub]+1,dp[mask]);
            }
         }
      }
      cout<<dp[(1<<n)-1]<<endl;
    }
    return 0;
}

那么现在的时间复杂度为多少呢？

对于每一个位置，

若为1，则子集可以为0/1,两种情况； 

若为0，那么子集只能为0

所以每一个位置有3种情况，时间复杂度为O(3^N).