# Queries to count occurrences of maximum array element in subarrays starting from given indices

• Difficulty Level : Easy
• Last Updated : 11 Feb, 2022

Given two arrays arr[] and q[] consisting of N integers, the task is for each query q[i] is to determine the number of times the maximum array element occurs in the subarray [q[i], arr[N – 1]].

Examples:

Input: arr[] = {5, 4, 5, 3, 2}, q[] = {1, 2, 3, 4, 5}
Output: 2 1 1 1 1
Explanation:
For the first query index start from 1. The subarray is [5, 4, 5, 3, 2], the maximum value is 5 and it’s occurrence in subarray is 2.
For the second query index start from 2. The subarray is [4, 5, 3, 2], the maximum value is 5 and it’s occurrence in subarray is 1.
For the third query index start from 3. The subarray is [5, 3, 2], the maximum value is 5 and it’s occurrence in subarray is 1.
For the forth query index start from 4. The subarray is [3, 2], the maximum value is 3 and it’s occurrence in subarray is 1.
For the fifth query index start from 5. The subarray is , the maximum value is 2 and it’s occurrence in subarray is 1.

Input: arr[] = {2, 1, 2}, q[] = {1, 2, 3}
Output: 2 1 1

Naive Approach: The simplest approach is to traverse the array and find the maximum array element. Now, for each query q[i], traverse the subarray [q[i], arr[N – 1]] and print the count of occurrences of the maximum element in the subarray.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Hashing. Below are the steps:

• Create an array maxFreqVec[] to store the occurrence of the max element from given index q[i] to N.
• Traverse the array arr[] from the right and keep track of the maximum element in the array and update the array maxFreqVec[] at that index with the occurrence of that maximum element.
• After the above steps, traverse over the array q[] and print the value maxFreqVec[q[i] – 1] as the maximum element in each subarray for each query.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include``using` `namespace` `std;` `// Function to find occurrence of``// max element in given subarray``void` `FreqOfMaxElement(vector<``int``> arr,``                      ``vector<``int``> q)``{``    ` `    ``// Store the frequency of maximum``    ``// element``    ``vector<``int``> maxFreqVec(arr.size());` `    ``int` `maxSoFar = INT_MIN;``    ``int` `maxFreq = 0;` `    ``// Traverse over the array arr[]``    ``// from right to left``    ``for``(``int` `i = arr.size() - 1; i >= 0; i--)``    ``{``        ` `        ``// If curr element is greater``        ``// than maxSofar``        ``if` `(arr[i] > maxSoFar)``        ``{``            ` `            ``// Reset maxSofar and maxFreq``            ``maxSoFar = arr[i];``            ``maxFreq = 1;``        ``}` `        ``// If curr is equal to maxSofar``        ``else` `if` `(arr[i] == maxSoFar)``        ``{``            ` `            ``// Increment the maxFreq``            ``maxFreq++;``        ``}` `        ``// Update maxFreqVec[i]``        ``maxFreqVec[i] = maxFreq;``    ``}` `    ``// Print occurrence of maximum``    ``// element for each query``    ``for``(``int` `k : q)``    ``{``        ``cout << maxFreqVec[k - 1] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 5, 4, 5, 3, 2 };``    ``vector<``int``> q = { 1, 2, 3, 4, 5 };``    ` `    ``// Function Call``    ``FreqOfMaxElement(arr, q);``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG {` `    ``// Function to find occurrence of``    ``// max element in given subarray``    ``static` `void` `FreqOfMaxElement(``        ``int``[] arr, ``int``[] q)``    ``{` `        ``// Store the frequency of maximum``        ``// element``        ``int``[] maxFreqVec``            ``= ``new` `int``[arr.length];` `        ``int` `maxSoFar = Integer.MIN_VALUE;``        ``int` `maxFreq = ``0``;` `        ``// Traverse over the array arr[]``        ``// from right to left``        ``for` `(``int` `i = arr.length - ``1``;``             ``i >= ``0``; i--) {` `            ``// If curr element is greater``            ``// than maxSofar``            ``if` `(arr[i] > maxSoFar) {` `                ``// Reset maxSofar and maxFreq``                ``maxSoFar = arr[i];``                ``maxFreq = ``1``;``            ``}` `            ``// If curr is equal to maxSofar``            ``else` `if` `(arr[i] == maxSoFar) {` `                ``// Increment the maxFreq``                ``maxFreq++;``            ``}` `            ``// Update maxFreqVec[i]``            ``maxFreqVec[i] = maxFreq;``        ``}` `        ``// Print occurrence of maximum``        ``// element for each query``        ``for` `(``int` `k : q) {``            ``System.out.print(``                ``maxFreqVec[k - ``1``] + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``5``, ``4``, ``5``, ``3``, ``2` `};``        ``int``[] q = { ``1``, ``2``, ``3``, ``4``, ``5` `};` `        ``// Function Call``        ``FreqOfMaxElement(arr, q);``    ``}``}`

## Python3

 `# Python3 program for``# the above approach``import` `sys;` `# Function to find occurrence``# of max element in given``# subarray``def` `FreqOfMaxElement(arr, q):``  ` `    ``# Store the frequency of``    ``# maximum element``    ``maxFreqVec ``=` `[``0``] ``*` `(``len``(arr));` `    ``maxSoFar ``=` `-``sys.maxsize;``    ``maxFreq ``=` `0``;` `    ``# Traverse over the array``    ``# arr from right to left``    ``for` `i ``in` `range``(``len``(arr)``-``1``,``                   ``-``1``, ``-``1``):` `        ``# If curr element is``        ``# greater than maxSofar``        ``if` `(arr[i] > maxSoFar):` `            ``# Reset maxSofar``            ``# and maxFreq``            ``maxSoFar ``=` `arr[i];``            ``maxFreq ``=` `1``;` `        ``# If curr is equal to``        ``# maxSofar``        ``elif` `(arr[i] ``=``=` `maxSoFar):` `            ``# Increment the``            ``# maxFreq``            ``maxFreq ``+``=` `1``;` `        ``# Update maxFreqVec[i]``        ``maxFreqVec[i] ``=` `maxFreq;` `    ``# Print occurrence of maximum``    ``# element for each query``    ``for` `i ``in` `range``(``0``, ``len``(q)):``        ``print``(maxFreqVec[q[i] ``-` `1``],``              ``end ``=` `" "``);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``arr ``=` `[``5``, ``4``, ``5``, ``3``, ``2``];``    ``q ``=` `[``1``, ``2``, ``3``, ``4``, ``5``];` `    ``# Function Call``    ``FreqOfMaxElement(arr, q);` `# This code is contributed by shikhasingrajput`

## C#

 `// C# program for the``// above approach``using` `System;``class` `GFG{``    ` `// Function to find occurrence of``// max element in given subarray``static` `void` `FreqOfMaxElement(``int``[] arr,``                             ``int``[] q)``{``  ``// Store the frequency of``  ``// maximum element``  ``int``[] maxFreqVec = ``new` `int``[arr.Length];` `  ``int` `maxSoFar = Int32.MinValue;``  ``int` `maxFreq = 0;` `  ``// Traverse over the array arr[]``  ``// from right to left``  ``for` `(``int` `i = arr.Length - 1;``           ``i >= 0; i--)``  ``{``    ``// If curr element is greater``    ``// than maxSofar``    ``if` `(arr[i] > maxSoFar)``    ``{``      ``// Reset maxSofar and maxFreq``      ``maxSoFar = arr[i];``      ``maxFreq = 1;``    ``}` `    ``// If curr is equal to maxSofar``    ``else` `if` `(arr[i] == maxSoFar)``    ``{``      ``// Increment the maxFreq``      ``maxFreq++;``    ``}` `    ``// Update maxFreqVec[i]``    ``maxFreqVec[i] = maxFreq;``  ``}` `  ``// Print occurrence of maximum``  ``// element for each query``  ``foreach` `(``int` `k ``in` `q)``  ``{``    ``Console.Write(maxFreqVec[k - 1] +``                  ``" "``);``  ``}``}``    ` `// Driver code``static` `void` `Main()``{``  ``int``[] arr = {5, 4, 5, 3, 2};``  ``int``[] q = {1, 2, 3, 4, 5};` `  ``// Function Call``  ``FreqOfMaxElement(arr, q);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

`2 1 1 1 1`

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

My Personal Notes arrow_drop_up