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

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 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 arrangment 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 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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 orginal 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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

Output:

10

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

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.




Recommended Posts:


Data science |Machine learning|Programming facebook -https//wwwfacebookcom/profilephpid=100002787011326

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :