Given an array arr[] of N unique integers, the task is to find the cost to arrange them in a circular arrangement in such a way that every element is less than or equal to the sum of its adjacent elements.
Cost of moving an element from index i in original array to index j in final arrangement is |i – j|
In case such an arrangement is not possible, then print -1.
Examples:
Input: arr[] = {2, 4, 5, 1, 3}
Output: 10
Explanation:
One of the possible arrangement is {1, 2, 3, 4, 5}
For index 1, 1 ? 4 + 2, cost = 4 – 1 = 3
For index 2, 2 ? 1 + 3, cost = 3 + (2 – 1) = 4
For index 3, 3 ? 2 + 4, cost = 4 + (5 – 3) = 6
For index 4, 4 ? 3 + 4, cost = 6 + (4 – 2) = 8
For index 5, 5 ? 4 + 1, cost = 8 + (5 – 3) = 10
Input: arr[] = {1, 10, 100, 1000}
Output: -1
Approach: The problem can be solved using a Greedy Approach. The idea is to store the original index of the elements in a hashmap and then sort the array. Now check if the given condition is satisfied or not. If found to be true, then calculate the cost by adding up the difference between the current and previous indices. Otherwise, print -1.
Below is the implementation of the above approach:
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to check if given elements // can be arranged such that sum of // its neighbours is strictly greater void Arrange( int arr[], int n)
{ // Initialize the total cost
int cost = 0;
// Storing the original index of
// elements in a hashmap
unordered_map< int , int > index;
for ( int i = 0; i < n; i++) {
index[arr[i]] = i;
}
// Sort the given array
sort(arr, arr + n);
// Check if a given condition
// is satisfies or not
for ( int i = 0; i < n; i++) {
// First number
if (i == 0) {
if (arr[i] > arr[i + 1]
+ arr[n - 1]) {
cout << "-1" ;
return ;
}
else {
// Add the cost to overall cost
cost += abs (index[arr[i]] - i);
}
}
// Last number
else if (i == n - 1) {
if (arr[i] > arr[i - 1]
+ arr[0]) {
cout << "-1" ;
return ;
}
else {
// Add the cost to
// overall cost
cost += abs (index[arr[i]] - i);
}
}
else {
if (arr[i] > arr[i - 1]
+ arr[i + 1]) {
cout << "-1" ;
return ;
}
else {
// Add the cost to
// overall cost
cost += abs (index[arr[i]] - i);
}
}
}
// Printing the cost
cout << cost;
return ;
} // Driver Code int main()
{ // Given array
int arr[] = { 2, 4, 5, 1, 3 };
int N = sizeof (arr) / sizeof (arr[0]);
// Function call
Arrange(arr, N);
return 0;
} |
// Java program to implement // the above approach import java.util.*;
class GFG{
// Function to check if given elements // can be arranged such that sum of // its neighbors is strictly greater static void Arrange( int arr[], int n)
{ // Initialize the total cost
int cost = 0 ;
// Storing the original index of
// elements in a hashmap
HashMap<Integer,
Integer> index = new HashMap<Integer,
Integer>();
for ( int i = 0 ; i < n; i++)
{
index.put(arr[i], i);
}
// Sort the given array
Arrays.sort(arr);
// Check if a given condition
// is satisfies or not
for ( int i = 0 ; i < n; i++)
{
// First number
if (i == 0 )
{
if (arr[i] > arr[i + 1 ] +
arr[n - 1 ])
{
System.out.print( "-1" );
return ;
}
else
{
// Add the cost to overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
// Last number
else if (i == n - 1 )
{
if (arr[i] > arr[i - 1 ] +
arr[ 0 ])
{
System.out.print( "-1" );
return ;
}
else
{
// Add the cost to
// overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
else
{
if (arr[i] > arr[i - 1 ] +
arr[i + 1 ])
{
System.out.print( "-1" );
return ;
}
else
{
// Add the cost to
// overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
}
// Printing the cost
System.out.print(cost);
return ;
} // Driver Code public static void main(String[] args)
{ // Given array
int arr[] = { 2 , 4 , 5 , 1 , 3 };
int N = arr.length;
// Function call
Arrange(arr, N);
} } // This code is contributed by 29AjayKumar |
# Python3 program to implement # the above approach # Function to check if given elements # can be arranged such that sum of # its neighbours is strictly greater def Arrange(arr, n):
# Initialize the total cost
cost = 0
# Storing the original index of
# elements in a hashmap
index = {}
for i in range (n):
index[arr[i]] = i
# Sort the given array
arr.sort()
# Check if a given condition
# is satisfies or not
for i in range (n):
# First number
if (i = = 0 ):
if (arr[i] > arr[i + 1 ] + arr[ - 1 ]):
print ( "-1" )
return
else :
# Add the cost to overall cost
cost + = abs (index[arr[i]] - i)
# Last number
elif (i = = n - 1 ):
if (arr[i] > arr[i - 1 ] + arr[ 0 ]):
print ( "-1" )
return
else :
# Add the cost to
# overall cost
cost + = abs (index[arr[i]] - i)
else :
if (arr[i] > arr[i - 1 ] + arr[i + 1 ]):
print ( "-1" )
return
else :
# Add the cost to
# overall cost
cost + = abs (index[arr[i]] - i)
# Printing the cost
print (cost)
return
# Driver Code # Given array arr = [ 2 , 4 , 5 , 1 , 3 ]
N = len (arr)
# Function call Arrange(arr, N) # This code is contributed by Shivam Singh |
// C# program to implement // the above approach using System;
using System.Collections.Generic;
class GFG{
// Function to check if given elements // can be arranged such that sum of // its neighbors is strictly greater static void Arrange( int []arr, int n)
{ // Initialize the total cost
int cost = 0;
// Storing the original index of
// elements in a hashmap
Dictionary< int ,
int > index = new Dictionary< int ,
int >();
for ( int i = 0; i < n; i++)
{
index.Add(arr[i], i);
}
// Sort the given array
Array.Sort(arr);
// Check if a given condition
// is satisfies or not
for ( int i = 0; i < n; i++)
{
// First number
if (i == 0)
{
if (arr[i] > arr[i + 1] +
arr[n - 1])
{
Console.Write( "-1" );
return ;
}
else
{
// Add the cost to overall cost
cost += Math.Abs(index[arr[i]] - i);
}
}
// Last number
else if (i == n - 1)
{
if (arr[i] > arr[i - 1] +
arr[0])
{
Console.Write( "-1" );
return ;
}
else
{
// Add the cost to
// overall cost
cost += Math.Abs(index[arr[i]] - i);
}
}
else
{
if (arr[i] > arr[i - 1] +
arr[i + 1])
{
Console.Write( "-1" );
return ;
}
else
{
// Add the cost to
// overall cost
cost += Math.Abs(index[arr[i]] - i);
}
}
}
// Printing the cost
Console.Write(cost);
return ;
} // Driver Code public static void Main(String[] args)
{ // Given array
int []arr = { 2, 4, 5, 1, 3 };
int N = arr.Length;
// Function call
Arrange(arr, N);
} } // This code is contributed by shikhasingrajput |
<script> // JavaScript program to implement // the above approach // Function to check if given elements // can be arranged such that sum of // its neighbours is strictly greater function Arrange(arr, n)
{ // Initialize the total cost
let cost = 0;
// Storing the original index of
// elements in a hashmap
let index = new Map();
for (let i = 0; i < n; i++) {
index.set(arr[i], i)
}
// Sort the given array
arr.sort();
// Check if a given condition
// is satisfies or not
for (let i = 0; i < n; i++) {
// First number
if (i == 0) {
if (arr[i] > arr[i + 1] + arr[n - 1]) {
document.write( "-1" );
return ;
}
else {
// Add the cost to overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
// Last number
else if (i == n - 1) {
if (arr[i] > arr[i - 1] + arr[0]) {
document.write( "-1" );
return ;
}
else {
// Add the cost to
// overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
else {
if (arr[i] > arr[i - 1] + arr[i + 1]) {
document.write( "-1" );
return ;
}
else {
// Add the cost to
// overall cost
cost += Math.abs(index.get(arr[i]) - i);
}
}
}
// Printing the cost
document.write(cost);
return ;
} // Driver Code // Given array
let arr = [ 2, 4, 5, 1, 3 ];
let N = arr.length;
// Function call
Arrange(arr, N);
// This code is contributed by Dharanendra L V.
</script> |
Output:
10
Time Complexity: O(N log N)
Auxiliary Space: O(N)