经典递归问题--棋盘分割 POJ--1191

最新推荐文章于 2019-12-01 10:45:20 发布

原创最新推荐文章于 2019-12-01 10:45:20 发布 · 2.9k 阅读

4 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

数据结构

算法

c语言

这篇博客探讨了如何使用递归算法解决经典的棋盘分割问题，详细介绍了问题背景、输入输出格式，并给出了样例输出。适合对递归和动态规划感兴趣的C++及C语言学习者。

棋盘分割

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 11735		Accepted: 4138

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

解题思路：很明显每次切割棋盘只有两种选择，要么横切要么竖切。方向选定后又有两种组合，取两部分中的一部分继续递归另一部分直接计算结果。每次切割后问题的规模会减小。所以我们考虑把所有的解遍历一遍找到最优方案。

这里要注意两点：

【1】原公式可以化简

【2】要考虑不进行重复的计算，即用一个多维数组记录已经得到的最优解。下一次再碰到同样的情况时直接查询得到解。减少运行时间否则会超时。（动态规划的思想）

// 棋盘分割.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<stdio.h>
#include<math.h>
using namespace std;

double a[8][8]={0};
int n=0;
double aver_2=0.0;
double dfs(int i,int j,int k,int p,int cnt);
double recorde[16][9][9][9][9]={0};
double sum_record[9][9][9][9]={0};

int main()
{
	//while(scanf("%d",&n)!=EOF)
	scanf("%d",&n);
	{
		memset(recorde,-1,sizeof(recorde));
		memset(sum_record,-1,sizeof(sum_record));

		double sum=0.0;
		double x_aver=0.0;
		double x_i=0.0;

		for(int i=0;i<8;i++)
			for(int j=0;j<8;j++)
			{
				scanf("%lf",&a[i][j]);
				sum+=a[i][j];
			}
		    x_aver=sum/n;
			x_aver*=x_aver;
			aver_2=x_aver;
		    x_i=dfs(0,7,0,7,1);
			double ans=sqrt(x_i/n-x_aver) ;
			//cout<<ans<<endl;
			printf("%0.3f",ans);
	}
	return 0;
}

double sum_(int i,int j,int k,int p)
{
	if(sum_record[i][j][k][p]>=0)
		return sum_record[i][j][k][p];
	int ii=0,kk=0;
	double sum=0.0;
	for(ii=i;ii<=j;ii++)
		for(kk=k;kk<=p;kk++)
			sum+=a[kk][ii];
	sum_record[i][j][k][p]=sum*sum;
	return sum_record[i][j][k][p];
}

double min_(double a,double b)
{
	return (a>b?b:a);
}
double min_1(double a,double b)
{
	return (a/n-aver_2>b/n-aver_2?b:a);
}


double dfs(int i,int j,int k,int p, int cnt)
{
	if(recorde[cnt][i][j][k][p]>=0)
		return recorde[cnt][i][j][k][p];
	int ii=0,kk=0;
	double temp1=0,temp2=0;
	double min=999999999999999;
	if(cnt==n)
	{
		return sum_(i,j,k,p);
	}
	for(ii=i;ii<j;ii++)
	{
		temp1=sum_(i,ii,k,p)+dfs(ii+1,j,k,p,cnt+1);
		if(min>temp1) 
			min=temp1;
		temp2=sum_(ii+1,j,k,p)+dfs(i,ii,k,p,cnt+1);  
		if(min>temp2) 
			min=temp2;
	}
	
	for(kk=k;kk<p;kk++)
	{
		temp1=sum_(i,j,k,kk)+dfs(i,j,kk+1,p,cnt+1);
		if(min>temp1) 
			min=temp1;
		temp2=sum_(i,j,kk+1,p)+dfs(i,j,k,kk,cnt+1);  
		if(min>temp2) 
			min=temp2;
	}
	recorde[cnt][i][j][k][p]=min;
	return min;
}

标签

#c++ #c语言 #递归 #动态规划