Open in App
Not now

# Maximize height of tower using elements from one of the given Subarrays

• Last Updated : 24 Feb, 2023

Given an array arr[] of length N, two arrays start[] and end[] of size M each where {start[i], end[i]} denotes a subarray of arr[] and an integer base, the task is to determine the maximum height of a tower with given base that can be formed using elements from a single subarray bounded by any {start[i], end[i]} and satisfying the following conditions:

• All elements in each level should be equal.
• Number of elements in each level is the same as base.
• No two level can have the same element.

Example to understand the problem

Examples:

Input: N = 9, arr[] = {1, 5, 7, 3, 2, 4, 6, 9, 8}, M = 3, start[] = {0, 3, 5}, end[] =  {8, 5, 6}, base = 1
Output: 9
Explanation:
First Subarray = {0, 8}. There are 9 different elements.
Each element can be kept at a different level.
So the height of the tower can be maximum 9 as base is 1.
Second Subarray = {3, 5}. There are 3 unique elements.
So it will have height 3 at maximum.
Third Subarray = {5, 6}. We can form a tower of max height 2.
The maximum height among all the sub-arrays = 9.

Input: N = 5, arr[] = {1, 3, 3, 7, 5}, M = 2, start[] = {0, 1}, end[] =  {0, 3}, base = 2
Output: 1
Explanation:
First Subarray = {0, 0}. height = 0 for this sub-array,
because no tower of base 2 can be formed.
Second Sub-array = {1, 2}. Tower of height 1 can be formed by using
arr[1] and arr[2] at 1st level of tower.
The maximum height of the tower that can be obtained from all the above subarrays is 1.

Approach: To solve the problem follow the below idea:

Count the frequency of each distinct element for each sub-array using Hash-Map. Initialized current_height a variable to zero, Traverse on Hash-Map and if an element’s frequency is greater than or equal to base then increment the current_height. Print the maximum value of Height H among all the sub-arrays.

Follow the steps to solve the problem:

• Create a max_height variable and set it as max_height = 0. Then for each sub-array follow these sub-steps:
• Create a Hash-Map and a current_variable = 0.
• Count the frequency of each distinct element and store it in Hash-Map as pair of <element, frequency>.
• While traversing on Hash-Map, if the frequency of a pair in Hash-Map is greater than or equal to the base of Tower, then increment current_height, and if current_height is greater than max_height then update max_height as current_height.
• Print the value of the max_height variable.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to obtain Maximum` `// height of tower` `int` `Max_height(``int` `n, ``int` `arr[], ``int` `m,` `               ``int` `start[], ``int` `end[], ``int` `base)` `{` `    ``// Variable to store Maximum height` `    ``// of tower among all sub-array` `    ``int` `max_height = 0;`   `    ``// Loop for obtaining maximum value` `    ``// of H for all sub-arrays` `    ``for` `(``int` `i = 0; i < m; i++)` `    ``{`   `        ``// Variable to current height` `        ``// for each sub-array` `        ``int` `current_height = 0;`   `        ``// Variable to store start` `        ``// point of each sub-array` `        ``int` `start_point = start[i];`   `        ``// Variable to store start` `        ``// point of each sub-array` `        ``int` `end_point = end[i];`   `        ``// HashMap initialized to` `        ``// store frequencies` `        ``unordered_map<``int``, ``int``> map;`   `        ``// Loop for Traversing` `        ``// on sub-array` `        ``for` `(``int` `j = start_point; j <= end_point; j++)` `        ``{`   `            ``// Updating frequencies in` `            ``// Hash-Map for each` `            ``// distinct element present` `            ``// in sub-array` `            ``map[arr[j]]++;` `        ``}`   `        ``// For loop for traversing` `        ``// on Map` `        ``for` `(``auto` `it = map.begin(); it != map.end(); it++)` `        ``{` `            ``if` `(it->second >= base)` `            ``{`   `                ``// Updating  value of` `                ``// current_height` `                ``current_height++;`   `                ``// Updating value of` `                ``// max_height by` `                ``// comparing it with` `                ``// current_height` `                ``max_height = current_height > max_height` `                                 ``? current_height` `                                 ``: max_height;` `            ``}` `        ``}` `    ``}` `    ``// Printing value of max height` `    ``// among all subarrays` `    ``return` `max_height;` `}` `// Driver Function` `int` `main()` `{` `    ``int` `N = 9;` `    ``int` `arr[] = {1, 5, 7, 3, 2, 4, 6, 9, 8};` `    ``int` `M = 3;` `    ``int` `start[] = {0, 3, 5};` `    ``int` `end[] = {8, 5, 6};` `    ``int` `base = 1;`   `    ``// Function call` `    ``cout << (Max_height(N, arr, M, start, end, base));` `}` `// This code is contributed by Potta Lokesh`

## Java

 `// Java code to implement the approach`   `import` `java.util.*;` `class` `GFG {`   `    ``// Driver Function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``9``;` `        ``int` `arr[] = { ``1``, ``5``, ``7``, ``3``, ``2``, ``4``, ``6``, ``9``, ``8` `};` `        ``int` `M = ``3``;` `        ``int` `start[] = { ``0``, ``3``, ``5` `};` `        ``int` `end[] = { ``8``, ``5``, ``6` `};` `        ``int` `base = ``1``;`   `        ``// Function call` `        ``System.out.println(` `            ``Max_height(N, arr, M, start, end, base));` `    ``}`   `    ``// Function to obtain Maximum` `    ``// height of tower` `    ``static` `int` `Max_height(``int` `n, ``int``[] arr, ``int` `m,` `                          ``int``[] start, ``int``[] end, ``int` `base)` `    ``{` `        ``// Variable to store Maximum height` `        ``// of tower among all sub-array` `        ``int` `max_height = ``0``;`   `        ``// Loop for obtaining maximum value` `        ``// of H for all sub-arrays` `        ``for` `(``int` `i = ``0``; i < m; i++) {`   `            ``// Variable to current height` `            ``// for each sub-array` `            ``int` `current_height = ``0``;`   `            ``// Variable to store start` `            ``// point of each sub-array` `            ``int` `start_point = start[i];`   `            ``// Variable to store start` `            ``// point of each sub-array` `            ``int` `end_point = end[i];`   `            ``// HashMap initialized to` `            ``// store frequencies` `            ``HashMap map = ``new` `HashMap<>();`   `            ``// Loop for Traversing` `            ``// on sub-array` `            ``for` `(``int` `j = start_point; j <= end_point; j++) {`   `                ``// Updating frequencies in` `                ``// Hash-Map for each` `                ``// distinct element present` `                ``// in sub-array` `                ``map.put(arr[j], map.get(arr[j]) == ``null` `                                    ``? ``1` `                                    ``: map.get(arr[j]) + ``1``);` `            ``}`   `            ``// For loop for traversing` `            ``// on Map` `            ``for` `(Map.Entry set :` `                 ``map.entrySet()) {` `                ``if` `(set.getValue() >= base) {`   `                    ``// Updating  value of` `                    ``// current_height` `                    ``current_height++;`   `                    ``// Updating value of` `                    ``// max_height by` `                    ``// comparing it with` `                    ``// current_height` `                    ``max_height = current_height > max_height` `                                     ``? current_height` `                                     ``: max_height;` `                ``}` `            ``}` `        ``}` `        ``// Printing value of max height` `        ``// among all subarrays` `        ``return` `max_height;` `    ``}` `}`

