Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Count the number of nodes in a Graph whose sum of neighbors is at most K

  • Last Updated : 03 Dec, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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, 2



Input: 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++




// 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




// 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));
    }
}


C#




// 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


Javascript




<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>


Output

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)




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!