最大子段和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。