Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum.
Kadane’s Algorithm:
Initialize: max_so_far = INT_MIN max_ending_here = 0 Loop for each element of the array (a) max_ending_here = max_ending_here + a[i] (b) if(max_so_farExplanation:
The simple idea of Kadane's algorithm is to look for all positive contiguous segments of the array (max_ending_here is used for this). And keep track of maximum sum contiguous segment among all positive segments (max_so_far is used for this). Each time we get a positive-sum compare it with max_so_far and update max_so_far if it is greater than max_so_farLets take the example: {-2, -3, 4, -1, -2, 1, 5, -3} max_so_far = max_ending_here = 0 for i=0, a[0] = -2 max_ending_here = max_ending_here + (-2) Set max_ending_here = 0 because max_ending_hereProgram:
PHP
<?php
// PHP program to print largest
// contiguous array sum
function
maxSubArraySum(
$a
,
$size
)
{
$max_so_far
= PHP_INT_MIN;
$max_ending_here
= 0;
for
(
$i
= 0;
$i
<
$size
;
$i
++)
{
$max_ending_here
=
$max_ending_here
+
$a
[
$i
];
if
(
$max_so_far
<
$max_ending_here
)
$max_so_far
=
$max_ending_here
;
if
(
$max_ending_here
< 0)
$max_ending_here
= 0;
}
return
$max_so_far
;
}
// Driver code
$a
=
array
(-2, -3, 4, -1,
-2, 1, 5, -3);
$n
=
count
(
$a
);
$max_sum
= maxSubArraySum(
$a
,
$n
);
echo
"Maximum contiguous sum is "
,
$max_sum
;
// This code is contributed by anuj_67.
?>
Output:
Maximum contiguous sum is 7Another approach:
PHP
<?php
function
maxSubArraySum(&
$a
,
$size
)
{
$max_so_far
=
$a
[0];
$max_ending_here
= 0;
for
(
$i
= 0;
$i
<
$size
;
$i
++)
{
$max_ending_here
=
$max_ending_here
+
$a
[
$i
];
if
(
$max_ending_here
< 0)
$max_ending_here
= 0;
/* Do not compare for all elements.
Compare only when max_ending_here > 0 */
else
if
(
$max_so_far
<
$max_ending_here
)
$max_so_far
=
$max_ending_here
;
}
return
$max_so_far
;
// This code is contributed
// by ChitraNayal
?>
Time Complexity: O(n)
Algorithmic Paradigm: Dynamic Programming
Following is another simple implementation suggested by Mohit Kumar. The implementation handles the case when all numbers in the array are negative. PHP
<?php
function
maxSubArraySum(
$a
,
$size
)
{
$max_so_far
=
$a
[0];
$curr_max
=
$a
[0];
for
(
$i
= 1;
$i
<
$size
;
$i
++)
{
$curr_max
= max(
$a
[
$i
],
$curr_max
+
$a
[
$i
]);
$max_so_far
= max(
$max_so_far
,
$curr_max
);
}
return
$max_so_far
;
}
// Driver Code
$a
=
array
(-2, -3, 4, -1,
-2, 1, 5, -3);
$n
= sizeof(
$a
);
$max_sum
= maxSubArraySum(
$a
,
$n
);
echo
"Maximum contiguous sum is "
.
$max_sum
;
// This code is contributed
// by Akanksha Rai(Abby_akku)
?>
Output:
Maximum contiguous sum is 7To print the subarray with the maximum sum, we maintain indices whenever we get the maximum sum.
PHP
<?php
// PHP program to print largest
// contiguous array sum
function
maxSubArraySum(
$a
,
$size
)
{
$max_so_far
= PHP_INT_MIN;
$max_ending_here
= 0;
$start
= 0;
$end
= 0;
$s
= 0;
for
(
$i
= 0;
$i
<
$size
;
$i
++)
{
$max_ending_here
+=
$a
[
$i
];
if
(
$max_so_far
<
$max_ending_here
)
{
$max_so_far
=
$max_ending_here
;
$start
=
$s
;
$end
=
$i
;
}
if
(
$max_ending_here
< 0)
{
$max_ending_here
= 0;
$s
=
$i
+ 1;
}
}
echo
"Maximum contiguous sum is "
.
$max_so_far
.
"\n"
;
echo
"Starting index "
.
$start
.
"\n"
.
"Ending index "
.
$end
.
"\n"
;
}
// Driver Code
$a
=
array
(-2, -3, 4, -1, -2, 1, 5, -3);
$n
= sizeof(
$a
);
$max_sum
= maxSubArraySum(
$a
,
$n
);
// This code is contributed
// by ChitraNayal
?>
Output:
Maximum contiguous sum is 7 Starting index 2 Ending index 6Kadane's Algorithm can be viewed both as a greedy and DP. As we can see that we are keeping a running sum of integers and when it becomes less than 0, we reset it to 0 (Greedy Part). This is because continuing with a negative sum is way more worse than restarting with a new range. Now it can also be viewed as a DP, at each stage we have 2 choices: Either take the current element and continue with previous sum OR restart a new range. These both choices are being taken care of in the implementation.
Time Complexity: O(n)
Auxiliary Space: O(1)
Now try the below question
Given an array of integers (possibly some elements negative), write a C program to find out the *maximum product* possible by multiplying 'n' consecutive integers in the array where n ? ARRAY_SIZE. Also, print the starting point of the maximum product subarray.