UVa 11583 Partitioning by Palindromes



Description

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

题意：求出字符串的最小回文串个数。

思路：dp求回文串，最后求最小个数。

AC代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.*;
public class Main{

	public static void main(String[] args) throws IOException {
		//Scanner scan=new Scanner(System.in);
		StreamTokenizer st = new StreamTokenizer(new BufferedReader(
				new InputStreamReader(System.in)));
		st.nextToken();
		int n=(int)st.nval;
		//scan.nextLine();
		for(int i=0;i<n;i++){
			st.nextToken();
			String s=(String)st.sval;
			int len=s.length();
			char a[]=new char[len];
			a=s.toCharArray();
			int dp[][]=new int[1010][1010];
			for(int j=0;j<len;j++){
				dp[j][j]=1;
				dp[j+1][j]=1;
			}
			for(int j=len-1;j>=0;j--){
				for(int k=j+1;k<len;k++){
					dp[j][k]=Math.min(dp[j+1][k]+1, dp[j][k-1]+1);
					if(a[j]==a[k]&&dp[j+1][k-1]==1){
						dp[j][k]=Math.min(dp[j][k], 1);
					}
				}
			}
			for(int j=0;j<len;j++){
				for(int k=0;k<j;k++){
					dp[0][j]=Math.min(dp[0][j], dp[0][k]+dp[k+1][j]);
				}
			}
			System.out.println(dp[0][len-1]);
		}
	}

}

UVa 11583 Partitioning by Palindromes,布布扣,bubuko.com