Given a Binary search tree(BST) and a positive integer K, find the maximum product of k integers in the tree. Return the product as an integer.
Examples:
Input: K = 3,
10
/ \
3 12
/ \ / \
2 4 11 13
Output: 1716
Explanation: The maximum product of 3 integers can be obtained by selecting 12, 13, and 11. The product is 12*13*11 = 1716. Hence the output is 1716, which is the maximum product of 3 integers.Input: K = 2,
5
/ \
2 6
/ \ \
1 3 8
Output: 48
Explanation: The maximum product of 2 integers can be obtained by selecting 6 and 8. The product is 6*8 = 48. Hence the output is 48, which is the maximum product of 2 integers.
Approach: This can be solved with the following idea:
We can find the maximum product of K integers in the BST using the following approach:
- Traverse the BST and store all the nodes in a vector.
- Sort the vector in decreasing order of node values.
- Select the first k nodes from the sorted vector and compute their product.
- Return the product.
Below are the steps to implement the above idea :
- Define a class for the BST node, which contains the node value and pointers to the left and right child nodes.
- Define a function to traverse the BST in any order (preorder, inorder, postorder) and store the nodes in a vector.
- Define a function to sort the vector in decreasing order of node values.
- Define a function to compute the product of K nodes.
- Define a function to find the maximum product of k nodes in the BST, which uses the above functions.
Below is the code for the above approach:
// C++ Implementation #include <bits/stdc++.h> using namespace std;
// Define a class for the BST node class Node {
public :
int value;
Node* left;
Node* right;
Node( int val)
{
value = val;
left = nullptr;
right = nullptr;
}
}; // Function to traverse the BST in any // order and store the nodes in a vector void traverse(Node* root, vector<Node*>& nodes)
{ if (root == nullptr) {
return ;
}
traverse(root->left, nodes);
nodes.push_back(root);
traverse(root->right, nodes);
} // Function to sort the vector in // decreasing order of node values bool cmp(Node* a, Node* b) { return a->value > b->value; }
// Function to compute the product // of k nodes int product(vector<Node*>& nodes, int k)
{ int prod = 1;
for ( int i = 0; i < k; i++) {
prod *= nodes[i]->value;
}
return prod;
} // Function to find the maximum product // of k nodes in the BST int max_product(Node* root, int k)
{ // Create a vector to store the nodes
vector<Node*> nodes;
// Traverse the BST and store the
// nodes in the vector
traverse(root, nodes);
// Sort the vector in decreasing
// order of node values
sort(nodes.begin(), nodes.end(), cmp);
// If the number of nodes in the
// BST is less than k, return 0
if (nodes.size() < k) {
return 0;
}
// Compute the product of the first
// k nodes in the sorted vector
int prod = product(nodes, k);
// Return the product
return prod;
} // Driver code int main()
{ // Create the BST
/*
10
/ \
3 12
/ \ / \
2 4 11 13
*/
Node* root1 = new Node(10);
root1->left = new Node(3);
root1->right = new Node(12);
root1->left->left = new Node(2);
root1->left->right = new Node(4);
root1->right->left = new Node(11);
root1->right->right = new Node(13);
// Function call
cout << max_product(root1, 3) << endl;
return 0;
} |
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
// Define a class for the BST node class Node {
public int value;
public Node left;
public Node right;
public Node( int val) {
value = val;
left = null ;
right = null ;
}
} public class MaximumProductBST {
// Function to traverse the BST in any
// order and store the nodes in a list
static void traverse(Node root, List<Node> nodes) {
if (root == null ) {
return ;
}
traverse(root.left, nodes);
nodes.add(root);
traverse(root.right, nodes);
}
// Function to sort the list in
// decreasing order of node values
static Comparator<Node> comparator = (a, b) -> b.value - a.value;
// Function to compute the product
// of k nodes
static int product(List<Node> nodes, int k) {
int prod = 1 ;
for ( int i = 0 ; i < k; i++) {
prod *= nodes.get(i).value;
}
return prod;
}
// Function to find the maximum product
// of k nodes in the BST
static int maxProduct(Node root, int k) {
// Create a list to store the nodes
List<Node> nodes = new ArrayList<>();
// Traverse the BST and store the
// nodes in the list
traverse(root, nodes);
// Sort the list in decreasing
// order of node values
Collections.sort(nodes, comparator);
// If the number of nodes in the
// BST is less than k, return 0
if (nodes.size() < k) {
return 0 ;
}
// Compute the product of the first
// k nodes in the sorted list
int prod = product(nodes, k);
// Return the product
return prod;
}
// Driver code
public static void main(String[] args) {
// Create the BST
/*
10
/ \
3 12
/ \ / \
2 4 11 13
*/
Node root = new Node( 10 );
root.left = new Node( 3 );
root.right = new Node( 12 );
root.left.left = new Node( 2 );
root.left.right = new Node( 4 );
root.right.left = new Node( 11 );
root.right.right = new Node( 13 );
// Function call
System.out.println(maxProduct(root, 3 ));
}
} // This code was contributed by codearcade |
# Python Implementation # Define a class for the BST node class Node:
def __init__( self , val):
self .value = val
self .left = None
self .right = None
# Function to traverse the BST in any # order and store the nodes in a list def traverse(root, nodes):
if root is None :
return
traverse(root.left, nodes)
nodes.append(root)
traverse(root.right, nodes)
# Function to sort the list in # decreasing order of node values def cmp (a, b):
return a.value > b.value
# Function to compute the product # of k nodes def product(nodes, k):
prod = 1
for i in range (k):
prod * = nodes[i].value
return prod
# Function to find the maximum product # of k nodes in the BST def max_product(root, k):
# Create a list to store the nodes
nodes = []
# Traverse the BST and store the
# nodes in the list
traverse(root, nodes)
# Sort the list in decreasing
# order of node values
nodes.sort(key = lambda x: x.value, reverse = True )
# If the number of nodes in the
# BST is less than k, return 0
if len (nodes) < k:
return 0
# Compute the product of the first
# k nodes in the sorted list
prod = product(nodes, k)
# Return the product
return prod
# Driver code if __name__ = = "__main__" :
# Create the BST
"""
10
/ \
3 12
/ \ / \
2 4 11 13
"""
root1 = Node( 10 )
root1.left = Node( 3 )
root1.right = Node( 12 )
root1.left.left = Node( 2 )
root1.left.right = Node( 4 )
root1.right.left = Node( 11 )
root1.right.right = Node( 13 )
# Function call
print (max_product(root1, 3 ))
# This code is contributed by Susobhan Akhuli |
// C# Implementation using System;
using System.Collections.Generic;
using System.Linq;
// Define a class for the BST node class Node {
public int value;
public Node left;
public Node right;
public Node( int val)
{
value = val;
left = null ;
right = null ;
}
} class Program {
// Function to traverse the BST in any
// order and store the nodes in a list
static void Traverse(Node root, List<Node> nodes)
{
if (root == null ) {
return ;
}
Traverse(root.left, nodes);
nodes.Add(root);
Traverse(root.right, nodes);
}
// Function to sort the list in
// decreasing order of node values
static int CompareNodes(Node a, Node b)
{
return b.value.CompareTo(a.value);
}
// Function to compute the product
// of k nodes
static int Product(List<Node> nodes, int k)
{
int prod = 1;
for ( int i = 0; i < k; i++) {
prod *= nodes[i].value;
}
return prod;
}
// Function to find the maximum product
// of k nodes in the BST
static int MaxProduct(Node root, int k)
{
// Create a list to store the nodes
List<Node> nodes = new List<Node>();
// Traverse the BST and store the
// nodes in the list
Traverse(root, nodes);
// Sort the list in decreasing
// order of node values
nodes.Sort(CompareNodes);
// If the number of nodes in the
// BST is less than k, return 0
if (nodes.Count < k) {
return 0;
}
// Compute the product of the first
// k nodes in the sorted list
int prod = Product(nodes, k);
// Return the product
return prod;
}
// Driver code
static void Main()
{
// Create the BST
/*
10
/ \
3 12
/ \ / \
2 4 11 13
*/
Node root1 = new Node(10);
root1.left = new Node(3);
root1.right = new Node(12);
root1.left.left = new Node(2);
root1.left.right = new Node(4);
root1.right.left = new Node(11);
root1.right.right = new Node(13);
// Function call
Console.WriteLine(MaxProduct(root1, 3));
}
} // This code is contributed by Susobhan Akhuli |
<script> // JavaScript code for the above approach // Define a class for the BST node class Node { constructor(val) {
this .value = val;
this .left = null ;
this .right = null ;
}
} // Function to traverse the BST in any order and store the nodes in a vector function traverse(root, nodes) {
if (root === null ) {
return ;
}
traverse(root.left, nodes);
nodes.push(root);
traverse(root.right, nodes);
} // Function to sort the vector in decreasing order of node values function cmp(a, b) {
return a.value > b.value ? -1 : 1;
} // Function to compute the product of k nodes function product(nodes, k) {
let prod = 1;
for (let i = 0; i < k; i++) {
prod *= nodes[i].value;
}
return prod;
} // Function to find the maximum product of k nodes in the BST function maxProduct(root, k) {
// Create a vector to store the nodes
const nodes = [];
// Traverse the BST and store the nodes in the vector
traverse(root, nodes);
// Sort the vector in decreasing order of node values
nodes.sort(cmp);
// If the number of nodes in the BST is less than k, return 0
if (nodes.length < k) {
return 0;
}
// Compute the product of the first k nodes in the sorted vector
const prod = product(nodes, k);
// Return the product
return prod;
} // Create the BST /* 10
/ \
3 12
/ \ / \
2 4 11 13
*/
const root = new Node(10);
root.left = new Node(3);
root.right = new Node(12);
root.left.left = new Node(2);
root.left.right = new Node(4);
root.right.left = new Node(11);
root.right.right = new Node(13);
// Function call document.write(maxProduct(root, 3)); // This code is contributed by Susobhan Akhuli </script> |
1716
Time Complexity: O(n*logn)
Auxiliary Space: O(n)