Given a graph root, and a value K, the task is to find the number of nodes in the graph whose sum of neighbors is less than K.
Example:
Input: root = 8 K = 14
/ \
2—3 7—3
/ \ \
5 6 0
\ \ / \
1 2 6 9
Output: 10
Explanation: Nodes with sum of neighbors less than 14 are the nodes with value 8, 7, 6, 9, 3(rightmost), 2, 5, 1, 6, 2Input: root = 2 K = 5
/ \
3 1
/ \
5 6
Output: 3
Approach: The given problem can be solved by using the depth-first search on the graph. The idea is to use recursion and visit every node to check the sum of its neighbor node is less than K. Below steps can be followed to solve the problem:
- Use recursion to apply depth-first search on the graph and use a hashset to store the visited nodes of the graph
- At every node iterate through the neighbors of that node and add their sum
- If the sum is greater than K then increment the count
- Return the count as the result
Below is the implementation of the above approach:
// C++ code for the above approach #include <bits/stdc++.h> using namespace std;
class Node
{ public :
vector<Node *> neighbors;
int val;
Node( int v)
{
val = v;
neighbors = {};
}
}; // Depth first search function to visit // every node of the graph and check if // sum of neighbor nodes is less than K void dfs(
Node *root,
set<Node *> &visited,
vector< int > &count, int K)
{ // If the current node is
// already visited then return
if (visited.find(root) != visited.end())
return ;
// Mark the current node as visited
visited.insert(root);
// Initialize a variable sum to
// calculate sum of neighbors
int sum = 0;
// Iterate through all neighbors
for (Node *n : root->neighbors)
{
sum += n->val;
}
// If sum is less than K then
// increment count by 1
if (sum < K)
count[0] = count[0] + 1;
for (Node *n : root->neighbors)
{
// Visit the neighbor nodes
dfs(n, visited, count, K);
}
} // Function to find the number of nodes // in the graph with sum less than K int nodeSumLessThanK(
Node *root, int K)
{ // Initialize the variable count
// to count the answer
vector< int > count(1, 0);
// Initialize a HashSet to
// store the visited nodes
set<Node *> visited;
// Apply DFS on the graph
dfs(root, visited, count, K);
// Return the answer stored in count
return count[0];
} // Driver code int main()
{ // Initialize the graph
Node *root = new Node(2);
root->neighbors.push_back( new Node(3));
root->neighbors.push_back( new Node(1));
root->neighbors[0]->neighbors.push_back( new Node(5));
root->neighbors[1]->neighbors.push_back( new Node(6));
int K = 5;
// Call the function
// and print the result
cout << (nodeSumLessThanK(root, K));
return 0;
} // This code is contributed by Potta Lokesh |
// Java implementation for the above approach import java.io.*;
import java.util.*;
class GFG {
static class Node {
List<Node> neighbors;
int val;
public Node( int val)
{
this .val = val;
neighbors = new ArrayList<>();
}
}
// Function to find the number of nodes
// in the graph with sum less than K
public static int nodeSumLessThanK(
Node root, int K)
{
// Initialize the variable count
// to count the answer
int [] count = new int [ 1 ];
// Initialize a HashSet to
// store the visited nodes
Set<Node> visited = new HashSet<>();
// Apply DFS on the graph
dfs(root, visited, count, K);
// Return the answer stored in count
return count[ 0 ];
}
// Depth first search function to visit
// every node of the graph and check if
// sum of neighbor nodes is less than K
public static void dfs(
Node root,
Set<Node> visited,
int [] count, int K)
{
// If the current node is
// already visited then return
if (visited.contains(root))
return ;
// Mark the current node as visited
visited.add(root);
// Initialize a variable sum to
// calculate sum of neighbors
int sum = 0 ;
// Iterate through all neighbors
for (Node n : root.neighbors) {
sum += n.val;
}
// If sum is less than K then
// increment count by 1
if (sum < K)
count[ 0 ]++;
for (Node n : root.neighbors) {
// Visit the neighbor nodes
dfs(n, visited, count, K);
}
}
// Driver code
public static void main(String[] args)
{
// Initialize the graph
Node root = new Node( 2 );
root.neighbors.add( new Node( 3 ));
root.neighbors.add( new Node( 1 ));
root.neighbors.get( 0 )
.neighbors.add( new Node( 5 ));
root.neighbors.get( 1 )
.neighbors.add( new Node( 6 ));
int K = 5 ;
// Call the function
// and print the result
System.out.println(
nodeSumLessThanK(root, K));
}
} |
# Python code for the above approach # Class to represent a node class Node:
def __init__( self , v):
self .val = v
self .neighbors = []
# Depth first search function to visit # every node of the graph and check if # sum of neighbor nodes is less than K def dfs(root, visited, count, K):
# If the current node is
# already visited then return
if root in visited:
return
# Mark the current node as visited
visited.add(root)
# Initialize a variable sum to
# calculate sum of neighbors
sum = 0
# Iterate through all neighbors
for n in root.neighbors:
sum + = n.val
# If sum is less than K then
# increment count by 1
if sum < K:
count[ 0 ] + = 1
for n in root.neighbors:
# Visit the neighbor nodes
dfs(n, visited, count, K)
# Function to find the number of nodes # in the graph with sum less than K def nodeSumLessThanK(root, K):
# Initialize the variable count
# to count the answer
count = [ 0 ]
# Initialize a set to store
# the visited nodes
visited = set ()
# Apply DFS on the graph
dfs(root, visited, count, K)
# Return the answer stored in count
return count[ 0 ]
# Driver code # Initialize the graph root = Node( 2 )
root.neighbors.append(Node( 3 ))
root.neighbors.append(Node( 1 ))
root.neighbors[ 0 ].neighbors.append(Node( 5 ))
root.neighbors[ 1 ].neighbors.append(Node( 6 ))
K = 5
# Call the function # and print the result print (nodeSumLessThanK(root, K))
|
// C# implementation for the above approach using System;
using System.Collections.Generic;
public class GFG {
class Node {
public List<Node> neighbors;
public int val;
public Node( int val)
{
this .val = val;
neighbors = new List<Node>();
}
}
// Function to find the number of nodes
// in the graph with sum less than K
static int nodeSumLessThanK(
Node root, int K)
{
// Initialize the variable count
// to count the answer
int [] count = new int [1];
// Initialize a HashSet to
// store the visited nodes
HashSet<Node> visited = new HashSet<Node>();
// Apply DFS on the graph
dfs(root, visited, count, K);
// Return the answer stored in count
return count[0];
}
// Depth first search function to visit
// every node of the graph and check if
// sum of neighbor nodes is less than K
static void dfs(
Node root,
HashSet<Node> visited,
int [] count, int K)
{
// If the current node is
// already visited then return
if (visited.Contains(root))
return ;
// Mark the current node as visited
visited.Add(root);
// Initialize a variable sum to
// calculate sum of neighbors
int sum = 0;
// Iterate through all neighbors
foreach (Node n in root.neighbors) {
sum += n.val;
}
// If sum is less than K then
// increment count by 1
if (sum < K)
count[0]++;
foreach (Node n in root.neighbors) {
// Visit the neighbor nodes
dfs(n, visited, count, K);
}
}
// Driver code
public static void Main(String[] args)
{
// Initialize the graph
Node root = new Node(2);
root.neighbors.Add( new Node(3));
root.neighbors.Add( new Node(1));
root.neighbors[0]
.neighbors.Add( new Node(5));
root.neighbors[1]
.neighbors.Add( new Node(6));
int K = 5;
// Call the function
// and print the result
Console.WriteLine(
nodeSumLessThanK(root, K));
}
} // This code is contributed by shikhasingrajput |
<script> // Javascript code for the above approach class Node { constructor(v) {
this .val = v;
this .neighbors = [];
}
}; // Depth first search function to visit // every node of the graph and check if // sum of neighbor nodes is less than K function dfs(root, visited, count, K) {
// If the current node is
// already visited then return
if (visited.has(root))
return ;
// Mark the current node as visited
visited.add(root);
// Initialize a variable sum to
// calculate sum of neighbors
let sum = 0;
// Iterate through all neighbors
for (let n of root.neighbors) {
sum += n.val;
}
// If sum is less than K then
// increment count by 1
if (sum < K)
count[0] = count[0] + 1;
for (let n of root.neighbors) {
// Visit the neighbor nodes
dfs(n, visited, count, K);
}
} // Function to find the number of nodes // in the graph with sum less than K function nodeSumLessThanK(root, K) {
// Initialize the variable count
// to count the answer
let count = new Array(1).fill(0);
// Initialize a HashSet to
// store the visited nodes
let visited = new Set();
// Apply DFS on the graph
dfs(root, visited, count, K);
// Return the answer stored in count
return count[0];
} // Driver code // Initialize the graph let root = new Node(2);
root.neighbors.push( new Node(3));
root.neighbors.push( new Node(1));
root.neighbors[0].neighbors.push( new Node(5));
root.neighbors[1].neighbors.push( new Node(6));
let K = 5; // Call the function // and print the result document.write(nodeSumLessThanK(root, K)); // This code is contributed by gfgking. </script> |
3
Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges in the graph
Auxiliary Space: O(V)