# Maximize the number of indices such that element is greater than element to its left

Given an array arr[] of N integers, the task is to maximize the number of indices such that an element is greater than the element to its left, i.e. arr[i+1] > arr[i] after rearranging the array.

Examples:

Input: arr[] = {200, 100, 100, 200}
Output: 2
Explanation:
By arranging the array in following way we have: arr[] = {100, 200, 100, 200}
The possible indices are 0 and 2 such that:
arr[1] > arr[0] (200 > 100)
arr[3] > arr[2] (200 > 100)

Input: arr[] = {1, 8, 5, 9, 8, 8, 7, 7, 5, 7, 7}
Output: 7
Explanation:
By arranging the array in following way we have: arr[] = {1, 5, 7, 8, 9, 5, 7, 8, 7, 8, 4}
The possible indices are 0, 1, 2, 3, 5, 6 and 7 such that:
arr[1] > arr[0] (5 > 1)
arr[2] > arr[1] (7 > 5)
arr[3] > arr[2] (8 > 7)
arr[4] > arr[3] (9 > 8)
arr[6] > arr[5] (7 > 5)
arr[7] > arr[6] (8 > 7)
arr[8] > arr[7] (8 > 7)

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem can be solved using Greedy Approach. Below are the steps:

1. To get the maximum number of indices(say i) such that arr[i+1] > arr[i], arrange the elements of the arr[] such that set of all unique element occurs first, then next set of unique elements occurs after the first set till all the elements are arranged.
For Example:

Let arr[] = {1, 8, 5, 9, 8, 8, 7, 7, 5, 7, 7}
1st Set = {1, 5, 7, 8, 9}
2nd Set = {5, 7, 8}
3rd Set = {7, 8}
4th Set = {4}

Now the new array will be:
arr[] = {1, 5, 7, 8, 9, 5, 7, 8, 7, 8, 4}

2. After the above arrangement, the element with the higher value will not be a part of the given condition as it is followed by a number smaller than itself.
3. Therefore the total number of pairs satisfying the given condition can be given by:

total_pairs = (number_of_elements – highest_frequency_of_a_number)

Below is the implementation of the above approach:

 `// C++ program of the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find the maximum pairs ` `// such that arr[i+1] > arr[i] ` `void` `countPairs(``int` `arr[], ``int` `N) ` `{ ` ` `  `    ``// To store the frequency of the ` `    ``// element in arr[] ` `    ``unordered_map<``int``, ``int``> M; ` ` `  `    ``// Store the frequency in map M ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``M[arr[i]]++; ` `    ``} ` ` `  `    ``int` `maxFreq = 0; ` ` `  `    ``// To find the maximum frequency ` `    ``// store in map M ` `    ``for` `(``auto``& it : M) { ` `        ``maxFreq = max(maxFreq, ` `                      ``it.second); ` `    ``} ` ` `  `    ``// Print the maximum number of ` `    ``// possible pairs ` `    ``cout << N - maxFreq << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``int` `arr[] = { 1, 8, 5, 9, 8, 8, 7, ` `                  ``7, 5, 7, 7 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``countPairs(arr, N); ` `    ``return` `0; ` `} `

 `// Java program of the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `  `  `// Function to find the maximum pairs ` `// such that arr[i+1] > arr[i] ` `static` `void` `countPairs(``int` `arr[], ``int` `N) ` `{ ` `  `  `    ``// To store the frequency of the ` `    ``// element in arr[] ` `    ``HashMap mp = ``new` `HashMap(); ` `  `  `    ``// Store the frequency in map M ` `    ``for` `(``int` `i = ``0``; i < N; i++) { ` `        ``if``(mp.containsKey(arr[i])){ ` `            ``mp.put(arr[i], mp.get(arr[i])+``1``); ` `        ``}``else``{ ` `            ``mp.put(arr[i], ``1``); ` `    ``} ` `    ``} ` `  `  `    ``int` `maxFreq = ``0``; ` `  `  `    ``// To find the maximum frequency ` `    ``// store in map M ` `    ``for` `(Map.Entry it : mp.entrySet()) { ` `        ``maxFreq = Math.max(maxFreq, ` `                      ``it.getValue()); ` `    ``} ` `  `  `    ``// Print the maximum number of ` `    ``// possible pairs ` `    ``System.out.print(N - maxFreq +``"\n"``); ` `} ` `  `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `  `  `    ``int` `arr[] = { ``1``, ``8``, ``5``, ``9``, ``8``, ``8``, ``7``, ` `                  ``7``, ``5``, ``7``, ``7` `}; ` `    ``int` `N = arr.length; ` `  `  `    ``countPairs(arr, N); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

 `# Python3 implementation of the above approach ` ` `  `# Function to find the maximum pairs ` `# such that arr[i + 1] > arr[i] ` `def` `countPairs(arr, N) : ` ` `  `    ``# To store the frequency of the ` `    ``# element in arr[] ` `    ``M ``=` `dict``.fromkeys(arr, ``0``); ` ` `  `    ``# Store the frequency in map M ` `    ``for` `i ``in` `range``(N) : ` `        ``M[arr[i]] ``+``=` `1``; ` ` `  `    ``maxFreq ``=` `0``; ` ` `  `    ``# To find the maximum frequency ` `    ``# store in map M ` `    ``for` `it ``in` `M.values() : ` `        ``maxFreq ``=` `max``(maxFreq,it); ` ` `  `    ``# Print the maximum number of ` `    ``# possible pairs ` `    ``print``(N ``-` `maxFreq); ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``arr ``=` `[ ``1``, ``8``, ``5``, ``9``, ``8``, ``8``, ``7``, ``7``, ``5``, ``7``, ``7` `]; ` `    ``N ``=` `len``(arr); ` ` `  `    ``countPairs(arr, N); ` `     `  `    ``# This code is contributed by AnkitRai01 `

 `// C# program of the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` `   `  `// Function to find the maximum pairs ` `// such that arr[i+1] > arr[i] ` `static` `void` `countPairs(``int` `[]arr, ``int` `N) ` `{ ` `   `  `    ``// To store the frequency of the ` `    ``// element in []arr ` `    ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>(); ` `   `  `    ``// Store the frequency in map M ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``if``(mp.ContainsKey(arr[i])){ ` `            ``mp[arr[i]] = mp[arr[i]]+1; ` `        ``}``else``{ ` `            ``mp.Add(arr[i], 1); ` `    ``} ` `    ``} ` `   `  `    ``int` `maxFreq = 0; ` `   `  `    ``// To find the maximum frequency ` `    ``// store in map M ` `    ``foreach` `(KeyValuePair<``int``,``int``> it ``in` `mp) { ` `        ``maxFreq = Math.Max(maxFreq, ` `                      ``it.Value); ` `    ``} ` `   `  `    ``// Print the maximum number of ` `    ``// possible pairs ` `    ``Console.Write(N - maxFreq +``"\n"``); ` `} ` `   `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `   `  `    ``int` `[]arr = { 1, 8, 5, 9, 8, 8, 7, ` `                  ``7, 5, 7, 7 }; ` `    ``int` `N = arr.Length; ` `   `  `    ``countPairs(arr, N); ` `} ` `} ` `  `  `// This code is contributed by Rajput-Ji `

Output:
```7
```

Time Complexity: O(N), where N is the number of element in the array.
Auxiliary Space: O(N), where N is the number of element in the array.

Check out this Author's contributed articles.

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.

Improved By : AnkitRai01, Rajput-Ji, nidhi_biet

Practice Tags :