hdoj 1003 连续最大子数组 分治法 & dp法

题目大意:给出一个序列a ，寻找出a的和最大的非空连续子数组

1.使用分支策略求解 （有算导的直接看算导好了，ch4）

假设寻找的子数组A[low...high]为最大子数组，使用分支策略，意味着我们需要将原数组分为两个规模近似相同的子数组，那么我们可以找到数组a的中间位置mid

则数组A的位置可能有三种情况：

1.完全位于子数组a[low...mid] 中

2.完全位于子数组a[mid + 1... high]中

3.跨过中点

其中前两种情况我们直接使用递归即可，至于第三种情况，可以用这种策略，从中点开始，向左遍历数组求出最大的和 ，然后在从中点向右遍历，求出最大的和

之后两者相加，即获得过中点 和最大的子数组

代码(注意输出格式)

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string>
#include <algorithm>
#include <memory.h>

using namespace std;
const int maxn = 100000 + 10;
const int mini = -100000000;

int num[maxn];
//int memo[maxn][maxn];

int find_cross_subarray(int low,int high,int  & cross_low,int & cross_high)// low_max 为过中点 到达最左边的下标，high_max 为过中点 到达最右边的下标
{
	int mid = (low + high) / 2;
	int res = 0;
	
	int left_sum = mini;
	for (int i = mid; i >= low; i--)
	{
		res += num[i];
		if (res >= left_sum)		//输出第一个 满足要求的数组 所以要尽量向左边靠拢
		{
			left_sum = res;
			cross_low = i;
		}
	}//for int i

	res = 0;
	int right_sum = mini;
	for (int i = mid + 1; i <= high; i++)
	{
		res += num[i];
		if (res > right_sum)
		{
			right_sum = res;
			cross_high = i;
		}
	}

	return right_sum + left_sum;
}

int find_max_subarray(int low, int high,int & max_low,int & max_high)	//max_low max_high为最终答案的左右下标
{
	if (high == low)
	{
		max_low = max_high = low;
		return num[high];
	}

	int mid = (low + high) / 2;
	int left_low, left_high, left_sum;
	int right_low, right_high, right_sum;
	int cross_low, cross_high, cross_sum;

	left_sum = find_max_subarray(low, mid,left_low,left_high);
	right_sum = find_max_subarray(mid + 1, high,right_low,right_high);
	cross_sum = find_cross_subarray(low, high, cross_low, cross_high);

	if (left_sum >= cross_sum && left_sum >= right_sum)
	{
		max_low = left_low;
		max_high = left_high;
		return left_sum;
	}

	if (cross_sum >= left_sum && cross_sum >= right_sum)
	{
		max_low = cross_low;
		max_high = cross_high;
		return cross_sum;
	}

	max_low = right_low;
	max_high = right_high;
	return right_sum;
}

int main()
{
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	int casenum, length,seq = 0;
	cin >> casenum;
	while (casenum--)
	{
		if (seq != 0)
			cout << endl;
		cin >> length;
		for (int i = 0; i < length; i++)
			cin >> num[i];
		
		int max_low, max_high, res;
		res = find_max_subarray(0, length - 1, max_low, max_high);
		cout << "Case " << ++seq << ":" << endl;
		cout << res << " " << max_low + 1<< " " << max_high + 1<<endl;
	}
	return 0;
}

2.dp方法

dp[i] 表示从开始到 第i个节点连续子串的最大值 ，方程dp[i] = maxn(dp[i], dp[i - 1] + num[i])

注意需要输出第一个满足题意的答案，所以在更新最大值时注意 比较符号

代码：

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>

using namespace std;
const int maxn = 100000 + 10;

int num[maxn], dp[maxn];//dp[i] 表示从开始到 第i个节点连续子串的最大值 方程dp[i] = maxn(dp[i], dp[i - 1] + num[i])

int max(int a, int b)
{
	return a > b ? a : b;
}

int main()
{
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	int casenum, length, seq = 0;
	cin >> casenum;
	while (casenum--)
	{
		if (0 != seq)
			cout << endl;

		int res , end = 0, start = 0;
		cin >> length;
		for (int i = 0; i < length; i++)
		{
			cin >> num[i];
			dp[i] = num[i];
		}

		res = dp[0];
		for (int i = 1; i < length; i++)
		{
			dp[i] = max(dp[i], dp[i - 1] + num[i]);
			if (res < dp[i])
			{
				res = dp[i];
				end = i;
			}
		}

		//从end位置出发，想回找到start 位置使得 dp[i] = num[start] + ... + num[end]
		int temp = 0;
		for (int i = end; i >= 0; i--)
		{
			temp += num[i];
			if (temp == res)
			{
				start = i;
				//break;
			}
		}

		cout << "Case " << ++seq << ":"<<endl;
		cout << res << " " << start + 1 << " " << end + 1 << endl;
	}//while
	return 0;
}

另外不用dp数组方法*（实际上还有不用数组存储 数字的方法，链接：www.cnblogs.com/ACMan/archive/2012/07/01/2572061.html）：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string>

using namespace std;
const int maxn = 100000 + 100;
int casenum;
int size;
int num[maxn];
int ans = 0;
void work(int & lp,int & rp)			//给ans， lp,rp赋值
{
	ans = num[0];
	int pre = ans;

	for (int i = 1; i < size; i++)
	{
		if (pre > 0)
			pre += num[i];
		else
			pre = num[i];
		if (pre > ans)
		{
			ans = pre;
			rp = i;
		}
	}

	int tmp = 0;
	for (int i = rp; i >= 0; i--)
	{
		tmp += num[i];
		if (tmp == ans)
			lp = i;
	}
}

int main()
{
	freopen("in.txt", "r", stdin);
	freopen("out.txt", "w", stdout);
	int cnt = 1;
	cin >> casenum;
	while (casenum--)
	{
		if (1 != cnt)
			cout << endl;
		cin >> size;
		for (int i = 0; i < size; i++)
			cin >> num[i];
		int lp = 0, rp = 0;
		work(lp, rp);
		cout << "Case " << cnt++ << ":" << endl;
		cout << ans << " " << lp + 1 << " " << rp + 1 << endl;
	}
	return 0;
}