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。