用a [i + 1]> a [i]最大化元素

给定一个由N个整数组成的数组，请重新排列该数组元素，以使下一个数组元素大于上一个元素( $A_{(i+1)}$ > $A_i$ )。

例子：

Input : arr[] = {20, 30, 10, 50, 40}
Output : 4
We rearrange the array as 10, 20, 30, 40, 50. As 20 > 10, 30 > 20, 40 > 30, 50 > 40, so we get 4 indices i such that $A_{(i+1)}$ > $A_i$.

Input : arr[] = {200, 100, 100, 200}
Output : 2
We get optimal arrangement as 100 200 100 200.

如果所有元素都不同，则答案就是n-1，其中n是数组中元素的数量。如果存在重复元素，则答案为n – max_freq。

C++

#include
using namespace std;
  
// returns the number of positions where A(i + 1) is
// greater than A(i) after rearrangement of the array
int countMaxPos(int arr[], int n)
{
  
    // Creating a HashMap containing char
    // as a key and occurrences as a value
    unordered_map map;
      
    for (int i = 0; i < n; i++ ) {
        if (map.count(arr[i]))
            map.insert({arr[i], (map.count(arr[i]) + 1)});
        else
            map.insert({arr[i], 1});
    }
      
    // Find the maximum frequency
    int max_freq = 0;
  
    for (auto i : map) { 
        if (max_freq < i.second) 
        { 
            max_freq = i.second; 
        } 
    } 
    return n - max_freq;
}
  
// Driver code
int main()
{
    int arr[] = { 20, 30, 10, 50, 40 };
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << (countMaxPos(arr, n));
}
  
// This code is contributed by Rajput-Ji

Java

import java.util.*;
  
class GFG {
  
    // returns the number of positions where A(i + 1) is
    // greater than A(i) after rearrangement of the array
    static int countMaxPos(int[] arr)
    {
        int n = arr.length;
  
        // Creating a HashMap containing char
        // as a key and occurrences as  a value
        HashMap map
            = new HashMap();
        for (int x : arr) {
            if (map.containsKey(x))
                map.put(x, map.get(x) + 1);
            else
                map.put(x, 1);
        }
  
        // Find the maximum frequency
        int max_freq = 0;
        for (Map.Entry entry : map.entrySet())
            max_freq = Math.max(max_freq, (int)entry.getValue());
  
        return n - max_freq;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = { 20, 30, 10, 50, 40 };
        System.out.println(countMaxPos(arr));
    }
}

Python3

# Python3 implementation of the above approach
  
# Returns the number of positions where 
# A(i + 1) is greater than A(i) after 
# rearrangement of the array 
def countMaxPos(arr): 
      
    n = len(arr) 
  
    # Creating a HashMap containing char 
    # as a key and occurrences as a value 
    Map = {} 
    for x in arr: 
        if x in Map: 
            Map[x] += 1
        else:
            Map[x] = 1
          
    # Find the maximum frequency 
    max_freq = 0
    for entry in Map: 
        max_freq = max(max_freq, Map[entry]) 
  
    return n - max_freq 
  
# Driver code 
if __name__ == "__main__":
      
    arr = [20, 30, 10, 50, 40] 
    print(countMaxPos(arr)) 
      
# This code is contributed by Rituraj Jain

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;             
  
class GFG 
{
  
    // returns the number of positions where 
    // A(i + 1) is greater than A(i) after 
    // rearrangement of the array
    static int countMaxPos(int[] arr)
    {
        int n = arr.Length;
  
        // Creating a HashMap containing char
        // as a key and occurrences as a value
        Dictionary map = new Dictionary();
        foreach (int x in arr) 
        {
            if (map.ContainsKey(x))
                map[x] = map[x] + 1;
            else
                map.Add(x, 1);
        }
  
        // Find the maximum frequency
        int max_freq = 0;
        foreach(KeyValuePair entry in map)
            max_freq = Math.Max(max_freq, entry.Value);
  
        return n - max_freq;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 20, 30, 10, 50, 40 };
        Console.WriteLine(countMaxPos(arr));
    }
}
  
// This code is contributed by 29AjayKumar

输出：

4