Number of unique paths in tree such that every path has a value greater than K - GeeksforGeeks

25 Jun, 2021
Given a tree as set of edges such that every node has unique value. We are also given a value k, the task is to count the unique paths in the tree such that every path has a value greater than K. A path value is said to be > K if every edge contributing in the path is connecting two nodes both of which have values > K.
Examples: 
Input:  
Output: 9 
Approach: The idea is to not form the tree with all the given edges. We only add an edge if it satisfies the condition of > k. In this case, a number of trees will be formed. While forming the different trees, we will only add the edge into the tree if both the node value are greater than K. After this, various number of trees will be created. Run a DFS for every node which in the end traverses the complete tree with which the node is attached and count the number of nodes in every tree. The number of unique paths for every tree which has X number of nodes is X * (X – 1) / 2. 
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to count the number of nodes// in the tree using DFSint dfs(int node, int parent, list<int>* adj, bool vis[]){     // Base case    int ans = 1;     // Mark as visited    vis[node] = true;     // Traverse for all children    for (auto it : adj[node]) {         // If not equal to parent        if (it != parent)            ans += dfs(it, node, adj, vis);    }    return ans;} // Function that returns the count of// unique pathsint countPaths(list<int>* adj, int k, int maxn){     // An array that marks if the node    // is visited or not    bool vis[maxn + 1];    int ans = 0;     // Initially marked as false    memset(vis, false, sizeof vis);     // Traverse till max value of node    for (int i = 1; i <= maxn; i++) {         // If not visited        if (!vis[i]) {             // Get the number of nodes in that            // tree            int numNodes = dfs(i, 0, adj, vis);             // Total unique paths in the current            // tree where numNodes is the total            // nodes in the tree            ans += numNodes * (numNodes - 1) / 2;        }    }    return ans;} // Function to add edges to tree if value// is less than Kvoid addEdge(list<int>* adj, int u, int v, int k){    if (u > k && v > k) {        adj[u].push_back(v);        adj[v].push_back(u);    }} // Driver codeint main(){    int maxn = 12;     list<int>* adj = new list<int>[maxn + 1];    int k = 3;     // Create undirected edges    addEdge(adj, 2, 11, k);    addEdge(adj, 2, 6, k);    addEdge(adj, 5, 11, k);    addEdge(adj, 5, 10, k);    addEdge(adj, 5, 12, k);    addEdge(adj, 6, 7, k);    addEdge(adj, 6, 8, k);     cout << countPaths(adj, k, maxn);     return 0;}
// Java implementation of the approachimport java.util.*; class GFG{     // Function to count the number of nodes    // in the tree using DFS    static int dfs(int node, int parent,                Vector<Integer>[] adj, boolean[] vis)    {         // Base case        int ans = 1;         // Mark as visited        vis[node] = true;         // Traverse for all children        for (Integer it : adj[node])        {             // If not equal to parent            if (it != parent)                ans += dfs(it, node, adj, vis);        }        return ans;    }     // Function that returns the count of    // unique paths    static int countPaths(Vector<Integer>[] adj,                        int k, int maxn)    {         // An array that marks if the node        // is visited or not        boolean[] vis = new boolean[maxn + 1];        int ans = 0;         // Initially marked as false        Arrays.fill(vis, false);         // Traverse till max value of node        for (int i = 1; i <= maxn; i++)        {             // If not visited            if (!vis[i])            {                 // Get the number of nodes in that                // tree                int numNodes = dfs(i, 0, adj, vis);                 // Total unique paths in the current                // tree where numNodes is the total                // nodes in the tree                ans += numNodes * (numNodes - 1) / 2;            }        }        return ans;    }     // Function to add edges to tree if value    // is less than K    static void addEdge(Vector<Integer>[] adj,                        int u, int v, int k)    {        if (u > k && v > k) {            adj[u].add(v);            adj[v].add(u);        }    }     // Driver Code    public static void main(String[] args)    {        int maxn = 12;         @SuppressWarnings("unchecked")        Vector<Integer>[] adj = new Vector[maxn + 1];        for (int i = 0; i < maxn + 1; i++)        {            adj[i] = new Vector<>();        }        int k = 3;         // Create undirected edges        addEdge(adj, 2, 11, k);        addEdge(adj, 2, 6, k);        addEdge(adj, 5, 11, k);        addEdge(adj, 5, 10, k);        addEdge(adj, 5, 12, k);        addEdge(adj, 6, 7, k);        addEdge(adj, 6, 8, k);         System.out.println(countPaths(adj, k, maxn));    }} // This code is contributed by// sanjeev2552
# Python3 implementation of the approach # Function to count the number of# nodes in the tree using DFSdef dfs(node, parent, adj, vis):     # Base case    ans = 1     # Mark as visited    vis[node] = True     # Traverse for all children    for it in adj[node]:         # If not equal to parent        if it != parent:            ans += dfs(it, node, adj, vis)         return ans # Function that returns the# count of unique pathsdef countPaths(adj, k, maxn):     # An array that marks if    # the node is visited or not    vis = [False] * (maxn + 1)    ans = 0     # Traverse till max value of node    for i in range(1, maxn+1):         # If not visited        if not vis[i]:             # Get the number of            # nodes in that tree            numNodes = dfs(i, 0, adj, vis)             # Total unique paths in the current            # tree where numNodes is the total            # nodes in the tree            ans += numNodes * (numNodes - 1) // 2             return ans # Function to add edges to# tree if value is less than Kdef addEdge(adj, u, v, k):     if u > k and v > k:        adj[u].append(v)        adj[v].append(u) # Driver codeif __name__ == "__main__":     maxn = 12     adj = [[] for i in range(maxn + 1)]    k = 3     # Create undirected edges    addEdge(adj, 2, 11, k)    addEdge(adj, 2, 6, k)    addEdge(adj, 5, 11, k)    addEdge(adj, 5, 10, k)    addEdge(adj, 5, 12, k)    addEdge(adj, 6, 7, k)    addEdge(adj, 6, 8, k)     print(countPaths(adj, k, maxn)) # This code is contributed by Rituraj Jain
// C# implementation of the approachusing System;using System.Collections.Generic; class GFG{ // Function to count the number of nodes// in the tree using DFSstatic int dfs(int node, int parent,          List<int>[] adj, bool[] vis){         // Base case    int ans = 1;     // Mark as visited    vis[node] = true;     // Traverse for all children    foreach(int it in adj[node])    {                 // If not equal to parent        if (it != parent)            ans += dfs(it, node, adj, vis);    }    return ans;} // Function that returns the count of// unique pathsstatic int countPaths(List<int>[] adj,                    int k, int maxn){     // An array that marks if the node    // is visited or not    bool[] vis = new bool[maxn + 1];    int ans = 0;     // Traverse till max value of node    for(int i = 1; i <= maxn; i++)    {                 // If not visited        if (!vis[i])        {                         // Get the number of nodes in that            // tree            int numNodes = dfs(i, 0, adj, vis);             // Total unique paths in the current            // tree where numNodes is the total            // nodes in the tree            ans += numNodes * (numNodes - 1) / 2;        }    }    return ans;} // Function to add edges to tree if value// is less than Kstatic void addEdge(List<int>[] adj,                    int u, int v, int k){    if (u > k && v > k)    {        adj[u].Add(v);        adj[v].Add(u);    }} // Driver Codepublic static void Main(String[] args){    int maxn = 12;     List<int>[] adj = new List<int>[maxn + 1];    for(int i = 0; i < maxn + 1; i++)    {        adj[i] = new List<int>();    }    int k = 3;     // Create undirected edges    addEdge(adj, 2, 11, k);    addEdge(adj, 2, 6, k);    addEdge(adj, 5, 11, k);    addEdge(adj, 5, 10, k);    addEdge(adj, 5, 12, k);    addEdge(adj, 6, 7, k);    addEdge(adj, 6, 8, k);     Console.WriteLine(countPaths(adj, k, maxn));}} // This code is contributed by Princi Singh
<script>     // JavaScript implementation of the approach         // Function to count the number of nodes    // in the tree using DFS    function dfs(node, parent, adj, vis)    {          // Base case        let ans = 1;          // Mark as visited        vis[node] = true;          // Traverse for all children        for (let it = 0; it < adj[node].length; it++)        {              // If not equal to parent            if (adj[node][it] != parent)                ans += dfs(adj[node][it], node, adj, vis);        }        return ans;    }      // Function that returns the count of    // unique paths    function countPaths(adj, k, maxn)    {          // An array that marks if the node        // is visited or not        let vis = new Array(maxn + 1);        let ans = 0;          // Initially marked as false        vis.fill(false);          // Traverse till max value of node        for (let i = 1; i <= maxn; i++)        {              // If not visited            if (!vis[i])            {                  // Get the number of nodes in that                // tree                let numNodes = dfs(i, 0, adj, vis);                  // Total unique paths in the current                // tree where numNodes is the total                // nodes in the tree                ans += numNodes * (numNodes - 1) / 2;            }        }        return ans;    }      // Function to add edges to tree if value    // is less than K    function addEdge(adj, u, v, k)    {        if (u > k && v > k) {            adj[u].push(v);            adj[v].push(u);        }    }         let maxn = 12;      let adj = new Array(maxn + 1);    for (let i = 0; i < maxn + 1; i++)    {      adj[i] = [];    }    let k = 3;     // Create undirected edges    addEdge(adj, 2, 11, k);    addEdge(adj, 2, 6, k);    addEdge(adj, 5, 11, k);    addEdge(adj, 5, 10, k);    addEdge(adj, 5, 12, k);    addEdge(adj, 6, 7, k);    addEdge(adj, 6, 8, k);     document.write(countPaths(adj, k, maxn));     </script>
9
 
rituraj_jain
sanjeev2552
princi singh
divyesh072019
DFS
Tree
DFS
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Tree Data Structure
DFS traversal of a tree using recursion
Top 50 Tree Coding Problems for Interviews
Find the node with minimum value in a Binary Search Tree
Real-time application of Data Structures
Print Binary Tree in 2-Dimensions
Iterative Postorder Traversal | Set 2 (Using One Stack)
Find maximum (or minimum) in Binary Tree
Difference between Min Heap and Max Heap
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)