 GFG App
Open App Browser
Continue

# C# Program for Largest Sum Contiguous Subarray

Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum. ```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_far < max_ending_here)
max_so_far = max_ending_here
(c) if(max_ending_here < 0)
max_ending_here = 0
return max_so_far```

Explanation:
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_far

```    Lets take the example:
{-2, -3, 4, -1, -2, 1, 5, -3}

max_so_far = max_ending_here = 0

for i=0,  a =  -2
max_ending_here = max_ending_here + (-2)
Set max_ending_here = 0 because max_ending_here < 0

for i=1,  a =  -3
max_ending_here = max_ending_here + (-3)
Set max_ending_here = 0 because max_ending_here < 0

for i=2,  a =  4
max_ending_here = max_ending_here + (4)
max_ending_here = 4
max_so_far is updated to 4 because max_ending_here greater
than max_so_far which was 0 till now

for i=3,  a =  -1
max_ending_here = max_ending_here + (-1)
max_ending_here = 3

for i=4,  a =  -2
max_ending_here = max_ending_here + (-2)
max_ending_here = 1

for i=5,  a =  1
max_ending_here = max_ending_here + (1)
max_ending_here = 2

for i=6,  a =  5
max_ending_here = max_ending_here + (5)
max_ending_here = 7
max_so_far is updated to 7 because max_ending_here is
greater than max_so_far

for i=7,  a =  -3
max_ending_here = max_ending_here + (-3)
max_ending_here = 4```

Program:

## C#

 `// C# program to print largest ` `// contiguous array sum` `using` `System;`   `class` `GFG` `{` `    ``static` `int` `maxSubArraySum(``int` `[]a)` `    ``{` `        ``int` `size = a.Length;` `        ``int` `max_so_far = ``int``.MinValue, ` `            ``max_ending_here = 0;`   `        ``for` `(``int` `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 ` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[] a = {-2, -3, 4, -1, -2, 1, 5, -3};` `        ``Console.Write(``"Maximum contiguous sum is "` `+` `                                ``maxSubArraySum(a));` `    ``}`   `}`   `// This code is contributed by Sam007_`

Output:

`Maximum contiguous sum is 7`

Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Another approach:

## C#

 `static` `int` `maxSubArraySum(``int``[] a, ``int` `size)` `{` `    ``int` `max_so_far = a, max_ending_here = 0;`   `    ``for` `(``int` `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), where n represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Following is another simple implementation suggested by Mohit Kumar. The implementation handles the case when all numbers in the array are negative.

## C#

 `// C# program to print largest ` `// contiguous array sum` `using` `System;`   `class` `GFG` `{` `    ``static` `int` `maxSubArraySum(``int` `[]a, ``int` `size)` `    ``{` `    ``int` `max_so_far = a;` `    ``int` `curr_max = a;`   `    ``for` `(``int` `i = 1; i < size; i++)` `    ``{` `        ``curr_max = Math.Max(a[i], curr_max+a[i]);` `        ``max_so_far = Math.Max(max_so_far, curr_max);` `    ``}`   `    ``return` `max_so_far;` `    ``}`   `    ``// Driver code ` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]a = {-2, -3, 4, -1, -2, 1, 5, -3};` `        ``int` `n = a.Length; ` `        ``Console.Write(``"Maximum contiguous sum is "` `                           ``+ maxSubArraySum(a, n));` `    ``}`   `}`   `// This code is contributed by Sam007_`

Output:

`Maximum contiguous sum is 7`

Time Complexity: O(N), where N represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

To print the subarray with the maximum sum, we maintain indices whenever we get the maximum sum.

## C#

 `// C# program to print largest ` `// contiguous array sum` `using` `System;`   `class` `GFG ` `{` `    ``static` `void` `maxSubArraySum(``int` `[]a, ` `                               ``int` `size)` `    ``{` `        ``int` `max_so_far = ``int``.MinValue,` `        ``max_ending_here = 0, start = 0,` `        ``end = 0, s = 0;`   `        ``for` `(``int` `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;` `            ``}` `        ``}` `        ``Console.WriteLine(``"Maximum contiguous "` `+ ` `                         ``"sum is "` `+ max_so_far);` `        ``Console.WriteLine(``"Starting index "` `+ ` `                                      ``start);` `        ``Console.WriteLine(``"Ending index "` `+ ` `                                      ``end);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]a = {-2, -3, 4, -1, ` `                   ``-2, 1, 5, -3};` `        ``int` `n = a.Length;` `        ``maxSubArraySum(a, n);` `    ``}` `}`   `// This code is contributed` `// by anuj_67.`

Output:

```Maximum contiguous sum is 7
Starting index 2
Ending index 6```

Kadane’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.