Open In App

Cost of rearranging the array such that no element exceeds the sum of its adjacent elements

Improve
Improve
Like Article
Like
Save
Share
Report

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++




// 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




// 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




# 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#




// 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


Javascript




<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)
 



Last Updated : 16 Jun, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads