poj 1050To the Max dp+暴力

最新推荐文章于 2020-06-19 22:41:42 发布

原创最新推荐文章于 2020-06-19 22:41:42 发布 · 551 阅读

0 ·

CC 4.0 BY-SA版权

暴力专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一个算法问题，旨在寻找给定二维数组中具有最大和的子矩阵，并提供了完整的代码实现。通过动态规划方法，计算不同子矩阵的和，找出其中的最大值。

To the Max

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 36633		Accepted: 19268

Description

Given a two-dimensional array of positive and negative integers, a sub-rectangle is any contiguous sub-array of size 1*1 or greater located within the whole array. The sum of a rectangle is the sum of all the elements in that rectangle. In this problem the sub-rectangle with the largest sum is referred to as the maximal sub-rectangle.
As an example, the maximal sub-rectangle of the array:

0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2
is in the lower left corner:

9 2
-4 1
-1 8
and has a sum of 15.

Input

The input consists of an N * N array of integers. The input begins with a single positive integer N on a line by itself, indicating the size of the square two-dimensional array. This is followed by N^2 integers separated by whitespace (spaces and newlines). These are the N^2 integers of the array, presented in row-major order. That is, all numbers in the first row, left to right, then all numbers in the second row, left to right, etc. N may be as large as 100. The numbers in the array will be in the range [-127,127].

Output

Output the sum of the maximal sub-rectangle.

Sample Input

4
0 -2 -7 0 9 2 -6 2
-4 1 -4  1 -1

8  0 -2

Sample Output

Source

Greater New York 2001

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
 * 最大连续子段和 + 暴力
 * a11 a12 a13
 * a21 a22 a23
 * a31 a32 a33
 * 计算过程：依次计算如下一维数组的最大连续子段和，和最大的即为结果
 * a11 a12 a13
 * a21 a22 a23
 * a21+a11 a22+a12 a23+a13
 * a31 a32 a33
 * a31+a21 a32+a22 a33+a23
 * a31+a21+a11 a32+a22+a12 a33+a23+a13
 */
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int data[105][105];
int dp[105][105];
int temp[105];	//find()中
/*
 * 计算data数组的最大连续子段和，下标从start到end，该计算过程不会破坏数组的结构
 * @param data：要计算的数组
 * @param start：数组的开始下标
 * @param end：数组的结束下标
 * @return res：该数组的最大连续子段和
 */
int find(int *data, int start, int end)
{
	int i;
	int res = -999999999;
	memset(temp, 0, sizeof(temp));
	for(i = start; i <= end; ++ i)
	{
		temp[i] = MAX(data[i], temp[i - 1] + data[i]);
		res = MAX(res, temp[i]);
	}
	return res;
}
int main()
{
//	freopen("in.txt", "r", stdin);
	int n;
	while(scanf("%d", &n) == 1)
	{
		memset(data, 0, sizeof(data));
		memset(dp, 0, sizeof(dp));
		int res = -999999999;
		int i, j, k;
		for(i = 1; i <= n; ++ i)
		{
			for(j = 1; j <= n; ++ j)
			{
				scanf("%d", &data[i][j]);
			}
		}
		for(i = 1; i <= n; ++ i)
		{
			for(j = i; j >0; --j)
			{
				for(k = 1; k <= n; ++ k)
				{
					dp[i][k] += data[j][k];
				}
				res = MAX(res, find(dp[i], 1, n));
			}
		}
		printf("%d\n", res);
	}
	return 0;
}