lightoj 1044 - Palindrome Partitioning DP优化DP

给定一个串，问这个串可以最少拆分为几个回文子串。

一开始就想到了dp[i]代表i之前有多少个回文串，然后枚举j，区间[j,i]是否回文，如果是回文的话min(dp[i]=dp[j-1]+1,dp[i]).

但是n有1000，枚举i，j还要判断区间回文，复杂度n^3肯定要爆...

苦思冥想，其实预处理一下hw[i][j]判断i，j是否是个回文串。

之前做过回文串类的区间DP，一个两重循环就可以打表得出，复杂度n^2..

然后百度了其他人的做法，貌似最开始的思路可以过？..

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1005
int hw[N][N];
char s[N];
int dp[N];
int main()
{
    int t;
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++)
    {
        scanf("%s",s+1);
        int len=strlen(s+1);
        memset(hw,0,sizeof(hw));
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=len;i++)
        {
            for(int l=1;l+i-1<=len;l++)
            {
                int r=l+i-1;
                if(s[l]==s[r])
                    hw[l][r]=l+1>r-1?1:hw[l+1][r-1];
                else
                    hw[l][r]=0;
            }
        }
        for(int i=1;i<=len;i++)
        {
            dp[i]=dp[i-1]+1;
            for(int j=i-1;j>=1;j--)
            {
                if(hw[j][i])
                    dp[i]=min(dp[i],dp[j-1]+1);
            }
        }
        printf("Case %d: %d\n",cas,dp[len]);
    }
    return 0;
}