给定N个唯一整数的数组arr [] ，任务是要找到以圆形方式排列它们的成本，即每个元素都小于或等于其相邻元素的总和。
Cost of moving an element from index i in original array to index j in final arrangement is |i – j|
如果这样的安排是不可能的，则打印-1 。
例子：
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
方法：可以使用贪婪方法解决问题。想法是将元素的原始索引存储在哈希图中，然后对数组进行排序。现在检查给定条件是否满足。如果发现是正确的，则通过将当前索引与先前索引之间的差相加来计算成本。否则，打印-1 。
下面是上述方法的实现：
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 orginal index of
// elements in a hashmap
unordered_map 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 orginal 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 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 SinghC#
// 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 index = new Dictionary();
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 输出：
10
时间复杂度： O(N log N)
辅助空间： O(N)