Given an infinitely long binary tree having a pattern as below:
1 / \ 2 3 / \ / \ 4 5 6 7 / \ / \ / \ / \ ......................
Also given an array arr of size N and a number K. The task is to color all the subtrees of node arr[i] with colour i (1 <= i <= N) one after another. Find the colour of node K after colouring all subtrees.
Note:- Initially all nodes have color 0.
Input :arr[] = {3, 2, 1, 3}, K = 7
Output : 4
Explanation :
After applying the color 1 to subtree at node 3, node 7 contains color 1.
After applying the color 2 to subtree at node 2, node 7 contains color 1.
After applying the color 3 to subtree at node 1, node 7 contains color 3.
After applying the color 4 to subtree at node 3, node 7 contains color 4.Input : arr[] = {3, 2, 1, 3}, K = 4
Output : 3
Explanation :
After applying the color 1 to subtree at node 3, node 4 contains color 0.
After applying the color 2 to subtree at node 2, node 4 contains color 2.
After applying the color 3 to subtree at node 1, node 4 contains color 3.
After applying the color 4 to subtree at node 3, node 4 contains color 3.
A naive approach is for every index i (1 <= i <= N) update color all nodes in a subtree until the level of the nodes less than the level of given node K. After N such operations print the color of node K.
An efficient approach is to use hashing
- First, insert all the nodes with their respective colors in a map( in case, if a node has more than one color, keep one with the maximum color number).
- Find all ancestors of the given node k and output the color having a maximum number. (If the current node is x, then (x-1)/2 or x/2 are its ancestors)
Below is the implementation of the above approach:
// CPP program to find color of the node #include <bits/stdc++.h> using namespace std;
// Function to find color of the node int findColor(map< int , int > mapWithColor, int query)
{ // Maximum is to store maximum color
int maximum = 0;
// Loop to check all the parent
// values to get maximum color
while (query >= 1) {
// Find the number into map and get maximum color
if (mapWithColor.find(query) != mapWithColor.end())
{
// Take the maximum color and
// assign into maximum variable
maximum = max(maximum, mapWithColor[query]);
}
// Find parent index
if (query % 2 == 1)
query = (query - 1) / 2;
else
query = query / 2;
}
// Return maximum color
return maximum;
} // Function to build hash map with color map< int , int > buildMapWithColor( int arr[], int n)
{ // To store color of each node
map< int , int > mapWithColor;
// For each number add a color number
for ( int i = 0; i < n; i++) {
// Assigning color
mapWithColor[arr[i]] = i + 1;
}
// Return hash map
return mapWithColor;
} // Driver code int main()
{ int arr[] = { 3, 2, 1, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 7;
// Build mapWithColor
map< int , int > mapWithColor = buildMapWithColor(arr, n);
// Print the maximum color
cout << findColor(mapWithColor, k);
return 0;
} |
// JAVA program to find color of the node import java.util.*;
class GFG
{ // Function to find color of the node
static int findColor(HashMap<Integer, Integer> mapWithColor, int query)
{
// Maximum is to store maximum color
int maximum = 0 ;
// Loop to check all the parent
// values to get maximum color
while (query >= 1 )
{
// Find the number into map and get maximum color
if (mapWithColor.containsKey(query))
{
// Take the maximum color and
// assign into maximum variable
maximum = Math.max(maximum, mapWithColor.get(query));
}
// Find parent index
if (query % 2 == 1 )
query = (query - 1 ) / 2 ;
else
query = query / 2 ;
}
// Return maximum color
return maximum;
}
// Function to build hash map with color
static HashMap<Integer, Integer> buildMapWithColor( int arr[], int n)
{
// To store color of each node
HashMap<Integer, Integer> mapWithColor = new HashMap<Integer, Integer>();
// For each number add a color number
for ( int i = 0 ; i < n; i++)
{
// Assigning color
mapWithColor.put(arr[i], i + 1 );
}
// Return hash map
return mapWithColor;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 3 , 2 , 1 , 3 };
int n = arr.length;
int k = 7 ;
// Build mapWithColor
HashMap<Integer, Integer> mapWithColor = buildMapWithColor(arr, n);
// Print the maximum color
System.out.print(findColor(mapWithColor, k));
}
} // This code is contributed by PrinciRaj1992 |
# Python3 code program to find color of the node # Function to find color of the node def findColor(mapWithColor, query):
# Maximum is to store maximum color
maximum = 0
# Loop to check all the parent
# values to get maximum color
while (query > = 1 ):
# Find the number into map and get maximum color
if (query) in mapWithColor.keys():
# Take the maximum color and
# assign into maximum variable
maximum = max (maximum, mapWithColor[query])
# Find parent index
if (query % 2 = = 1 ):
query = (query - 1 ) / / 2
else :
query = query / / 2
# Return maximum color
return maximum
# Function to build hash map with color def buildMapWithColor(arr, n):
# To store color of each node
mapWithColor = {}
# For each number add a color number
for i in range (n):
# Assigning color
mapWithColor[arr[i]] = i + 1
# Return hash map
return mapWithColor
# Driver code arr = [ 3 , 2 , 1 , 3 ]
n = len (arr)
k = 7
# Build mapWithColor mapWithColor = buildMapWithColor(arr, n)
# Print the maximum color print (findColor(mapWithColor, k))
# This code is contributed by mohit kumar 29 |
// C# program to find color of the node using System;
using System.Collections.Generic;
class GFG
{ // Function to find color of the node
static int findColor(Dictionary< int , int > mapWithColor, int query)
{
// Maximum is to store maximum color
int maximum = 0;
// Loop to check all the parent
// values to get maximum color
while (query >= 1)
{
// Find the number into map and get maximum color
if (mapWithColor.ContainsKey(query))
{
// Take the maximum color and
// assign into maximum variable
maximum = Math.Max(maximum, mapWithColor[query]);
}
// Find parent index
if (query % 2 == 1)
query = (query - 1) / 2;
else
query = query / 2;
}
// Return maximum color
return maximum;
}
// Function to build hash map with color
static Dictionary< int , int > buildMapWithColor( int []arr, int n)
{
// To store color of each node
Dictionary< int , int > mapWithColor = new Dictionary< int , int >();
// For each number add a color number
for ( int i = 0; i < n; i++)
{
// Assigning color
if (mapWithColor.ContainsKey(arr[i]))
mapWithColor[arr[i]] = i + 1;
else
mapWithColor.Add(arr[i], i + 1);
}
// Return hash map
return mapWithColor;
}
// Driver code
public static void Main(String[] args)
{
int []arr = { 3, 2, 1, 3 };
int n = arr.Length;
int k = 7;
// Build mapWithColor
Dictionary< int , int > mapWithColor = buildMapWithColor(arr, n);
// Print the maximum color
Console.Write(findColor(mapWithColor, k));
}
} // This code is contributed by Rajput-Ji |
<script> // Javascript program to find color of the node
// Function to find color of the node function findColor(mapWithColor, query)
{
// Maximum is to store maximum color
let maximum = 0;
// Loop to check all the parent
// values to get maximum color
while (query >= 1)
{
// Find the number into map and get maximum color
if (mapWithColor.has(query))
{
// Take the maximum color and
// assign into maximum variable
maximum = Math.max(maximum, mapWithColor.get(query));
}
// Find parent index
if (query % 2 == 1)
query = (query - 1) / 2;
else
query = query / 2;
}
// Return maximum color
return maximum;
}
// Function to build hash map with color
function buildMapWithColor(arr, n)
{
// To store color of each node
let mapWithColor = new Map();
// For each number add a color number
for (let i = 0; i < n; i++)
{
// Assigning color
mapWithColor.set(arr[i], i + 1);
}
// Return hash map
return mapWithColor;
}
// Driver code
let arr = [ 3, 2, 1, 3 ];
let n = arr.length;
let k = 7;
// Build mapWithColor
let mapWithColor = buildMapWithColor(arr, n);
// Print the maximum color
document.write(findColor(mapWithColor, k));
// This code is contributed by susmitakundugoaldanga.
</script> |
4