# 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 the root at vertex 1 and values at each vertex [1, N] denoted by the array arr[], the task is to find the number of root to leaf paths that contain at most 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 the value at the present node is K, increment the count.
• Otherwise, set count to 0.
• If the count exceeds M, then return.
• Otherwise, traverse its neighboring nodes and repeat the above steps.
• Finally, print the value of the 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`

## Python3

 `# Python3 Program to implement` `# the above approach`   `# Initialize the adjacency` `# list and visited array` `adj ``=` `[[] ``for` `i ``in` `range``(``100005``)]` `visited ``=` `[ ``0` `for` `i ``in` `range``(``100005``)]` `ans ``=` `0``;` ` `  `# Function to find the number of root to` `# leaf paths that contain atmost m` `# consecutive nodes with value k` `def` `dfs(node, count, m, arr, k):` `    `  `    ``global` `ans` `    `  `    ``# Mark the current node` `    ``# as visited` `    ``visited[node] ``=` `1``;` ` `  `    ``# If value at current ` `    ``# node is k` `    ``if` `(arr[node ``-` `1``] ``=``=` `k):` ` `  `        ``# Increment counter` `        ``count ``+``=` `1``;` `    `  `    ``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` `(``len``(adj[node]) ``=``=` `1` `and` `node !``=` `1``):` `        ``ans ``+``=` `1` `    `  `    ``for` `x ``in` `adj[node]:        ` `        ``if` `(``not` `visited[x]):` `            ``dfs(x, count, m, arr, k);`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `        `  `    ``arr ``=` `[``2``, ``1``, ``3``, ``2``, ``1``, ``2``, ``1``]` `    ``N ``=` `7` `    ``K ``=` `2` `    ``M ``=` `2` ` `  `    ``# Desigining the tree` `    ``adj[``1``].append(``2``);` `    ``adj[``2``].append(``1``);` ` `  `    ``adj[``1``].append(``3``);` `    ``adj[``3``].append(``1``);` ` `  `    ``adj[``2``].append(``4``);` `    ``adj[``4``].append(``2``);` ` `  `    ``adj[``2``].append(``5``);` `    ``adj[``5``].append(``2``);` ` `  `    ``adj[``3``].append(``6``);` `    ``adj[``6``].append(``3``);` ` `  `    ``adj[``3``].append(``7``);` `    ``adj[``7``].append(``3``);` ` `  `    ``# Counter counts no.` `    ``# of consecutive nodes` `    ``counter ``=` `0``;` ` `  `    ``dfs(``1``, counter, M, arr, K);    ` `    ``print``(ans)        `   `# This code is contributed by rutvik_56`

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