Maximum occurred integer in n ranges | Set-2

Given N ranges of L-R. The task is to print the number which occurs the maximum number of times in the given ranges. 

Note: 1 <= L <= R <= 10⁶

Examples: 

Input: range[] = { {1, 6}, {2, 3}, {2, 5}, {3, 8} } 
Output: 3 
1 occurs in 1 range {1, 6} 
2 occurs 3 in 3 range {1, 6}, {2, 3}, {2, 5} 
3 occurs 4 in 4 range {1, 6}, {2, 3}, {2, 5}, {3, 8} 
4 occurs 3 in 3 range {1, 6}, {2, 5}, {3, 8} 
5 occurs 3 in 3 range {1, 6}, {2, 5}, {3, 8} 
6 occurs 2 in 2 range {1, 6}, {3, 8} 
7 occurs 1 in 1 range {3, 8} 
8 occurs 1 in 1 range {3, 8}

Input: range[] = { {1, 4}, {1, 9}, {1, 2}}; 
Output: 1

Approach: The approach is similar to Maximum occurred integer in n ranges. The only thing that is different is to find the lower and upper bound of ranges. So that there is no need to traverse from 1 to MAX.

Below is the step by step algorithm to solve this problem: 

1. Initialize a freq array with 0, let the size of the array be 10^6 as this is the maximum possible.
2. Increase the freq[l] by 1, for every starting index of the given range.
3. Decrease the freq[r+1] by 1 for every ending index of the given range.
4. Iterate from the minimum L to the maximum R and add the frequencies by freq[i] += freq[i-1].
5. The index with the maximum value of freq[i] will be the answer.
6. Store the index and return it.

Implementation:

// C++ program to check the most occurring
// element in given range
#include <bits/stdc++.h>
using namespace std;

// Function that returns the maximum element.
int maxOccurring(int range[][2], int n)
{

    // freq array to store the frequency
    int freq[(int)(1e6 + 2)] = { 0 };

    int first = 0, last = 0;

    // iterate and mark the hash array
    for (int i = 0; i < n; i++) {
        int l = range[i][0];
        int r = range[i][1];

        // increase the hash array by 1 at L
        freq[l] += 1;

        // Decrease the hash array by 1 at R
        freq[r + 1] -= 1;

        first = min(first, l);
        last = max(last, r);
    }

    // stores the maximum frequency
    int maximum = 0;
    int element = 0;

    // check for the most occurring element
    for (int i = first; i <= last; i++) {

        // increase the frequency
        freq[i] = freq[i - 1] + freq[i];

        // check if is more than the previous one
        if (freq[i] > maximum) {
            maximum = freq[i];
            element = i;
        }
    }

    return element;
}

// Driver code
int main()
{
    int range[][2] = { { 1, 6 }, { 2, 3 }, { 2, 5 }, { 3, 8 } };
    int n = 4;

    // function call
    cout << maxOccurring(range, n);

    return 0;
}

// Java program to check the most occurring
// element in given range
class GFG 
{ 

// Function that returns the maximum element.
static int maxOccurring(int range[][], int n)
{

    // freq array to store the frequency
    int []freq = new int[(int)(1e6 + 2)];

    int first = 0, last = 0;

    // iterate and mark the hash array
    for (int i = 0; i < n; i++)
    {
        int l = range[i][0];
        int r = range[i][1];

        // increase the hash array by 1 at L
        freq[l] += 1;

        // Decrease the hash array by 1 at R
        freq[r + 1] -= 1;

        first = Math.min(first, l);
        last = Math.max(last, r);
    }

    // stores the maximum frequency
    int maximum = 0;
    int element = 0;

    // check for the most occurring element
    for (int i = first+1; i <= last; i++) 
    {

        // increase the frequency
        freq[i] = freq[i - 1] + freq[i];

        // check if is more than the previous one
        if (freq[i] > maximum) 
        {
            maximum = freq[i];
            element = i;
        }
    }
    return element;
}

// Driver code
public static void main(String[] args) 
{
    int range[][] = { { 1, 6 }, { 2, 3 }, 
                      { 2, 5 }, { 3, 8 } };
    int n = 4;

    // function call
    System.out.println(maxOccurring(range, n));
}
}

// This code is contributed by PrinciRaj1992 

# Python3 program to check the most 
# occurring element in given range

# Function that returns the 
# maximum element.
def maxOccurring(range1, n):
    
    # freq array to store the frequency
    freq = [0] * 1000002;
    
    first = 0;
    last = 0;
    
    # iterate and mark the hash array
    for i in range(n):
        l = range1[i][0];
        r = range1[i][1];
        
        # increase the hash array by 1 at L
        freq[l] += 1;
        
        # Decrease the hash array by 1 at R
        freq[r + 1] -= 1;
        first = min(first, l);
        last = max(last, r);
    
    # stores the maximum frequency
    maximum = 0;
    element = 0;
    
    # check for the most occurring element
    for i in range(first, last + 1):
        
        # increase the frequency
        freq[i] = freq[i - 1] + freq[i];
        
        # check if is more than the 
        # previous one
        if(freq[i] > maximum):
            maximum = freq[i];
            element = i;
    return element;

# Driver code
range1= [[ 1, 6 ], [ 2, 3 ], 
         [ 2, 5 ], [ 3, 8 ]];
n = 4;
    
# function call
print(maxOccurring(range1, n));

# This code is contributed by mits

// C# program to check the most occurring
// element in given range
using System;
    
class GFG 
{ 

// Function that returns the maximum element.
static int maxOccurring(int [,]range, int n)
{

    // freq array to store the frequency
    int []freq = new int[(int)(1e6 + 2)];

    int first = 0, last = 0;

    // iterate and mark the hash array
    for (int i = 0; i < n; i++)
    {
        int l = range[i, 0];
        int r = range[i, 1];

        // increase the hash array by 1 at L
        freq[l] += 1;

        // Decrease the hash array by 1 at R
        freq[r + 1] -= 1;

        first = Math.Min(first, l);
        last = Math.Max(last, r);
    }

    // stores the maximum frequency
    int maximum = 0;
    int element = 0;

    // check for the most occurring element
    for (int i = first + 1; i <= last; i++) 
    {

        // increase the frequency
        freq[i] = freq[i - 1] + freq[i];

        // check if is more than the previous one
        if (freq[i] > maximum) 
        {
            maximum = freq[i];
            element = i;
        }
    }
    return element;
}

// Driver code
public static void Main(String[] args) 
{
    int [,]range = {{ 1, 6 }, { 2, 3 }, 
                    { 2, 5 }, { 3, 8 }};
    int n = 4;

    // function call
    Console.WriteLine(maxOccurring(range, n));
}
}

// This code is contributed by Princi Singh

<?php 
// PHP program to check the most occurring
// element in given range

// Function that returns the maximum element.
function maxOccurring(&$range, $n)
{
    // freq array to store the frequency
    $freq = array(0, 1000002, NULL); 

    $first = 0;
    $last = 0;

    // iterate and mark the hash array
    for ($i = 0; $i < $n; $i++)
    {
        $l = $range[$i][0];
        $r = $range[$i][1];

        // increase the hash array 
        // by 1 at L
        $freq[$l] += 1;

        // Decrease the hash array 
        // by 1 at R
        $freq[$r + 1] -= 1;

        $first = min($first, $l);
        $last = max($last, $r);
    }

    // stores the maximum frequency
    $maximum = 0;
    $element = 0;

    // check for the most occurring element
    for ($i = $first; $i <= $last; $i++)
    {

        // increase the frequency
        $freq[$i] = $freq[$i - 1] + $freq[$i];

        // check if is more than the 
        // previous one
        if ($freq[$i] > $maximum)
        {
            $maximum = $freq[$i];
            $element = $i;
        }
    }

    return $element;
}

// Driver code
$range = array(array( 1, 6 ),
               array( 2, 3 ),
               array( 2, 5 ), 
               array( 3, 8 ));
$n = 4;

// function call
echo maxOccurring($range, $n);

// This code is contributed by ita_c
?>

<script>

// Javascript program to check the most occurring
// element in given range    

// Function that returns the maximum element.
    function maxOccurring(range , n) 
    {

        // freq array to store the frequency
        var freq = Array(parseInt(1e6 + 2)).fill(0);

        var first = 0, last = 0;

        // iterate and mark the hash array
        for (i = 0; i < n; i++) {
            var l = range[i][0];
            var r = range[i][1];

            // increase the hash array by 1 at L
            freq[l] += 1;

            // Decrease the hash array by 1 at R
            freq[r + 1] -= 1;

            first = Math.min(first, l);
            last = Math.max(last, r);
        }

        // stores the maximum frequency
        var maximum = 0;
        var element = 0;

        // check for the most occurring element
        for (i = first + 1; i <= last; i++) {

            // increase the frequency
            freq[i] = freq[i - 1] + freq[i];

            // check if is more than the previous one
            if (freq[i] > maximum) {
                maximum = freq[i];
                element = i;
            }
        }
        return element;
    }

    // Driver code
    
        var range = [ [ 1, 6 ], [ 2, 3 ],
                      [ 2, 5 ], [ 3, 8 ] ];
        var n = 4;

        // function call
        document.write(maxOccurring(range, n));

// This code contributed by gauravrajput1 

</script>

3

Complexity Analysis:

• Time Complexity: O(N + M), where M is the maximum value among the ranges.
• Auxiliary Space: O(10⁶), as we are using extra space for freq array.

Note: If values the values of L and T are of order 10⁸ then above method won't work as there will be a memory error. We need a different but similar approach for these limits. You may think in terms of hashing.