Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize cost to sort given array by sorting unsorted subarrays

  • Last Updated : 19 Jan, 2022

Given an array arr[] of size N, the task is to minimize the  cost to sort the array by sorting any unsorted subarray where the cost of the operation is the difference between the maximum and minimum element of that subarray. This operation can be performed infinite times including 0.

Examples:

Input: arr[] = {1, 7, 5, 2, 1, 8}
Output: 6
Explanation: The subarray from index [1,4] can be chosen and can be sorted with cost = 7 – 1 = 6

Input: arr[] = { 1, 4, 3, 5, 6 ,13, 10}
Output: 4
Explanation: The subarray from index index [1,2] and [5,6] can be sorted with cost of  4 – 3 and 13 – 10 = 1 + 3 = 4

 

Approach: This can be solved using the greedy approach, the elements already sorted don’t require any cost so only the subarrays that have unsorted elements must be considered to sort. Multiset can be used to store the elements that are not in sorted order and the difference between the last and first element of multiset gives the cost.

Follow these steps to solve the above problem:

  • Initialize a vector v and copy the arr into it and assign the size of the vector to the variable n.
  • Now sort the vector v.
  • Initialize 2 multisets m1 and m2 to store the unsorted and sorted subarray respectively and cost = 0  to store the result.
  • Now iterate through the range [0,N) and check
  • If v[i] is not equal to arr[i] 
  • Insert arr[i] into m1 and v[i] into m2
  • When both the multisets are the same add the difference between the last and first element of the set to the cost.
  • Clear both the multisets to make them used by the next unsorted subarray.
  • Print the cost.

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 minimum cost
// to sort the array in ascending order
int minimum_cost(vector<int> arr)
{
    // Copy the arr into vector and sort it
    vector<int> sorted = arr;
    int n = arr.size();
    sort(sorted.begin(), sorted.end());
 
    // Initialize the two multisets to store
    // sorted and the unordered elements
    multiset<int> m1, m2;
 
    // Initialize cost to store final answer
    int cost = 0;
 
    for (int i = 0; i < n; i++) {
        if (sorted[i] != arr[i]) {
            m1.insert(arr[i]);
            m2.insert(sorted[i]);
 
            // If both the multisets are equal,
            // the unordered subarray is sorted
            if (m1 == m2) {
                // The cost is difference
                // between mini and max
                cost += (*m1.rbegin() -
                         *m2.begin());
 
                // Clear the multisets to make
                // use of it again
                m1.clear();
                m2.clear();
            }
        }
    }
    return cost;
}
 
// Driver code
int main()
{
    // Initialize the queries
    vector<int> arr = { 1, 7, 5, 2, 1, 8 };
    cout << minimum_cost(arr);
 
    return 0;
}
Java



// Java code to implement the above approach
import java.util.*;
 
class GFG {
 
  // Function to find the minimum cost
  // to sort the array in ascending order
  public static int minimum_cost(int[] arr)
  {
 
    // Copy the arr into vector and sort it
    int n = arr.length;
    int[] sorted = new int[n];
    sorted = arr.clone();
    Arrays.sort(sorted);
 
    // Initialize the two multisets to store
    // sorted and the unordered elements
    SortedSet<Integer> m1 = new TreeSet<Integer>();
    SortedSet<Integer> m2 = new TreeSet<Integer>();
 
    // Initialize cost to store final answer
    int cost = 0;
 
    for (int i = 0; i < n; i++) {
      if (sorted[i] != arr[i]) {
        m1.add(arr[i]);
        m2.add(sorted[i]);
 
        // If both the multisets are equal,
        // the unordered subarray is sorted
        if (m1.equals(m2))
        {
 
          // The cost is difference
          // between mini and max
          cost += (Collections.max(m1) - Collections.min(m2));
 
          // Clear the multisets to make
          // use of it again
          m1.clear();
          m2.clear();
        }
      }
    }
    return cost;
  }
 
  // Driver code
  public static void main (String[] args)
  {
     
    // Initialize the queries
    int[] arr = { 1, 7, 5, 2, 1, 8 };
    System.out.println(minimum_cost(arr));
 
  }
}
 
// This code is contributed by Shubham Singh
Python3



# python3 program for the above approach
 
# Function to find the minimum cost
# to sort the array in ascending order
def minimum_cost(arr):
 
    # Copy the arr into vector and sort it
    sorted = arr.copy()
    n = len(arr)
    sorted.sort()
 
    # Initialize the two multisets to store
    # sorted and the unordered elements
    m1 = set()
    m2 = set()
 
    # Initialize cost to store final answer
    cost = 0
 
    for i in range(0, n):
        if (sorted[i] != arr[i]):
            m1.add(arr[i])
            m2.add(sorted[i])
 
            # If both the multisets are equal,
            # the unordered subarray is sorted
            if (m1 == m2):
                # The cost is difference
                # between mini and max
                cost += (list(m1)[len(list(m1)) - 1] -
                         list(m2)[0])
 
                # Clear the multisets to make
                # use of it again
                m1.clear()
                m2.clear()
 
    return cost
 
