uva 11584

题目：
We say a sequence of characters
is a palindrome if it
is the same written forwards
and backwards. For example,
‘racecar’ is a palindrome, but
‘fastcar’ is not.
A partition of a sequence of
characters is a list of one or
more disjoint non-empty groups
of consecutive characters whose
concatenation yields the initial
sequence. For example, (‘race’,
‘car’) is a partition of ‘racecar’
into two groups.
Given a sequence of characters,
we can always create a partition
of these characters such
that each group in the partition
is a palindrome! Given this observation
it is natural to ask:
what is the minimum number of
groups needed for a given string
such that every group is a palindrome?
For example:
• ‘racecar’ is already a
palindrome, therefore it
can be partitioned into
one group.
• ‘fastcar’ does not contain
any non-trivial palindromes,
so it must be partitioned
as (‘f’, ‘a’, ‘s’, ‘t’,
‘c’, ‘a’, ‘r’).
• ‘aaadbccb’ can be partitioned
as (‘aaa’, ‘d’, ‘bccb’).
Input
Input begins with the number n of test cases. Each test case consists of a single line of between 1 and
1000 lowercase letters, with no whitespace within.
Output
For each test case, output a line containing the minimum number of groups required to partition the
input into groups of palindromes.
Sample Input
3
racecar
fastcar
aaadbccb
Sample Output
1
7
3

ac代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
char s[1005];
int flag[1005][1005];
int dp[1005];
int judge(int i,int j);
int main()
{
    int cas;
    scanf("%d",&cas);
    getchar();
    while(cas--)
    {
        memset(s,'\0',sizeof(s));
        gets(s+1);                        //输入技巧 
        int len=strlen(s+1);              //注意是s+1而不是s！！！ 
        for(int i=1;i<=len;i++)
         for(int j=1;j<=len;j++)
         flag[i][j]=-1;
        for(int i=1;i<=len;i++)
        flag[i][i]=1;
        for(int i=0;i<=len;i++)
        dp[i]=i;
        for(int i=1;i<=len;i++)
         for(int j=0;j<i;j++)
         {
            if(judge(j+1,i))
            dp[i]=min(dp[i],dp[j]+1);
         }
        cout << dp[len] << endl;
    }
}
int judge(int i,int j)
{
    if(i>=j)
    return 1;
    if(s[i]!=s[j])
    return 0;
    if(flag[i+1][j-1]>=0)
    return flag[i+1][j-1];
    flag[i][j]=judge(i+1,j-1);
    return flag[i][j];
}

刘汝佳老师版：

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

const int maxn = 1000 + 5;
int n, kase, vis[maxn][maxn], p[maxn][maxn], d[maxn];
char s[maxn];

int is_palindrome(int i, int j)
{
  if(i >= j) return 1;
  if(s[i] != s[j]) return 0;

  if(vis[i][j] == kase) return p[i][j];
  vis[i][j] = kase;
  p[i][j] = is_palindrome(i+1, j-1);
  return p[i][j];
}

int main() 
{
  int T;
  scanf("%d", &T);
  memset(vis, 0, sizeof(vis));
  for(kase = 1; kase <= T; kase++) 
  {
    scanf("%s", s+1);
    n = strlen(s+1);
    d[0] = 0;
    for(int i = 1; i <= n; i++) 
    {
      d[i] = i+1;
      for(int j = 0; j < i; j++)
        if(is_palindrome(j+1, i)) d[i] = min(d[i], d[j] + 1);
    }
    printf("%d\n", d[n]);
  }
  return 0;
}