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

Last Updated : 16 Jun, 2022

Given a tree as a set of edges such that every node has a 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 to the path is connecting two nodes both of which have values > K.

Examples:

Input:

Output:

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

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to count the number of nodes` `// in the tree using DFS` `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` `    ``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 paths` `int` `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 K` `void` `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 code` `int` `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

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG ` `{`   `    ``// Function to count the number of nodes` `    ``// in the tree using DFS` `    ``static` `int` `dfs(``int` `node, ``int` `parent, ` `                ``Vector[] 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[] 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[] 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[] 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

 `# Python3 implementation of the approach `   `# Function to count the number of ` `# nodes in the tree using DFS ` `def` `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 paths ` `def` `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 K ` `def` `addEdge(adj, u, v, k): `   `    ``if` `u > k ``and` `v > k:` `        ``adj[u].append(v) ` `        ``adj[v].append(u) `   `# Driver code ` `if` `__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#

 `// C# implementation of the approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to count the number of nodes` `// in the tree using DFS` `static` `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 paths` `static` `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 K` `static` `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 Code` `public` `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`

## Javascript

 ``

Output:

`9`

Time Complexity: O(N), as we are using recursion to traverse N times. Where N is the total number of nodes.

Auxiliary Space: O(N), as we are using extra space for the visited array. Where N is the total number of nodes.

Share your thoughts in the comments