Maximum Subarray Sum of Alternate Parity (original) (raw)

Last Updated : 18 Jan, 2024

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));

`

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