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: 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 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++ implementation of the approach #include <bits/stdc++.h> 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 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<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 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# 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 |
<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
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.