子数组的最大累加和问题

输入一个整形数组，求数组中连续的子数组使其和最大。比如，数组x

应该返回 x[2..6]的和187.

 

这四个代码完成的功能都是求最大子数组（注意用词准确，子数组连续，子序列可以不连续）。

1）

for(i = 1; i <= n; i++)scanf("%d", &num[i]);
ans = num[1]; 
for(i = 1; i <= n; i++)
{for(j = i; j <= n; j++) {s = 0;for(k = i; k <= j; k++)s += num[k];if(s > ans)ans = s;}
}

分别枚举每一个子数组的起点和终点，也就是i和j，对于每一个起点和终点，对中间部分求和，也就是k循环。显然有n个起点n个终点（去重减半，不影响复杂度），所以子数组数量为O(N^2)，对于每个子数组，我们要遍历一下求和，子数组长度1-n不等，遍历一遍平均O(N)，乘起来O(N^3).（注意可能产生时间更大的错觉）。找出所有子数组中最大的即可。

2）

for(i = 1; i <= n; i++)scanf("%d", &num[i]);
sum[0] = 0;
for(i = 1; i <= n; i++) {sum[i] = num[i] + sum[i - 1];
}
ans = num[1]; 
for(i = 1; i <= n; i++) {for(j = i; j <= n; j++) {s = sum[j] - sum[i - 1];if(s > ans) ans = s;}
}

预处理出每一个以第一个元素开始，第i个元素结尾的子数组和，还是枚举每个起点终点，但是我们求和时直接减就可以了，不用遍历。对于每个子数组，操作为O(1),子数组数量O(N^2),所以总时间O(N^2).

3）

int solve(int left, int right)
{if(left == right)return num[left];mid = (left + right) / 2;lans = solve(left, mid);rans = solve(mid + 1, right);sum = 0, lmax = num[mid], rmax = num[mid + 1];for(i = mid; i >= left; i--) {sum += num[i];if(sum > lmax) lmax = sum;}sum = 0;for(i = mid + 1; i <= right; i++) {sum += num[i];if(sum > rmax) rmax = sum;}ans = lmax + rmax;if(lans > ans) ans = lans;if(rans > ans) ans = rans;return ans;
}int main(void)
{scanf("%d", &n);for(i = 1; i <= n; i++)scanf("%d", &num[i]);printf("%d\n", solve(1, n));return 0;
}

二分，求左右两边最大子数组，取最大。但是还有一种情况：包含断点的那些子数组也要考虑，请思考那两个那两个循环为什么那么写？最后逻辑为何正确？

4）动态规划入门思想

没有枚举，num[i]的含义是以下标i结尾的所有子数组中最大的。

遍历数组，对于第i个元素，它的所有子数组下标范围有[1,i],[2,i].....[i-1,i],还有它自己，我们看i-1个元素，他的子数组为[1,i-1],[2,i-1].....[i-1]。请想num[i]的含义，我们求i结尾的，只要把i-1结尾的最大加上i就好了，当然如果i-1结尾最大子数组是负的，i结尾最大子数组就是它本身。

为什么O(N)？时间省在哪里了？我们省掉了许多没必要的计算，计算i时，之前的数组和已经都计算过，朴素算法并没有记录下来，而是重复计算，造成时间浪费。算法优化的过程就是去掉重复计算的过程。
 

for(i = 1; i <= n; i++)scanf("%d", &num[i]);num[0] = 0;
ans = num[1];
for(i = 1; i <= n; i++) 
{if(num[i - 1] > 0) num[i] += num[i - 1];elsenum[i] += 0;if(num[i] > ans) ans = num[i];
}

子矩阵的最大累加和问题

给一个矩阵，请找出一个矩阵中，和最大的子矩阵。

 

 

 

如果大家看懂了之前的讲解，我给个提示：利用第二个代码和第四个代码思想的结合

 

 

解释：

1   2  3   4

-1 -2  1   2

1   3   -2  1

-1  -2  -1  -3

如图是前三行整体最大

怎么做呢？

先用第二个代码的思想，我们进行预处理

每个数代表这一列到这个数位置截止，累加和。

1  2  3  4

0  0  4  6

1  3  2  7

0  1  1  4

然后，我们枚举每一列的起点和终点分别为第0，1，2，3行

然后压缩成一维来做

比如求1-3行的这个矩形，我们拿0和3行减一下就行了

0-1，1-2，1-3，4-4=-1，-1，-2，0就是1-3行压缩后的结果

然后按一维dp来做就好
 

public class SubMatrixMaxSum {public static int maxSum(int[][] m) {if (m == null || m.length == 0 || m[0].length == 0) {return 0;}int max = Integer.MIN_VALUE;int cur = 0;int[] s = null; // 累加数组for (int i = 0; i != m.length; i++) {s = new int[m[0].length];for (int j = i; j != m.length; j++) {cur = 0;for (int k = 0; k != s.length; k++) {s[k] += m[j][k];cur += s[k];max = Math.max(max, cur);cur = cur < 0 ? 0 : cur;}}}return max;}public static void main(String[] args) {int[][] matrix = { { -90, 48, 78 }, { 64, -40, 64 }, { -81, -7, 66 } };System.out.println(maxSum(matrix));}}

子数组的最大累乘积

题目：

给定一个double类型的数组arr，其中的元素可正、可负、可为0。返回子数组累乘的最大乘积。

思路：

假设以arr[i-1]结尾的数组最小累乘积为min，最大累乘积为max，那么以arr[i]结尾的数组的最大累乘积可能有三种情况。

• max*arr[i]//本身乘之前的最大累乘
• min*arr[i]//可能是负负得正变成最大的
• arr[i]//可能就是它本身，比如之前的max小于1

public class SubArrayMaxProduct {public static double maxProduct(double[] arr) {if (arr == null || arr.length == 0) {return 0;}double max = arr[0];double min = arr[0];double res = arr[0];double maxEnd = 0;double minEnd = 0;for (int i = 1; i < arr.length; ++i) {maxEnd = max * arr[i];minEnd = min * arr[i];max = Math.max(Math.max(maxEnd, minEnd), arr[i]);min = Math.min(Math.min(maxEnd, minEnd), arr[i]);res = Math.max(res, max);}return res;}public static void main(String[] args) {double[] arr = { -2.5, 4, 0, 3, 0.5, 8, -1 };System.out.println(maxProduct(arr));}}