# Driver code
if __name__ == "__main__":
 
    # Initialize the queries
    arr = [1, 7, 5, 2, 1, 8]
    print(minimum_cost(arr))
 
    # This code is contributed by rakeshsahni
C#



// C# code to implement the above approach
using System;
using System.Collections.Generic;
 
public class GFG{
 
  // Function to find the minimum cost
  // to sort the array in ascending order
  public static int minimum_cost(int[] arr)
  {
 
    // Copy the arr into vector and sort it
    int n = arr.Length;
    int[] sorted = new int[n];
    Array.Copy(arr, 0, sorted, 0, n);
    Array.Sort(sorted);
 
    // Initialize the two multisets to store
    // sorted and the unordered elements
    SortedSet<int> m1 = new SortedSet<int>();
    SortedSet<int> m2 = new SortedSet<int>();
 
    // Initialize cost to store final answer
    int cost = 0;
 
    for (int i = 0; i < n; i++) {
      if (sorted[i] != arr[i]) {
        m1.Add(arr[i]);
        m2.Add(sorted[i]);
 
        // If both the multisets are equal,
        // the unordered subarray is sorted
        if (m1.SetEquals(m2))
        {
 
          // The cost is difference
          // between mini and max
          cost += (m1.Max - m2.Min);
 
          // Clear the multisets to make
          // use of it again
          m1.Clear();
          m2.Clear();
        }
      }
    }
    return cost;
  }
 
  // Driver code
  public static void Main()
  {
    // Initialize the queries
    int[] arr = { 1, 7, 5, 2, 1, 8 };
    Console.Write(minimum_cost(arr));
 
  }
}
 
// This code is contributed by Shubham Singh
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to find the minimum cost
// to sort the array in ascending order
function minimum_cost(arr)
{
    // Copy the arr into vector and sort it
    var sorted = arr.slice();
    var n = arr.length;
    sorted.sort();
 
    // Initialize the two multisets to store
    // sorted and the unordered elements
    var m1 = new Set();
    var m2 = new Set();
 
    // Initialize cost to store final answer
    var cost = 0;
     
    let areSetsEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value));
     
    for (var i = 0; i < n; i++) {
        if (sorted[i] != arr[i]) {
            m1.add(arr[i]);
            m2.add(sorted[i]);
 
            // If both the multisets are equal,
            // the unordered subarray is sorted
            if (areSetsEqual(m1,m2)) {
                // The cost is difference
                // between mini and max
                cost += (Math.max(...Array.from(m1.values())) -
                         Math.min(...Array.from(m2.values())));
 
                // Clear the multisets to make
                // use of it again
                m1.clear();
                m2.clear();
            }
        }
    }
    return cost;
}
 
// Driver code
// Initialize the queries
var arr = [ 1, 7, 5, 2, 1, 8 ];
document.write(minimum_cost(arr));
 
// This code is contributed by Shubham Singh
</script>
 
 
Output
6
 
Time Complexity: O(N * logN ) 
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Previous
Minimum operations to make Array sum at most S from given Array
Next

Minimum number of deletions from front and back of given Array to make count of 0 and 1 equal
Recommended Articles
Page :
Minimize cost to sort an Array by swapping any pair of element (X, Y) with cost as (X + Y)
20, Jul 21
Minimize cost to sort the Array by moving elements with cost as the value itself
29, Sep 21
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost
26, Jan 22
Minimize cost to traverse the Arrays with given Array switching cost
27, Apr 22
Minimize cost to travel from source to destination in a Matrix based on given row change and column change cost
27, Dec 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Find the Minimum length Unsorted Subarray, sorting which makes the complete array sorted
06, Dec 10
Minimize cost to connect the graph by connecting any pairs of vertices having cost at least 0
27, Sep 21
Merging and Sorting Two Unsorted Stacks
20, May 18
Sorting by combining Insertion Sort and Merge Sort algorithms
10, Nov 21
Minimize Cost to sort a String in Increasing Order of Frequencies of Characters
23, Jul 20
Minimize cost to reach the end of given Binary Array using jump of K length after performing given operations
27, Oct 21
Minimize cost to make given Array a permutation of 1 to N by given replacements
31, Jan 22
Minimize cost of choosing and skipping array elements to reach end of the given array
25, Oct 20
Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
03, Sep 21
Minimum cost to complete given tasks if cost of 1, 7 and 30 days are given
09, Jul 21
Sort an array having first N elements sorted and last M elements are unsorted
15, Jun 21
Minimum cost to convert all elements of a K-size subarray to 0 from given Ternary Array with subarray sum as cost
05, Jul 21
Know Your Sorting Algorithm | Set 2 (Introsort- C++’s Sorting Weapon)
26, Jun 16
Sorting objects using In-Place sorting algorithm
29, Oct 19
Know Your Sorting Algorithm | Set 1 (Sorting Weapons used by Programming Languages)
26, Jun 16
Sort the given Array after sorting each number individually
05, Dec 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
lokeshpotta20
@lokeshpotta20
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!