Related Articles
Count of Root to Leaf Paths consisting of at most M consecutive Nodes having value K
• Difficulty Level : Easy
• Last Updated : 19 Oct, 2020

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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up