Split an Array to maximize subarrays having equal count of odd and even elements for a cost not exceeding K

Given an array arr[] of size N and an integer K, the task is to split the given array into maximum possible subarrays having equal count of even and odd elements such that the cost to split the array does not exceed K.

The cost to split an array into a subarray is the difference between the last and first elements of the subarrays respectively.

Examples:

Input: arr[] = {1, 2, 5, 10, 15, 20}, K = 4 
Output: 1 
Explanation:
The optimal way is to split the array between 2 and 5. 
So it splits into {1, 2} and {5, 10, 15, 20}. 
Also, both the subarrays contain an equal number of even and odd elements. The cost of the split is abs(2 – 5) = 3 which is ? K.
Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 100 
Output: 2 
Explanation:
The optimal way is to make two splits such that the subarrays formed are {1, 2}, {3, 4}, {5, 6}. 
The total cost is abs(2 – 3) + abs(4 – 5) = 2

Naive Approach: The simplest approach to solve this problem is as follows:

1. Split the array at every index and check if the cost is less than K or not.
2. If the cost is less than K, then check if the number of odd and even elements in the subarray are equal or not.
3. Now check if another split is possible or not by repeating the same steps.
4. After checking all possible splits, print the minimum cost which add up to a sum less than K.

Time Complexity: O(N²) 
Auxiliary Space: O(1)
Efficient Approach: The idea is to maintain the counters which store the number of even numbers and odd numbers in the array. Below are the steps:

1. Initialize an array (say poss[]) which stores the cost of all possible splits.
2. Traverse through the array arr[]. For every index, check if the subarray up to this index and the subarray starting from the next index has equal count of odd and even elements.
3. If the above condition satisfies, then a split is possible. Store the cost associated with this split in poss[].
4. Repeat the above steps for all the elements in the array and store the costs of every split.
5. Cost of split at index i can be obtained by abs(arr[i + 1] – arr[i]).
6. Now, in order to find the maximum number of possible splits, sort the array poss[] that contains the costs of each possible split.
7. Now select all minimum costs from poss[] whose sum is less than or equal to K.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the cost of
// splitting the arrays into subarray
// with cost less than K
int make_cuts(int arr[], int n, int K)
{
    // Store the possible splits
    int ans = 0;

    // Stores the cost of each split
    vector<int> poss;

    // Stores the count of even numbers
    int ce = 0;

    // Stores the count
    // of odd numbers
    int co = 0;

    for (int x = 0; x < n - 1; x++) {

        // Count of odd & even elements
        if (arr[x] % 2 == 0)
            ce++;
        else
            co++;

        // Check the required conditions
        // for a valid split
        if (ce == co && co > 0
            && ce > 0) {
            poss.push_back(
                abs(arr[x]
                    - arr[x + 1]));
        }
    }

    // Sort the cost of splits
    sort(poss.begin(), poss.end());

    // Find the minimum split costs
    // adding up to sum less than K
    for (int x : poss) {
        if (K >= x) {
            ans++;
            K -= x;
        }
        else
            break;
    }
    return ans;
}

// Driver Code
int main()
{
    // Given array and K
    int N = 6;
    int K = 4;

    int arr[] = { 1, 2, 5, 10, 15, 20 };

    // Function Call
    cout << make_cuts(arr, N, K);
}

Java

// Java program for the above approach
import java.util.*;

class GFG{

// Function to find the cost of
// splitting the arrays into subarray
// with cost less than K
static int make_cuts(int arr[], int n, int K)
{

    // Store the possible splits
    int ans = 0;

    // Stores the cost of each split
    Vector<Integer> poss = new Vector<Integer>();

    // Stores the count of even numbers
    int ce = 0;

    // Stores the count
    // of odd numbers
    int co = 0;

    for(int x = 0; x < n - 1; x++)
    {

        // Count of odd & even elements
        if (arr[x] % 2 == 0)
            ce++;
        else
            co++;

        // Check the required conditions
        // for a valid split
        if (ce == co && co > 0 && ce > 0)
        {
            poss.add(Math.abs(arr[x] -
                              arr[x + 1]));
        }
    }

    // Sort the cost of splits
    Collections.sort(poss);

    // Find the minimum split costs
    // adding up to sum less than K
    for(int x : poss)
    {
        if (K >= x)
        {
            ans++;
            K -= x;
        }
        else
            break;
    }
    return ans;
}

// Driver Code
public static void main(String[] args)
{

    // Given array and K
    int N = 6;
    int K = 4;

    int arr[] = { 1, 2, 5, 10, 15, 20 };

    // Function call
    System.out.print(make_cuts(arr, N, K));
}
}

// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach

# Function to find the cost of
# splitting the arrays into subarray
# with cost less than K
def make_cuts(arr, n, K):

    # Store the possible splits
    ans = 0

    # Stores the cost of each split
    poss = []

    # Stores the count of even numbers
    ce = 0

    # Stores the count
    # of odd numbers
    co = 0

    for x in range(n - 1):

        # Count of odd & even elements
        if(arr[x] % 2 == 0):
            ce += 1
        else:
            co += 1

        # Check the required conditions
        # for a valid split
        if(ce == co and co > 0 and ce > 0):
            poss.append(abs(arr[x] -
                            arr[x + 1]))

    # Sort the cost of splits
    poss.sort()

    # Find the minimum split costs
    # adding up to sum less than K
    for x in poss:
        if (K >= x):
            ans += 1
            K -= x
        else:
            break

    return ans

# Driver Code

# Given array and K
N = 6
K = 4

arr = [ 1, 2, 5, 10, 15, 20 ]

# Function call
print(make_cuts(arr, N, K))

# This code is contributed by Shivam Singh

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find the cost of
// splitting the arrays into subarray
// with cost less than K
static int make_cuts(int []arr, int n, int K)
{

    // Store the possible splits
    int ans = 0;

    // Stores the cost of each split
    List<int> poss = new List<int>();

    // Stores the count of even numbers
    int ce = 0;

    // Stores the count
    // of odd numbers
    int co = 0;

    for(int x = 0; x < n - 1; x++)
    {

        // Count of odd & even elements
        if (arr[x] % 2 == 0)
            ce++;
        else
            co++;

        // Check the required conditions
        // for a valid split
        if (ce == co && co > 0 && ce > 0)
        {
            poss.Add(Math.Abs(arr[x] -
                              arr[x + 1]));
        }
    }

    // Sort the cost of splits
    poss.Sort();

    // Find the minimum split costs
    // adding up to sum less than K
    foreach(int x in poss)
    {
        if (K >= x)
        {
            ans++;
            K -= x;
        }
        else
            break;
    }
    return ans;
}

// Driver Code
public static void Main(String[] args)
{

    // Given array and K
    int N = 6;
    int K = 4;

    int []arr = { 1, 2, 5, 10, 15, 20 };

    // Function call
    Console.Write(make_cuts(arr, N, K));
}
}

// This code is contributed by Amit Katiyar

Javascript

<script>

// Javascript program for the above approach

// Function to find the cost of
// splitting the arrays into subarray
// with cost less than K

function make_cuts(arr, n, K)
{
    // Store the possible splits
    var ans = 0;

    // Stores the cost of each split
    var poss = [];

    // Stores the count of even numbers
    var ce = 0;

    // Stores the count
    // of odd numbers
    var co = 0;
    var x;
    for (x = 0; x < n - 1; x++) {

        // Count of odd & even elements
        if (arr[x] % 2 == 0)
            ce++;
        else
            co++;

        // Check the required conditions
        // for a valid split
        if (ce == co && co > 0
            && ce > 0) {
            poss.push(
                Math.abs(arr[x]
                    - arr[x + 1]));
        }
    }

    // Sort the cost of splits
    poss.sort();

    var i;
    // Find the minimum split costs
    // adding up to sum less than K
    for(i=0;i<poss.length;i++){
        if (K >= poss[i]) {
            ans++;
            K -= poss[i];
        }
         else
            break;
    }
    return ans;
}

// Driver Code

    // Given array and K
    var N = 6;
    var K = 4;

    var arr = [1, 2, 5, 10, 15, 20];

    // Function Call
    document.write(make_cuts(arr, N, K));

// This code is contributed by bgangwar59.
</script>

Output:

1

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