Related Articles

Related Articles

Minimum cost required to move all elements to the same position
  • Last Updated : 11 Dec, 2020

Given an array position[] consisting of N integers where position[i] denotes the position of the ith element, the task is to find the minimum cost required to move all the elements to the same position by performing either of the following two operations:

  • Move form position[i] to position[i] + 2 or position[i] – 2. Cost = 0.
  • Move form position[i] to position[i] + 1 or position[i] – 1. Cost = 1.

Examples:

Input: position[] = {1, 2, 3}
Output: 1
Explanation: 
Operation 1: Move the element at position 3 to position 1. Cost = 0. 
Operation 2: Move the element at position 2 to position 1. Cost = 1. 
Therefore, total cost = 1.

Input: position[] = {2, 2, 2, 3, 3}
Output: 2
Explanation: Move the two elements at position 3 to position 2. Cost of each operation = 1. Therefore, total cost = 2.

Approach: The idea is to traverse the array and count the number of odd and even elements. For each operation involving increment or decrement by two indices, the cost will always be 0. The cost changes only on moving an element from odd to even position or vice-versa. Therefore, the minimum cost required is the minimum of the count of odd and even elements present in the array position[].



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <iostream>
using namespace std;
 
// Function to find the minimum
// cost required to place all
// elements in the same position
int minCost(int arr[], int arr_size)
{
     
    // Stores the count of even
    // and odd elements
    int odd = 0, even = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < arr_size; i++)
    {
         
        // Count even elements
        if (arr[i] % 2 == 0)
            even++;
             
        // Count odd elements
        else
            odd++;
    }
     
    // Print the minimum count
    cout << min(even, odd);
}
 
// Driver Code
int main()
{
     
    // Given array
    int arr[] = { 1, 2, 3 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
     
    // Function Call
    minCost(arr, arr_size);
}
 
// This code is contributed by khushboogoyal499

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
 
import java.io.*;
class GFG {
 
    // Function to find the minimum
    // cost required to place all
    // elements in the same position
    public void minCost(int[] arr)
    {
        // Stores the count of even
        // and odd elements
        int odd = 0, even = 0;
 
        // Traverse the array arr[]
        for (int i = 0;
             i < arr.length;  i++) {
 
            // Count even elements
            if (arr[i] % 2 == 0)
                even++;
 
            // Count odd elements
            else
                odd++;
        }
 
        // Print the minimum count
        System.out.print(
            Math.min(even, odd));
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        GFG obj = new GFG();
 
        // Given array
        int arr[] = { 1, 2, 3 };
 
        // Function Call
        obj.minCost(arr);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to find the minimum
# cost required to place all
# elements in the same position
def minCost(arr):
     
    # Stores the count of even
    # and odd elements
    odd = 0
    even = 0
 
    # Traverse the array arr[]
    for i in range(len(arr)):
         
        # Count even elements
        if (arr[i] % 2 == 0):
            even += 1
             
        # Count odd elements
        else:
            odd += 1
 
    # Print the minimum count
    print(min(even, odd))
 
# Driver Code
if __name__ == '__main__':
     
    # Given array
    arr = [ 1, 2, 3 ]
 
    # Function Call
    minCost(arr)
 
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach 
using System;
  
class GFG{
  
// Function to find the minimum
// cost required to place all
// elements in the same position
public void minCost(int[] arr)
{
     
    // Stores the count of even
    // and odd elements
    int odd = 0, even = 0;
 
    // Traverse the array arr[]
    for(int i = 0; i < arr.Length; i++)
    {
         
        // Count even elements
        if (arr[i] % 2 == 0)
            even++;
             
        // Count odd elements
        else
            odd++;
    }
     
    // Print the minimum count
    Console.Write(Math.Min(even, odd));
}
 
// Driver Code
public static void Main()
{
    GFG obj = new GFG();
     
    // Given array
    int[] arr = { 1, 2, 3 };
     
    // Function Call
    obj.minCost(arr);
}
}
 
// This code is contributed by sanjoy_62

chevron_right


Output: 

1

 

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

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :