Folding UVA - 1630

动态规划，其实感觉有点像枚举，从串的末尾开始逐步推进到串的开头，每次判断将串分开结合得到的最小长度值以及是否能够将当前的整个串进行压缩得到更小的长度值的串，将当前得到的最小的串的值进行记录，作为下一次判断的依据，依次类推，直到得到最小长度的串即可，具体实现见如下代码：

package a;//实际提交的时候记得去掉包名

import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by wangshiyuan on 2017/10/11.
 */
public class Main {

    String s;
    String [][]dp=new String[100][100];
    int Inf=1<<20;

    public void Init(int length){
        for(int i=0;i<length;i++){
            for(int j=0;j<length;j++){
                dp[i][j]="";
                if(i==j) dp[i][j]+=s.charAt(i);
            }
        }
    }

    public int Combine(int i,int j){
        int len=j-i+1;
        for(int k=1;k<=len/2;k++){
            if(len%k==0){
                boolean exist=true;
                for(int ind=i;ind<=j-k;ind++){
                    if(s.charAt(ind)!=s.charAt(ind+k)){
                        exist=false;
                        break;
                    }
                }
                if(exist) return k;
            }
        }
        return 0;
    }

    public void Slove(){
        Scanner scan=new Scanner(System.in);
        while(scan.hasNextLine()){
            s=scan.nextLine();
            int length=s.length();
            Init(length);
            for(int i=length-2;i>=0;i--){
                for(int j=i+1;j<length;j++){
                    int ans=Inf;
                    int ind=-1;
                    for(int k=i;k<j;k++){
                        if(dp[i][k].length()+dp[k+1][j].length()<ans){
                            ans=dp[i][k].length()+dp[k+1][j].length();
                            ind=k;
                        }
                    }
                    dp[i][j]=dp[i][ind]+dp[ind+1][j];
                    int len=Combine(i,j);
                    if(len>0){
                        int L=j-i+1;
                        int amount=L/len;
                        String head=Integer.toString(amount);
                        String temp=head+"("+dp[i][i+len-1]+")";
                        if(temp.length()<dp[i][j].length())
                            dp[i][j]=temp;
                    }
                }
            }
            System.out.println(dp[0][length-1]);
        }
    }

    public static void main(String[] args){
        Main a=new Main();
        a.Slove();
    }

}