Calculate the biggest sum of subarray

 Given an array of integers, how to calculate the biggest sum of its subarrays? This is a typical problem and is solved in almost every textbook about algorithm, especially about dynamic programming. However, in most cases, there is always an extra requirement that the biggest sum will be ZERO if the final result is negative. This leads to a limitation of the solution. For example, if all the data in the array are negative, then the real answer (i.e., the biggest negative integer in it) is hidden by ZERO. The below code can deal with this situation. The basic idea is still dynamic programming, that is, if the first i elements' biggest sum is known, when considering the (i + 1)th element, there will be only two possible consequences: one is that the (i + 1)th element can be added to the "biggest" subarray, while the other is that a new "bigger" subarray, which contains only the (i + 1)th element is taking place of the old one. During the whole process, the starting and the ending index of the "biggest" subarray can be maintained. Here is one version of implementation (Using the test data in <Beauty of Programming>).

1. #include <iostream>
2. using namespace std;
4. void max_sum_of_subarray(int* A, int n, int& max_all, int& start_index, int& end_index) {
5.     int max_pre; // Store the max sum of the pre-subarray.
6.     int temp_start_index, temp_end_index; // Bookkeeping during the process.
7.     max_pre = max_all = A[0];
8.     temp_start_index = temp_end_index = start_index = end_index = 0;
9.     for(int i = 1; i < n; ++i) {
10.         if(A[i] > max_pre + A[i]) { // A new "bigger" subarray appears.
11.             max_pre = A[i];
12.           temp_start_index = temp_end_index = i;
13.         }
14.         else { // Just add the ith element into the old subarray.
15.             max_pre += A[i];
16.             temp_end_index = i;
17.         }
18.         if(max_all < max_pre) { // Adjust the final max sum and the indices.
19.             max_all = max_pre;
20.             start_index = temp_start_index;
21.             end_index = temp_end_index;
22.         }
23.     }
24. }
26. int main() {
27.         // Test data from <Beauty of Programming>.
28.     int a[6] = {1, -2, 3, 5, -3, 2};
29.     int b[6] = {0, -2, 3, 5, -1, 2};
30.     int c[5] = {-9, -2, -3, -5, -3};
31.     
32.     int max_sum, start_index, end_index;
33.     max_sum_of_subarray(a, 6, max_sum, start_index, end_index);
34.     cout << "max sum: " << max_sum << "/trange: [" << start_index << ", " << end_index << "]" << endl;
35.     max_sum_of_subarray(b, 6, max_sum, start_index, end_index);
36.     cout << "max sum: " << max_sum << "/trange: [" << start_index << ", " << end_index << "]" << endl;
37.     max_sum_of_subarray(c, 5, max_sum, start_index, end_index);
38.     cout << "max sum: " << max_sum << "/trange: [" << start_index << ", " << end_index << "]" << endl;
39.     
40.     return 0;
41. }

The command line outputs:

max sum: 8        range: [2, 3]

max sum: 9        range: [2, 5]

max sum: -2       range: [1, 1]

 

Referenced to <Beauty of Programming>.