UVa11584 - Partitioning by Palindromes(动态规划)

We say a sequence of characters is a palindrome if it is the same writtenforwards and backwards. For example, 'racecar' is a palindrome, but 'fastcar' is not.

A partition of a sequence of characters is a list ofone 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 thesecharacters such that each group in the partition is a palindrome! Given this observation it is natural to ask: what is the minimum number of groupsneeded 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 ofbetween 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(i)表示 到第i个字符时最小的回文数，状态转移方程为：

dp(i) = min{dp(j - 1) + 1} 1 <= j <= i ,如果(j,i)之间的字符是回文字符串

import java.io.FileInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.io.PrintWriter;
import java.io.OutputStreamWriter;

public class Main implements Runnable{
	private static final boolean DEBUG = false;
	private static final int N = 1005;
	private BufferedReader cin;
	private PrintWriter cout;
	private StreamTokenizer tokenizer;
	private String s;
	private int[] dp;
	
	private void init() 
	{
		try {
			if (DEBUG) {
				cin = new BufferedReader(new InputStreamReader(
						new FileInputStream("e:\\uva_in.txt")));
			} else {
				cin = new BufferedReader(new InputStreamReader(System.in));
			}

			tokenizer = new StreamTokenizer(cin);
			cout = new PrintWriter(new OutputStreamWriter(System.out));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private String next() 
	{
		try {
			 tokenizer.nextToken(); 
			 if (tokenizer.ttype == StreamTokenizer.TT_EOF) return null; 
			 else if (tokenizer.ttype == StreamTokenizer.TT_NUMBER) { 
			 	return String.valueOf((int)tokenizer.nval); 
			} else return tokenizer.sval;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	private boolean input() 
	{
		s = next();
		return true;
	}

	private boolean isPalindrom(int start, int end)
	{
		while (start <= end) {
			if (s.charAt(start) != s.charAt(end)) return false;
			start++;
			end--;
		}

		return true;
	}
	
	
	
	private void solve() 
	{
		int len = s.length(), i, j;
		dp = new int[len + 1];
		dp[0] = 0;
		for (i = 1; i <= len; i++) {
			for (dp[i] = N, j = 1; j <= i; j++) {
				if (isPalindrom(j - 1, i - 1)) {
					dp[i] = Math.min(dp[i], dp[j - 1] + 1);
				}
			}
		}

		cout.println(dp[len]);
		cout.flush();
	}

	public void run()
	{
		init();

		int n = Integer.parseInt(next());
		while (n-- > 0) {
			input();
			solve();
		}
	}
	
	public static void main(String[] args) 
	{
		new Thread(new Main()).start();
	}
}