 Open in App
Not now

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

• Last Updated : 16 Jun, 2022

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 ``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) {``                ``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);` `    ``// 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 index = ``new` `HashMap();` `    ``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)``            ``{``                ``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

 ``

Output:

`10`

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

My Personal Notes arrow_drop_up