Maximum Subarray Sum of Alternate Parity

Given array A[] of size N. The Task for this problem is to find the maximum subarray (Subarrays are arrays within another array. Subarrays contain contiguous elements) sum such that adjacent elements of the subarray should have different parity.

Examples:

Input: A[] = {-1, 4, -1, 0, 5, -4}
Output: 8
Explanation: Subarray {4, -1, 0, 5} has maximum sum with consecutive elements has alternate parity (4 is even, -1 is odd, 0 is even, 5 is odd)

Input: A[] = {-1, 2, 4, -3}
Output: 4
Explanation: Subarray {4} has maximum sum.

Approach: To solve the problem efficiently follow the below idea:

Kadane’s Algorithm can be used to solve this problem, small change is that whenever our parity is not same we start new subarray with that point. Using this we can calculate maximum subarray sum with alternate parity with required subarray.

Below are the steps for the above approach:

• Initialize the variable curSum = A[0]
• Initialize the maximumSum = 0 that keeps track of the maximum subarray sum with alternate parity.
• Iterate over N elements
  • If the parity is the same then update curSum with A[i]
  • else if the current sum is negative then update curSum with A[i]
  • else add A[i] in curSum
• in each iteration update maximumSum with curSum.

Below is the implementation of the above approach:

C++

// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to Find Maximum subarray sum with
// alternate parity
int findMaxSubarraySum(int A[], int N)
{

    // for tracking current sum
    int curSum = A[0];

    // for tracking max subarray sum
    int maximumSum = 0;

    // iterating over all N elements
    for (int i = 1; i < N; i++) {

        // if adjacent elements have different parity
        if (A[i] % 2 != A[i - 1] % 2) {

            // if curSum with A[i] is greater than
            // A[i] alone extend the solution by updating
            // curSum with addtion of A[i]
            if (curSum + A[i] > A[i]) {

                // adding A[i] in curSum
                curSum += A[i];
            }

            // in case if curSum is negative
            else {
                curSum = A[i];
            }
        }
        else {

            // update curSum
            curSum = A[i];
        }

        // updating maximumsum
        maximumSum = max(maximumSum, curSum);
    }

    // returning maximum subarray sum
    return maximumSum;
}

// Driver Code
int32_t main()
{

    // Input 1
    int N = 6;
    int A[] = { -1, 4, -1, 0, 5, -4 };

    // Function Call
    cout << findMaxSubarraySum(A, N) << endl;

    // Input 2
    int N1 = 4;
    int A1[] = { -1, 2, 4, -3 };

    // Function Call
    cout << findMaxSubarraySum(A1, N1) << endl;

    return 0;
}

Java

public class Main {

    // Function to find maximum subarray sum with alternate parity
    static int findMaxSubarraySum(int[] A, int N) {
        // for tracking current sum
        int curSum = A[0];

        // for tracking max subarray sum
        int maximumSum = 0;

        // iterating over all N elements
        for (int i = 1; i < N; i++) {
            // if adjacent elements have different parity
            if (A[i] % 2 != A[i - 1] % 2) {
                // if curSum with A[i] is greater than A[i] alone
                // extend the solution by updating curSum with addition of A[i]
                if (curSum + A[i] > A[i]) {
                    // adding A[i] in curSum
                    curSum += A[i];
                } else {
                    // in case if curSum is negative
                    curSum = A[i];
                }
            } else {
                // update curSum
                curSum = A[i];
            }

            // updating maximum sum
            maximumSum = Math.max(maximumSum, curSum);
        }

        // returning maximum subarray sum
        return maximumSum;
    }

    // Driver Code
    public static void main(String[] args) {
        // Input 1
        int N = 6;
        int[] A = { -1, 4, -1, 0, 5, -4 };

        // Function Call
        System.out.println(findMaxSubarraySum(A, N));

        // Input 2
        int N1 = 4;
        int[] A1 = { -1, 2, 4, -3 };

        // Function Call
        System.out.println(findMaxSubarraySum(A1, N1));
    }
}

Python3

def find_max_subarray_sum(arr, N):
    # For tracking current sum
    cur_sum = arr[0]

    # For tracking max subarray sum
    maximum_sum = 0

    # Iterating over all N elements
    for i in range(1, N):
        # If adjacent elements have different parity
        if arr[i] % 2 != arr[i - 1] % 2:
            # If cur_sum with arr[i] is greater than arr[i] alone,
            # extend the solution by updating cur_sum with addition of arr[i]
            if cur_sum + arr[i] > arr[i]:
                # Adding arr[i] to cur_sum
                cur_sum += arr[i]
            # In case if cur_sum is negative
            else:
                cur_sum = arr[i]
        else:
            # Update cur_sum
            cur_sum = arr[i]

        # Updating maximum_sum
        maximum_sum = max(maximum_sum, cur_sum)

    # Returning maximum subarray sum
    return maximum_sum


# Driver Code
if __name__ == "__main__":
    # Input 1
    N = 6
    A = [-1, 4, -1, 0, 5, -4]

    # Function Call
    print(find_max_subarray_sum(A, N))

    # Input 2
    N1 = 4
    A1 = [-1, 2, 4, -3]

    # Function Call
    print(find_max_subarray_sum(A1, N1))

C#

// C# code to implement the approach
using System;

class GFG
{
    // Function to Find Maximum subarray sum with alternate parity
    static int FindMaxSubarraySum(int[] A, int N)
    {
        // for tracking current sum
        int curSum = A[0];

        // for tracking max subarray sum
        int maximumSum = 0;

        // iterating over all N elements
        for (int i = 1; i < N; i++)
        {
            // if adjacent elements have different parity
            if (A[i] % 2 != A[i - 1] % 2)
            {
                // if curSum with A[i] is greater than
                // A[i] alone extend the solution by updating
                // curSum with addtion of A[i]
                if (curSum + A[i] > A[i])
                {
                    // adding A[i] in curSum
                    curSum += A[i];
                }
                // in case if curSum is negative
                else
                {
                    curSum = A[i];
                }
            }
            else
            {
                // update curSum
                curSum = A[i];
            }

            // updating maximumsum
            maximumSum = Math.Max(maximumSum, curSum);
        }

        // returning maximum subarray sum
        return maximumSum;
    }

    // Driver Code
    static void Main(string[] args)
    {
        // Input 1
        int N = 6;
        int[] A = { -1, 4, -1, 0, 5, -4 };

        // Function Call
        Console.WriteLine(FindMaxSubarraySum(A, N));

        // Input 2
        int N1 = 4;
        int[] A1 = { -1, 2, 4, -3 };

        // Function Call
        Console.WriteLine(FindMaxSubarraySum(A1, N1));
    }
}

Javascript

// Function to find maximum subarray
// sum with alternate parity
function findMaxSubarraySum(A, N) {
    // For tracking current sum
    let curSum = A[0];

    // For tracking max subarray sum
    let maximumSum = 0;

    // Iterating over all N elements
    for (let i = 1; i < N; i++) {
        // If adjacent elements have different parity
        if (A[i] % 2 !== A[i - 1] % 2) {
            // If curSum with A[i] is greater than A[i] alone,
            // extend the solution by updating
            // curSum with addition of A[i]
            if (curSum + A[i] > A[i]) {
                // Adding A[i] to curSum
                curSum += A[i];
            } else {
                // In case if curSum is negative
                curSum = A[i];
            }
        } else {
            // Update curSum
            curSum = A[i];
        }

        // Updating maximumsum
        maximumSum = Math.max(maximumSum, curSum);
    }

    // Returning maximum subarray sum
    return maximumSum;
}

// Driver Code

// Input 1
const N = 6;
const A = [-1, 4, -1, 0, 5, -4];

// Function Call
console.log(findMaxSubarraySum(A, N));

// Input 2
const N1 = 4;
const A1 = [-1, 2, 4, -3];

// Function Call
console.log(findMaxSubarraySum(A1, N1));

Output

8
4

Time Complexity: O(N)
Auxiliary Space: O(1)