uva 11584 Partitioning by Palindromes dp

Problem H: Partitioning by Palindromes

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 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.

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

给出n和n个字符串

求每个字符串最少由几个回文字符串组成

dp1：

#include<stdio.h>
#include<string.h>
int dp[1100];
int huiwen(char *str,int s,int t)
{
    if(str[s]!=str[t])
        return 0;
    else
    {
        int i;
        int flag=1;
        int a=(t-s)/2+1;
        for(i=0;i<a;i++)
        {
            if(str[s+i]!=str[t-i])
            {
                flag=0;
                break;
            }
        }
        return flag;
    }
}
int min(int a,int b)
{
    return a<b?a:b;
}
int main()
{
    int n;
    int i,j;
    char str[1100];
    while(scanf("%d",&n)!=EOF)
    {
        while(n--)
        {
            scanf("%s",str);
            dp[0]=0;
            int l=strlen(str);
            for(i=1;i<=l;i++)
            {
                dp[i]=1100;
            }
            for(i=1;i<=l;i++)
            {
                dp[i]=min(i,dp[i]);
                for(j=i;j<=l;j++)
                {
                    if(huiwen(str,i-1,j-1))
                    {
                            dp[j]=min(dp[j],dp[i-1]+1);
                    }

                }
            }
            printf("%d\n",dp[l]);
        }
    }
    return 0;
}

dp2：

#include<stdio.h>
#include<string.h>
int dp[1100];
int huiwen(char *str,int s,int t)
{
    if(str[s]!=str[t])
        return 0;
    else
    {
        int i;
        int flag=1;
        int a=(t-s)/2+1;
        for(i=0;i<a;i++)
        {
            if(str[s+i]!=str[t-i])
            {
                flag=0;
                break;
            }
        }
        return flag;
    }
}
int min(int a,int b)
{
    return a<b?a:b;
}
int main()
{
    int n;
    int i,j;
    char str[1100];
    while(scanf("%d",&n)!=EOF)
    {
        while(n--)
        {
            memset(dp,0,sizeof(dp));
            scanf("%s",str);
            int l=strlen(str);
            for(i=0;i<l;i++)
            {
                dp[i]=i+1;
                for(j=0;j<=i;j++)
                {
                    if(huiwen(str,j,i))
                    {
                        dp[i]=min(dp[i],dp[j-1]+1);
                    }
                }
            }
            printf("%d\n",dp[l-1]);
        }
    }
    return 0;
}