# Minimize cost to modify the Array such that even indices have even elements and vice versa

• Difficulty Level : Medium
• Last Updated : 28 Oct, 2021

Given an array arr[] of size N and two integers X and Y, the task is to find the minimum cost required to modify the array such that even indices have even elements and odd indices have odd elements on them, either by swapping two elements of the array with a cost of X or by incrementing or decrementing 1 from the element with a cost of Y.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {5, 3, 7, 2, 1}, X = 1, Y = 2
Output: 5
Explanation:
Following are the operations performed:
Operation 1: Swap the array elements at indices 0 and 3, modifies the array to {2, 3, 7, 5, 1}. The cost of this operations is X(= 1).
Operation 2: Incrementing the array elements at index 2, modifies the array to {2, 3, 8, 5, 1}. The cost of this operations is Y(= 2).
Operation 3: Incrementing the array elements at index 4, modifies the array to {2, 3, 8, 5, 2}. The cost of this operations is Y(= 2).
Therefore, the total cost is 1 + 2 + 2 = 5, which is minimum.

Input: arr[] = {1, 2, 3, 4}, X = 1, Y = 2
Output: 2

Approach: The given problem can be solved by using the following observations by first finding the count of elements that are wrongly placed at odd and even indices as oddCount and evenCount respectively:

• Case 1: The cost can be calculated by performing the swap operations on a minimum of oddCount and evenCount at a cost of X and performing the decrementing operation on the remaining elements at a cost of Y.
• Case 2: The cost can be calculated by performing the decrementing operation on the remaining elements at a cost of Y.

The minimum of the costs obtained in the above two cases is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum cost to``// modify the array according to the``// given criteria``int` `minimumCost(``int` `arr[], ``int` `N,``                ``int` `X, ``int` `Y)``{``    ``// Count of wrong positioned odd``    ``// and even elements``    ``int` `even_count = 0, odd_count = 0;``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Odd Count``        ``if` `((arr[i] & 1)``            ``&& (i % 2 == 0)) {``            ``odd_count++;``        ``}` `        ``// Even Count``        ``if` `((arr[i] % 2) == 0``            ``&& (i & 1)) {``            ``even_count++;``        ``}``    ``}` `    ``// Cost for Case 1` `    ``// Swapping Cost``    ``int` `cost1 = X * min(odd_count, even_count);` `    ``// Decrementing cost after swapping``    ``int` `cost2 = Y``                ``* (max(odd_count, even_count)``                   ``- min(odd_count, even_count));` `    ``// Cost for Case 2` `    ``// Only decrementing cost``    ``int` `cost3 = (odd_count + even_count) * Y;` `    ``// Return the minimum cost of the``    ``// two cases``    ``return` `min(cost1 + cost2, cost3);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 3, 7, 2, 1 }, X = 10, Y = 2;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << minimumCost(arr, N, X, Y);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG {` `    ``// Function to find the minimum cost to``    ``// modify the array according to the``    ``// given criteria``    ``public` `static` `int` `minimumCost(``int` `arr[], ``int` `N, ``int` `X, ``int` `Y)``    ``{``      ` `        ``// Count of wrong positioned odd``        ``// and even elements``        ``int` `even_count = ``0``, odd_count = ``0``;``        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``// Odd Count``            ``if` `((arr[i] & ``1``) > ``0` `&& (i % ``2` `== ``0``)) {``                ``odd_count++;``            ``}` `            ``// Even Count``            ``if` `((arr[i] % ``2``) == ``0` `&& (i & ``1``) > ``0``) {``                ``even_count++;``            ``}``        ``}` `        ``// Cost for Case 1` `        ``// Swapping Cost``        ``int` `cost1 = X * Math.min(odd_count, even_count);` `        ``// Decrementing cost after swapping``        ``int` `cost2 = Y * (Math.max(odd_count, even_count) - Math.min(odd_count, even_count));` `        ``// Cost for Case 2` `        ``// Only decrementing cost``        ``int` `cost3 = (odd_count + even_count) * Y;` `        ``// Return the minimum cost of the``        ``// two cases``        ``return` `Math.min(cost1 + cost2, cost3);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``5``, ``3``, ``7``, ``2``, ``1` `}, X = ``10``, Y = ``2``;``        ``int` `N = arr.length;``        ``System.out.println(minimumCost(arr, N, X, Y));``    ``}``}` `// This code is contributed by gfgking.`

## Python3

 `# python program for the above approach` `# Function to find the minimum cost to``# modify the array according to the``# given criteria``def` `minimumCost(arr, N, X, Y):` `        ``# Count of wrong positioned odd``        ``# and even elements``    ``even_count ``=` `0``    ``odd_count ``=` `0``    ``for` `i ``in` `range``(``0``, N):` `                ``# Odd Count``        ``if` `((arr[i] & ``1``) ``and` `(i ``%` `2` `=``=` `0``)):``            ``odd_count ``+``=` `1` `            ``# Even Count``        ``if` `((arr[i] ``%` `2``) ``=``=` `0` `and` `(i & ``1``)):``            ``even_count ``+``=` `1` `        ``# Cost for Case 1` `        ``# Swapping Cost``    ``cost1 ``=` `X ``*` `min``(odd_count, even_count)` `    ``# Decrementing cost after swapping``    ``cost2 ``=` `Y ``*` `(``max``(odd_count, even_count) ``-` `min``(odd_count, even_count))` `    ``# Cost for Case 2` `    ``# Only decrementing cost``    ``cost3 ``=` `(odd_count ``+` `even_count) ``*` `Y` `    ``# Return the minimum cost of the``    ``# two cases``    ``return` `min``(cost1 ``+` `cost2, cost3)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``5``, ``3``, ``7``, ``2``, ``1``]``    ``X ``=` `10``    ``Y ``=` `2``    ``N ``=` `len``(arr)``    ``print``(minimumCost(arr, N, X, Y))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG {` `    ``// Function to find the minimum cost to``    ``// modify the array according to the``    ``// given criteria``    ``public` `static` `int` `minimumCost(``int` `[]arr, ``int` `N, ``int` `X, ``int` `Y)``    ``{``      ` `        ``// Count of wrong positioned odd``        ``// and even elements``        ``int` `even_count = 0, odd_count = 0;``        ``for` `(``int` `i = 0; i < N; i++) {` `            ``// Odd Count``            ``if` `((arr[i] & 1) > 0 && (i % 2 == 0)) {``                ``odd_count++;``            ``}` `            ``// Even Count``            ``if` `((arr[i] % 2) == 0 && (i & 1) > 0) {``                ``even_count++;``            ``}``        ``}` `        ``// Cost for Case 1` `        ``// Swapping Cost``        ``int` `cost1 = X * Math.Min(odd_count, even_count);` `        ``// Decrementing cost after swapping``        ``int` `cost2 = Y * (Math.Max(odd_count, even_count) - Math.Min(odd_count, even_count));` `        ``// Cost for Case 2` `        ``// Only decrementing cost``        ``int` `cost3 = (odd_count + even_count) * Y;` `        ``// Return the minimum cost of the``        ``// two cases``        ``return` `Math.Min(cost1 + cost2, cost3);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string` `[]args)``    ``{``        ``int` `[]arr= { 5, 3, 7, 2, 1 };``        ``int` `X = 10, Y = 2;``        ``int` `N = arr.Length;``        ``Console.WriteLine(minimumCost(arr, N, X, Y));``    ``}``}` `// This code is contributed by rutvik_56.`

## Javascript

 ``
Output:
`8`

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

My Personal Notes arrow_drop_up