Given two arrays, arr1[] of length m and arr2[] of length n, and an integer C. You can take any permutation of arr1[] and arr2[]. The task is to find the minimum cost by moving all elements from arr2[] to arr1[]. In each operation, remove arr2[0] and place it at the start of arr1[], and then move it to the right in arr1[] until it is smaller than the element to its right. Each swap is considered one operation and costs C.
Examples:
Input: m = 5, n = 3, C = 4, arr1[] = {10, 5, 2, 5, 4}, arr2[] = {3, 1, 2}
Output: 0
Explanation: One optimal permutation can be: arr1[]={10, 2, 5, 4, 5} and arr2[]={3, 2, 1}.
- => Remove arr2[0] = 3 and insert into arr1, after this arr1 = {3, 10, 2, 5, 4, 5}
- => Remove arr2[0] = 1 and insert into arr1, after this arr1 = {2, 3, 10, 2, 5, 4, 5}
- => Remove arr2[0] = 2 and insert into arr1, after this arr1 = {1, 2, 3, 10, 2, 5, 4, 5}
Hence, there is no swapping required during moving all elements of arr2[] to arr1[]
Input: m = 3, n = 2, C = 5, arr1[] = {5, 4, 3}, arr2[] = {1, 10}
Output: 15
Explanation: One optimal permutation can be: arr1[] = {5, 4, 3} and arr2[] = {1, 10}.
- => Remove arr2[0] = 1 and insert into arr1, after this arr1 = {1, 5, 4, 3}
- => Remove arr2[0] = 10 and insert into arr1, after this arr1 = {1, 5, 4, 10}. Three swaps are required here.
Hence, there is total 3 swapping required during moving all elements of arr2[] to arr1[]. So, total cost would be 5*3 = 15
Approach:
The optimal strategy is to sort arr1[] in descending order. This ensures that the largest element comes first, minimizing the need for swaps when smaller elements are inserted. For example, if arr1[] = {1, 10} and arr2[] = {3}, without sorting arr1[], arr2[0] = 3 would require one swap to reach its correct position, resulting in arr1[] = {1, 3, 10}. However, if arr1[] is sorted in descending order, no swaps are needed and arr1[] becomes {3, 10, 1}.
Similarly, arr2[] should also be sorted in descending order. As elements are removed from arr2[] in decreasing order and inserted into arr1[], having arr2[] in descending order helps avoid any additional swaps.
Steps-by-step approach:
- Sort arr1 and arr2 in descending order.
- Initialize operations to 0.
- Traverse through sorted arr2. If an element in arr2 is greater than the first element in arr1, increment operations by arr1.length (i.e, we have to put element of arr2 to the end of arr1).
- Calculate minimum cost by multiplying operations with the given cost.
- Print the calculated minimum cost.
Below is the code to implement the above approach:
C++
// Include necessary libraries
#include <bits/stdc++.h>
using namespace std;
// Function to calculate and print the minimum possible cost
void min_cost(long n, long m, vector<long> arr1,
vector<long> arr2, long cost)
{
// Sort arr1[] and arr2[] in descending order using the
// in-built sort function
sort(arr1.begin(), arr1.end(), greater<int>());
sort(arr2.begin(), arr2.end(), greater<int>());
// Initialize a variable to hold the number of minimum
// operations needed
long operations = 0;
// Traverse through arr2[]
for (int i = 0; i < arr2.size(); i++) {
// If the current element in arr2[] is greater than
// the first element in arr1[] increment the
// operations count by n
if (arr2[i] > arr1[0])
operations += arr1.size();
else
continue; // If not, continue to the next
// iteration
}
// Print the minimum cost by multiplying the number of
// operations with the cost per operation
cout << operations * cost << endl;
}
// Driver code.
int main()
{
// Define input variables
long m = 3;
long n = 2;
long cost = 5;
vector<long> arr1 = { 5, 4, 3 };
vector<long> arr2 = { 10, 1 };
// Call the function with the defined inputs
min_cost(n, m, arr1, arr2, cost);
}
Java
import java.util.*;
public class Main {
// Function to calculate and print the minimum possible
// cost
public static void min_cost(int n, int m,
ArrayList<Integer> arr1,
ArrayList<Integer> arr2,
int cost)
{
// Sort arr1[] and arr2[] in descending order using
// the in-built sort function
Collections.sort(arr1, Collections.reverseOrder());
Collections.sort(arr2, Collections.reverseOrder());
// Initialize a variable to hold the number of
// minimum operations needed
int operations = 0;
// Traverse through arr2[]
for (int i = 0; i < arr2.size(); i++) {
// If the current element in arr2[] is greater
// than the first element in arr1[] increment
// the operations count by n
if (arr2.get(i) > arr1.get(0))
operations += arr1.size();
else
continue; // If not, continue to the next
// iteration
}
// Print the minimum cost by multiplying the number
// of operations with the cost per operation
System.out.println(operations * cost);
}
public static void main(String[] args)
{
// Define input variables
int m = 3;
int n = 2;
int cost = 5;
ArrayList<Integer> arr1
= new ArrayList<>(Arrays.asList(5, 4, 3));
ArrayList<Integer> arr2
= new ArrayList<>(Arrays.asList(10, 1));
// Call the function with the defined inputs
min_cost(n, m, arr1, arr2, cost);
}
}
Python
def min_cost(n, m, arr1, arr2, cost):
# Sort arr1[] and arr2[] in descending order using the
# in-built sorted function
arr1.sort(reverse=True)
arr2.sort(reverse=True)
# Initialize a variable to hold the number of minimum
# operations needed
operations = 0
# Traverse through arr2[]
for i in range(len(arr2)):
# If the current element in arr2[] is greater than
# the first element in arr1[] increment the
# operations count by n
if arr2[i] > arr1[0]:
operations += len(arr1)
else:
continue # If not, continue to the next iteration
# Print the minimum cost by multiplying the number of
# operations with the cost per operation
print(operations * cost)
# Driver code.
if __name__ == "__main__":
# Define input variables
m = 3
n = 2
cost = 5
arr1 = [5, 4, 3]
arr2 = [10, 1]
# Call the function with the defined inputs
min_cost(n, m, arr1, arr2, cost)
C#
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
// Function to calculate and print the minimum possible cost
static void MinCost(long n, long m, List<long> arr1, List<long> arr2, long cost)
{
// Sort arr1[] and arr2[] in descending order
arr1.Sort((a, b) => b.CompareTo(a));
arr2.Sort((a, b) => b.CompareTo(a));
// Initialize a variable to hold the number of minimum operations needed
long operations = 0;
// Traverse through arr2[]
for (int i = 0; i < arr2.Count; i++)
{
// If the current element in arr2[] is greater than the first element in arr1[]
// Increment the operations count by n
if (arr2[i] > arr1[0])
operations += arr1.Count;
else
continue; // If not, continue to the next iteration
}
// Print the minimum cost by multiplying the number of operations with the cost per operation
Console.WriteLine(operations * cost);
}
// Driver code
static void Main()
{
// Define input variables
long m = 3;
long n = 2;
long cost = 5;
List<long> arr1 = new List<long> { 5, 4, 3 };
List<long> arr2 = new List<long> { 10, 1 };
// Call the function with the defined inputs
MinCost(n, m, arr1, arr2, cost);
}
}
Javascript
// Function to calculate and print the minimum possible cost
function min_cost(n, m, arr1, arr2, cost) {
// Sort arr1[] and arr2[] in descending order
arr1.sort((a, b) => b - a);
arr2.sort((a, b) => b - a);
// Initialize a variable to hold the number of minimum operations needed
let operations = 0;
// Traverse through arr2[]
for (let i = 0; i < arr2.length; i++) {
// If the current element in arr2[] is greater than the first element in arr1[]
// increment the operations count by n
if (arr2[i] > arr1[0]) {
operations += arr1.length;
}
}
// Print the minimum cost by multiplying the number of operations with the cost per operation
console.log(operations * cost);
}
// Define input variables
const m = 3;
const n = 2;
const cost = 5;
const arr1 = [5, 4, 3];
const arr2 = [10, 1];
// Call the function with the defined inputs
min_cost(n, m, arr1, arr2, cost);
Output
15
Time Complexity: O(max(n*log(n), m*log(m))
Auxiliary Space: O(1)