给定一个数组A[A0,A1,A2,...,An],求数组中 连续子段之和 的最大值。
(1)最简单的算法:穷举法
计算所有的连续子段之和,得出最大值
// 穷举法:计算所有的子序列和
// O(n^3)
public static int maxSum1(int[] data) {
int max = data[0], tmp;
for (int i = 0; i < data.length; i++) {
for (int j = i; j < data.length; j++) {
tmp = 0;
for (int k = i; k <= j; k++) {
tmp += data[k];
}
max = tmp > max ? tmp : max;
}
}
return max;
}
(2) 穷举法改进版
去除
for (int k = i; k <= j; k++)
是的算法复杂度减为O(n^2)
// maxSum2的改进版
// O(n^2)
public static int maxSum2(int[] data) {
int max = data[0], tmp;
for (int i = 0; i < data.length; i++) {
tmp = 0;
for (int j = i; j < data.length; j++) {
tmp += data[j];
max = tmp > max ? tmp : max;
}
}
return max;
}
(3) 动态规划
/**
* M[j] = MAX(A[i]+A[i+1]+...+A[j]) i : 0~j
* M[j] = M[j-1]+A[j] M[j-1]>=0
* = A[j] M[j-1]<0
* max = MAX(M[j]) j : 0~n
* M[j]是最后一项为A[j]的0~j之间的最大子段和,M的最大值即为最大子段和
* O(n)
*/
public static int maxSum3(int[] data) {
int[] M = new int[data.length];
M[0] = data[0];
for (int j = 1; j < data.length; j++) {
if (M[j - 1] < 0) {
M[j] = data[j];
} else {
M[j] += data[j];
}
}
int max = M[0];
for (int j = 1; j < M.length; j++) {
if (max < M[j])
max = M[j];
}
return max;
}
+最优子结构
整个数组的最大子项和,一定包含子数组的最大子项和。MAX(M[j])
+建立递归关系
自顶向下,建立递归关系,至最原子态的问题.
M[j] = M[j-1]+A[j] M[j-1]>=0
= A[j] M[j-1]<0
+自底向上,计算各个子问题的最优解
由最原子态的问题(M[0]=data[0])的最优解开始,构建全部子问题的最优解,并记录过程
+求解整个问题的最优解
由全部子问题的最优解,自顶向下,组合出整个问题的最优解
比较得出M的最大值。
(4)动态规划的改进版
/**
* { 1, -2, 4, 10, -3, 5, 4, 6, 10, -30 }
* max 1 1 4 14 14 16 20 26 36 36
* tmp 1 -1 4 14 11 16 20 26 36 6
* maxSum3的改进版,maxSum3中在最后寻找最大值,可改为在循环过程中只保存M的最大值
*/
public static int maxSum(int[] data) {
int max = data[0], tmp = 0;
for (int i = 0; i < data.length; i++) {
if (tmp > 0) {
tmp += data[i];
} else {
tmp = data[i];
}
if (max < tmp) {
max = tmp;
}
}
return max;
}