16：棋盘分割

Description

将一个８*８的棋盘进行如下分割：将原棋盘割下一块矩形棋盘并使剩下部分也是矩形，再将剩下的部分继续如此分割，这样割了(n-1)次后，连同最后剩下的矩形棋盘共有n块矩形棋盘。(每次切割都只能沿着棋盘格子的边进行)

原棋盘上每一格有一个分值，一块矩形棋盘的总分为其所含各格分值之和。现在需要把棋盘按上述规则分割成n块矩形棋盘，并使各矩形棋盘总分的均方差最小。
均方差，其中平均值，x_i为第i块矩形棋盘的总分。
请编程对给出的棋盘及n，求出O'的最小值。

Input

第1行为一个整数n(1 < n < 15)。
第2行至第9行每行为8个小于100的非负整数，表示棋盘上相应格子的分值。每行相邻两数之间用一个空格分隔。

Output

仅一个数，为O'（四舍五入精确到小数点后三位）。

Sample Input

3

1 1 1 1 1 1 1 3

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 0

1 1 1 1 1 1 0 3

Sample Output

1.633

解题方法：首先先进行数学计算和化简，发现均方差最小就是每个矩形的总分的平方和最小即可。所以算法只要进行穷举和动态规划即可~~~

package OJ;

import java.util.*; 

public class P16_temp  
{ 
    static int min(int a,int b){
    	return (a>b)? b:a;
    } 
    
    static double min(double a,double b){
    	return (a>b)? b:a;
    
    } 
    final int Max_Int=200000000; 
    
    static double qr(double x){  //取平方
    	return x*x;
    } 
    
    public static void main(String[] args) 
    { 
        Scanner cin=new Scanner(System.in); 
        int a[][]=new int[10][10],s[][]=new int [10][10],sum[][][][]=new int[9][9][9][9]; 
        double dp[][][][][]=new double [9][9][9][9][17]; 
        int n=cin.nextInt();  //输入分割成几块
        double tot=0,ave=0; 
        for(int i=1;i<=8;i++) 
        { 
            s[i][0]=0; 
            for(int j=1;j<=8;j++) 
            {    
                a[i][j]=cin.nextInt();  //a数组中存储棋盘
                tot+=(double)a[i][j];   //tot是棋盘分数和
                s[i][j]=s[i][j-1]+a[i][j];  //s数组的第二列的和就是该棋盘从左往右数的两列的和 
                                            //举例：s[1][1] = a[1][1] , s[1][2] = s[1][1] + a[1][2]
            } 
        } 
        ave=tot/(double)n;  //棋盘分数平均值
        for(int x1=1;x1<=8;x1++) 
            for(int x2=x1;x2<=8;x2++) 
                for(int y1=1;y1<=8;y1++) 
                    for(int y2=y1;y2<=8;y2++) 
                    { 
                        sum[x1][x2][y1][y2]=0;    //sum数组是sum[x1][x2][y1][y2]  左上角坐标为(x1,y1)，右下角坐标为(x2,y2)的棋盘的总和
                        for(int t=x1;t<=x2;t++) 
                            sum[x1][x2][y1][y2]+=s[t][y2]-s[t][y1-1]; 
                        dp[x1][x2][y1][y2][1]=qr(sum[x1][x2][y1][y2]-ave);  //每一个左上角坐标为(x1,y1)，右下角坐标为(x2,y2)的棋盘的方差
                    } 
        for(int v=2;v< n;v++)  //v表示已经被切过v次了 举例：dp[x1][t][y1][y2][v-1] 表示前面的那个部分已经被切过v-1次了
            for(int x1=1;x1<=8;x1++) 
                for(int x2=x1;x2<=8;x2++) 
                    for(int y1=1;y1<=8;y1++) 
                        for(int y2=y1;y2<=8;y2++) 
                        { 
                            dp[x1][x2][y1][y2][v]=100000000.0; 
                            for(int t=x1;t< x2;t++)  //先竖着切，找到最小值（从左往右切）
                                dp[x1][x2][y1][y2][v]=min(dp[x1][x2][y1][y2][v],dp[x1][t][y1][y2][v-1]+dp[t+1][x2][y1][y2][1]); 
                            for(int t=x1;t< x2;t++)  //（从右往左切）
                                dp[x1][x2][y1][y2][v]=min(dp[x1][x2][y1][y2][v],dp[t+1][x2][y1][y2][v-1]+dp[x1][t][y1][y2][1]); 
                            for(int t=y1;t< y2;t++)  //再横着切，找到最小值（从左往右切）
                                dp[x1][x2][y1][y2][v]=min(dp[x1][x2][y1][y2][v],dp[x1][x2][y1][t][v-1]+dp[x1][x2][t+1][y2][1]); 
                            for(int t=y1;t< y2;t++)  //（从右往左切）
                                dp[x1][x2][y1][y2][v]=min(dp[x1][x2][y1][y2][v],dp[x1][x2][t+1][y2][v-1]+dp[x1][x2][y1][t][1]); 
                        } 
        dp[1][8][1][8][n]=100000000.0; 
        for(int t=1;t< 8;t++) 
            dp[1][8][1][8][n]=min(dp[1][8][1][8][n], dp[1][t][1][8][n-1]+dp[t+1][8][1][8][1]); 
        for(int t=1;t< 8;t++) 
            dp[1][8][1][8][n]=min(dp[1][8][1][8][n], dp[t+1][8][1][8][n-1]+dp[1][t][1][8][1]); 
        for(int t=1;t< 8;t++) 
            dp[1][8][1][8][n]=min(dp[1][8][1][8][n], dp[1][8][1][t][n-1]+dp[1][8][t+1][8][1]); 
        for(int t=1;t< 8;t++) 
            dp[1][8][1][8][n]=min(dp[1][8][1][8][n], dp[1][8][t+1][8][n-1]+dp[1][8][1][t][1]); 
        System.out.printf("%.3f", Math.sqrt(dp[1][8][1][8][n]/(double)n)); 
    } 
}