最大子段和c（c语言实现）

1，题目

2，各种算法

• 暴力解决，就是所有的情况都遍历一遍，然后说，我找到最牛逼的啦

int MaxSubseqSum1(int A[], int N, int* pidxStart, int* pidxEnd)
{ 
	int sum = A[0], tempSum = 0;
	int i, j, k;
	*pidxStart = 0, *pidxEnd = 0;
	for (i = 0; i < N; i++) {
		for (j = i+1; j < N; j++) {
			tempSum = 0;
			for(k = i; k <= j; k++) {
				tempSum += A[k];
			}
			if (tempSum > sum) {
				sum = tempSum;
				*pidxStart = i;
				*pidxEnd = j;
			}
		}

	}
	return sum;
}

粗略的看三重循环，算法复杂度是O(n^3)，空间上没有大空间的开辟。

• 好一点的暴力解决

int MaxSubseqSum2(int A[], int N, int* idxStart, int* idxEnd)
{
	int ThisSum, MaxSum = 0;
	int i, j;
	for (i = 0; i < N; i++) { //遍历所有的起点，以i为i起点
		ThisSum = 0;
		for (j = i; j < N; j++) { //j为终点
			ThisSum += A[j];
			if (ThisSum > MaxSum) {
				MaxSum = ThisSum;
				*idxStart = i;
				*idxEnd = j;
			}
		}
	}
	return MaxSum;
}

算法复杂度O(n^2)，和第一个算法相比到底是哪个地方优化了呢？原因在于很多子段和有重叠的地方，第一个算的法重复计算重复计算特别多，第二个相对少多了，但还是有很多子段和是重叠计算的，这说明这个算法还有很大的提高的空间。

• 分治算法

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

int MaxSubseqSum3(int A[], int beg, int end)
{
	if (beg == end) {
		return A[beg];
	}
	int mid = (beg + end) / 2;
	int left, right, lSum = A[mid], thislSum = 0, rSum = A[mid+1], thisrSum = 0;
	int i;
	left = MaxSubseqSum3(A, beg, mid);
	right = MaxSubseqSum3(A, mid+1, end);
	for (i = mid; i >= 0; i--) {
		thislSum += A[i];
		if (thislSum > lSum) {
			lSum = thislSum;
		}
	}
	for (i = mid+1; i <= end; i++) {
		thisrSum += A[i];
		if (thisrSum > rSum) {
			rSum = thisrSum;
		}
	}
	return max(left, lSum+rSum, right);
}

分治算法因为使用到递归，所以一般实际中也不会用，因为在实际中数据偏大，递归过程中会开辟很多的空间，造成空间超出内存。其优美之处在于其算法复杂度的数学分析上，其算法复杂度是O(n * ln(n))，具体参看《算法导论》。

• 在线算法，先看其算法

//在线算法
int MaxSubseqSum4(int A[], int N)
{
	int i = 0;
	int thisSum = 0, sum = 0;
	for (i = 0; i < N; i++) {
		thisSum += A[i];
		if (thisSum > sum) {
			sum = thisSum;
		} else if (thisSum <= 0) {
			thisSum = 0;
		}
	}
	return sum;
}

很多数学概念学起来是枯燥无味的，因为它们是现实世界的抽象，完全扭曲了我们观察事物的直观感觉，另一方面，数学是真正的抓住了核心和本质，所以很多繁杂的现象，可能用一个方程式子就完全描述了，譬如说爱因斯坦的质量方程，麦克斯韦的电磁方程组。

看上面的图，我们用数学语言描述一个过程：我们要寻找物质A，寻找的范围是T，可是T的范围太大了，可能花费多少力气都完不成；由于物质A具有性质B，那么B性质就是物质A的必要条件（也就是必须满足的条件），在T中发现满足B性质的是范围C，那么我们直接在C范围中寻找物质A就行了，而且范围C非常小，使得我们很快的找到了物质A。