## Python3

 `# Python code to implement the approach`   `# Function to obtain Maximum` `# height of tower` `def` `Max_height(n, arr, m, start, end, base):` `  `  `    ``# Variable to store Maximum height` `    ``# of tower among all sub-array` `    ``max_height ``=` `0`   `    ``# Loop for obtaining maximum value` `    ``# of H for all sub-arrays` `    ``for` `i ``in` `range``(m):` `      `  `        ``# Variable to current height` `        ``# for each sub-array` `        ``current_height ``=` `0` `        `  `        ``# Variable to store start` `        ``# point of each sub-array` `        ``start_point ``=` `start[i]` `        `  `        ``# Variable to store start` `        ``# point of each sub-array` `        ``end_point ``=` `end[i]` `        `  `        ``# HashMap initialized to` `        ``# store frequencies` `        ``mp ``=` `{}`   `        ``# Loop for Traversing` `        ``# on sub-array` `        ``for` `j ``in` `range``(start_point, end_point``+``1``):` `          `  `            ``# Updating frequencies in` `            ``# Hash-Map for each` `            ``# distinct element present` `            ``# in sub-array` `            ``if` `mp.get(arr[j]) ``=``=` `None``:` `                ``mp[arr[j]] ``=` `1` `            ``else``:` `                ``mp[arr[j]] ``+``=` `1` `                `  `        ``# For loop for traversing` `        ``# on Map` `        ``for` `first, second ``in` `mp.items():` `            ``if` `(second >``=` `base):` `              `  `                ``# Updating  value of` `                ``# current_height` `                ``current_height ``+``=` `1` `                `  `                ``# Updating value of` `                ``# max_height by` `                ``# comparing it with` `                ``# current_height` `                ``max_height ``=` `current_height ``if` `(` `                    ``current_height > max_height) ``else` `max_height`   `    ``# Printing value of max height` `    ``# among all subarrays` `    ``return` `max_height`   `# Driver Function` `if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `9` `    ``arr ``=` `[``1``, ``5``, ``7``, ``3``, ``2``, ``4``, ``6``, ``9``, ``8``]` `    ``M ``=` `3` `    ``start ``=` `[``0``, ``3``, ``5``]` `    ``end ``=` `[``8``, ``5``, ``6``]` `    ``base ``=` `1`   `    ``# Function call` `    ``print``(Max_height(N, arr, M, start, end, base))`   `# This code is contributed by Rohit Pradhan`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG {`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``int` `N = 9;` `    ``int``[] arr = { 1, 5, 7, 3, 2, 4, 6, 9, 8 };` `    ``int` `M = 3;` `    ``int``[] start = { 0, 3, 5 };` `    ``int``[] end = { 8, 5, 6 };` `    ``int` `Base = 1;`   `    ``// Function call` `    ``Console.WriteLine(` `      ``Max_height(N, arr, M, start, end, Base));` `  ``}`   `  ``// Function to obtain Maximum` `  ``// height of tower` `  ``static` `int` `Max_height(``int` `n, ``int``[] arr, ``int` `m,` `                        ``int``[] start, ``int``[] end, ``int` `Base)` `  ``{` `    ``// Variable to store Maximum height` `    ``// of tower among all sub-array` `    ``int` `max_height = 0;`   `    ``// Loop for obtaining maximum value` `    ``// of H for all sub-arrays` `    ``for` `(``int` `i = 0; i < m; i++) {`   `      ``// Variable to current height` `      ``// for each sub-array` `      ``int` `current_height = 0;`   `      ``// Variable to store start` `      ``// point of each sub-array` `      ``int` `start_point = start[i];`   `      ``// Variable to store start` `      ``// point of each sub-array` `      ``int` `end_point = end[i];`   `      ``// HashMap initialized to` `      ``// store frequencies` `      ``Dictionary<``int``, ``int``> map` `        ``= ``new` `Dictionary<``int``, ``int``>();`   `      ``// Loop for Traversing` `      ``// on sub-array` `      ``for` `(``int` `j = start_point; j <= end_point; j++) {`   `        ``// Updating frequencies in` `        ``// Hash-Map for each` `        ``// distinct element present` `        ``// in sub-array` `        ``if` `(map.ContainsKey(arr[j])) {` `          ``map[arr[j]] += 1;` `        ``}` `        ``else` `{` `          ``map[arr[j]] = 1;` `        ``}` `      ``}`   `      ``// For loop for traversing` `      ``// on Map` `      ``foreach``(KeyValuePair<``int``, ``int``> Set ``in` `map)` `      ``{` `        ``if` `(Set.Value >= Base) {`   `          ``//Updating  value of` `          ``// current_height` `          ``current_height++;`   `          ``// Updating value of` `          ``// max_height by` `          ``// comparing it with` `          ``// current_height` `          ``max_height = current_height > max_height` `            ``? current_height` `            ``: max_height;` `        ``}` `      ``}` `    ``}` `    ``// Printing value of max height` `    ``// among all subarrays` `    ``return` `max_height;` `  ``}` `}`   `// This code is contributed by lokeshmvs21.`

## Javascript

 ``

Output

`9`

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

My Personal Notes arrow_drop_up
Related Articles