# Count of Root to Leaf Paths consisting of at most M consecutive Nodes having value K

Given an Acyclic Undirected Graph in the form of a Binary Tree with root at vertex 1 and values at each vertices [1, N] denoted by the array arr[], the task is to find number of root to leaf paths that contain atmost m consecutive nodes with value K.

Example:

Input: arr[] = {1, 0, 1, 0, 0, 1, 0}, K = 1, M = 2 Output:
Explanation:
Path 1 : 1 -> 2 -> 4 contains maximum 1 consecutive K
Path 2 : 1 -> 2 -> 5 contains maximum 1 consecutive K
Path 3 : 1 -> 3 -> 6 contains maximum 3 consecutive K
Path 4 : 1 -> 3 -> 7 contains maximum 2 consecutive K
Since the given value of M is 2, therefore there are 3 paths that contains atmost 2 consecutive K.

Input: arr[] = {2, 1, 3, 2, 1, 2, 1, 4, 3, 5, 2}, K = 2, M = 2

```            2
/     \
1       3
/   \    /  \
2     1  2    1
/  \   / \
4    3 5   2
```

Output:

Approach:
The problem can be solved using Depth First Search approach:

• Depth First Search can be used to traverse all the paths from the root vertex.
• Every time if value at the present node is K, increment the count.
• Otherwise, set count to 0.
• If count exceeds M, then return.
• Otherwise, traverse its neighboring nodes and repeat the above steps.
• Finally print the value of count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Initialize the adjacency ` `// list and visited array ` `vector<``int``> adj; ` `int` `visited = { 0 }; ` `int` `ans = 0; ` ` `  `// Function to find the number of root to ` `// leaf paths that contain atmost m ` `// consecutive nodes with value k ` `void` `dfs(``int` `node, ``int` `count, ``int` `m, ` `         ``int` `arr[], ``int` `k) ` `{ ` `    ``// Mark the current node ` `    ``// as visited ` `    ``visited[node] = 1; ` ` `  `    ``// If value at current node is k ` `    ``if` `(arr[node - 1] == k) { ` ` `  `        ``// Increment counter ` `        ``count++; ` `    ``} ` `    ``else` `{ ` `        ``count = 0; ` `    ``} ` ` `  `    ``// If count is greater than m ` `    ``// return from that path ` `    ``if` `(count > m) { ` `        ``return``; ` `    ``} ` ` `  `    ``// Path is allowed if size of present node ` `    ``// becomes 0 i.e it has no child root and ` `    ``// no more than m consecutive 1's ` `    ``if` `(adj[node].size() == 1 && node != 1) { ` `        ``ans++; ` `    ``} ` ` `  `    ``for` `(``auto` `x : adj[node]) { ` `        ``if` `(!visited[x]) { ` `            ``dfs(x, count, m, arr, k); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 1, 3, 2, 1, 2, 1 }; ` `    ``int` `N = 7, K = 2, M = 2; ` ` `  `    ``// Desigining the tree ` `    ``adj.push_back(2); ` `    ``adj.push_back(1); ` ` `  `    ``adj.push_back(3); ` `    ``adj.push_back(1); ` ` `  `    ``adj.push_back(4); ` `    ``adj.push_back(2); ` ` `  `    ``adj.push_back(5); ` `    ``adj.push_back(2); ` ` `  `    ``adj.push_back(6); ` `    ``adj.push_back(3); ` ` `  `    ``adj.push_back(7); ` `    ``adj.push_back(3); ` ` `  `    ``// Counter counts no. ` `    ``// of consecutive nodes ` `    ``int` `counter = 0; ` ` `  `    ``dfs(1, counter, M, arr, K); ` ` `  `    ``cout << ans << ``"\n"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Initialize the adjacency ` `// list and visited array ` `@SuppressWarnings``(``"unchecked"``) ` `static` `Vector []adj = ``new` `Vector[``100005``]; ` `static` `int` `[]visited = ``new` `int``[``100005``]; ` `static` `int` `ans = ``0``; ` ` `  `// Function to find the number of root to ` `// leaf paths that contain atmost m ` `// consecutive nodes with value k ` `static` `void` `dfs(``int` `node, ``int` `count, ``int` `m, ` `                ``int` `arr[], ``int` `k) ` `{ ` `     `  `    ``// Mark the current node ` `    ``// as visited ` `    ``visited[node] = ``1``; ` ` `  `    ``// If value at current node is k ` `    ``if` `(arr[node - ``1``] == k) ` `    ``{ ` `         `  `        ``// Increment counter ` `        ``count++; ` `    ``} ` `    ``else` `    ``{ ` `        ``count = ``0``; ` `    ``} ` ` `  `    ``// If count is greater than m ` `    ``// return from that path ` `    ``if` `(count > m) ` `    ``{ ` `        ``return``; ` `    ``} ` ` `  `    ``// Path is allowed if size of present node ` `    ``// becomes 0 i.e it has no child root and ` `    ``// no more than m consecutive 1's ` `    ``if` `(adj[node].size() == ``1` `&& node != ``1``)  ` `    ``{ ` `        ``ans++; ` `    ``} ` ` `  `    ``for``(``int` `x : adj[node]) ` `    ``{ ` `        ``if` `(visited[x] == ``0``) ` `        ``{ ` `            ``dfs(x, count, m, arr, k); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``2``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1` `}; ` `    ``int` `N = ``7``, K = ``2``, M = ``2``; ` `     `  `    ``for``(``int` `i = ``0``; i < adj.length; i++) ` `        ``adj[i] = ``new` `Vector(); ` `         `  `    ``// Desigining the tree ` `    ``adj[``1``].add(``2``); ` `    ``adj[``2``].add(``1``); ` ` `  `    ``adj[``1``].add(``3``); ` `    ``adj[``3``].add(``1``); ` ` `  `    ``adj[``2``].add(``4``); ` `    ``adj[``4``].add(``2``); ` ` `  `    ``adj[``2``].add(``5``); ` `    ``adj[``5``].add(``2``); ` ` `  `    ``adj[``3``].add(``6``); ` `    ``adj[``6``].add(``3``); ` ` `  `    ``adj[``3``].add(``7``); ` `    ``adj[``7``].add(``3``); ` ` `  `    ``// Counter counts no. ` `    ``// of consecutive nodes ` `    ``int` `counter = ``0``; ` ` `  `    ``dfs(``1``, counter, M, arr, K); ` ` `  `    ``System.out.print(ans + ``"\n"``); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Initialize the adjacency ` `// list and visited array ` `static` `List<``int``> []adj = ``new` `List<``int``>; ` `static` `int` `[]visited = ``new` `int``; ` `static` `int` `ans = 0; ` ` `  `// Function to find the number of root to ` `// leaf paths that contain atmost m ` `// consecutive nodes with value k ` `static` `void` `dfs(``int` `node, ``int` `count, ``int` `m, ` `                ``int` `[]arr, ``int` `k) ` `{ ` `     `  `    ``// Mark the current node ` `    ``// as visited ` `    ``visited[node] = 1; ` ` `  `    ``// If value at current node is k ` `    ``if` `(arr[node - 1] == k) ` `    ``{ ` `         `  `        ``// Increment counter ` `        ``count++; ` `    ``} ` `    ``else` `    ``{ ` `        ``count = 0; ` `    ``} ` ` `  `    ``// If count is greater than m ` `    ``// return from that path ` `    ``if` `(count > m) ` `    ``{ ` `        ``return``; ` `    ``} ` ` `  `    ``// Path is allowed if size of present node ` `    ``// becomes 0 i.e it has no child root and ` `    ``// no more than m consecutive 1's ` `    ``if` `(adj[node].Count == 1 && node != 1)  ` `    ``{ ` `        ``ans++; ` `    ``} ` ` `  `    ``foreach``(``int` `x ``in` `adj[node]) ` `    ``{ ` `        ``if` `(visited[x] == 0) ` `        ``{ ` `            ``dfs(x, count, m, arr, k); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `[]arr = { 2, 1, 3, 2, 1, 2, 1 }; ` `    ``int` `K = 2, M = 2; ` `     `  `    ``for``(``int` `i = 0; i < adj.Length; i++) ` `        ``adj[i] = ``new` `List<``int``>(); ` `         `  `    ``// Desigining the tree ` `    ``adj.Add(2); ` `    ``adj.Add(1); ` ` `  `    ``adj.Add(3); ` `    ``adj.Add(1); ` ` `  `    ``adj.Add(4); ` `    ``adj.Add(2); ` ` `  `    ``adj.Add(5); ` `    ``adj.Add(2); ` ` `  `    ``adj.Add(6); ` `    ``adj.Add(3); ` ` `  `    ``adj.Add(7); ` `    ``adj.Add(3); ` ` `  `    ``// Counter counts no. ` `    ``// of consecutive nodes ` `    ``int` `counter = 0; ` ` `  `    ``dfs(1, counter, M, arr, K); ` ` `  `    ``Console.Write(ans + ``"\n"``); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

Output:

```4
```

Time Complexity: O(V + E)
Auxiliary Space: O(V)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.