Related Articles
Number of Paths of Weight W in a K-ary tree
• Difficulty Level : Hard
• Last Updated : 02 Apr, 2019

Given a K-ary tree, where each node is having K children and each edge has some weight. All the edges i.e. K, that goes from a particular node to all its children have weights in ascending order 1, 2, 3, …, K. Find the number of paths having total weight as W (sum of all edge weights in the path) starting from root and containing atleast one edge of weight atleast M.

Examples:

```Input : W = 3, K = 3, M = 2
Output : 3
Explanation : One path can be (1 + 2), second can be (2 + 1) and third is 3. Input : W = 4, K = 3, M = 2
Output : 6
```

Approach: This problem can be solved using dynamic programming approach. The idea is to maintain two states, one for the current weight to be required and other one for a boolean variable which denotes that the current path has included an edge of weight atleast M or not. Iterate over all possible edge weights i.e. K and recursively solve for the weight W – i for 1 ≤ i ≤ K. If the current edge weight is more than or equal to M, set the boolean variable as 1 for the next call.

Below is the implementation of above approach.

## C++

 `// C++ program to count the number of``// paths with weight W in a K-ary tree``#include ``using` `namespace` `std;`` ` `// Function to return the number of ways``// having weight as wt in K-ary tree``int` `solve(``int` `dp[], ``int` `wt, ``int` `K, ``int` `M,``          ``int` `used)``{``    ``// Return 0 if weight becomes less``    ``// than zero``    ``if` `(wt < 0)``        ``return` `0;`` ` `    ``if` `(wt == 0) {`` ` `        ``// Return one only if the``        ``// current path has included``        ``// edge weight of atleast M``        ``if` `(used)``            ``return` `1;``        ``return` `0;``    ``}`` ` `    ``if` `(dp[wt][used] != -1)``        ``return` `dp[wt][used];`` ` `    ``int` `ans = 0;``    ``for` `(``int` `i = 1; i <= K; i++) {`` ` `        ``// If the current edge weight``        ``// is greater than or equal to``        ``// M, set used as true``        ``if` `(i >= M)``            ``ans += solve(dp, wt - i,``                         ``K, M, used | 1);``        ``else``            ``ans += solve(dp, wt - i,``                         ``K, M, used);``    ``}``    ``return` `dp[wt][used] = ans;``}`` ` `// Driver Code to test above function``int` `main()``{``    ``int` `W = 3, K = 3, M = 2;``    ``int` `dp[W + 1];``    ``memset``(dp, -1, ``sizeof``(dp));``    ``cout << solve(dp, W, K, M, 0) << endl;``    ``return` `0;``}`

## Java

 `// Java program to count the number of ``// paths with weight W in a K-ary tree `` ` `class` `GFG ``{``    ``// Function to return the number of ways ``    ``// having weight as wt in K-ary tree `` ` `    ``public` `static` `int` `solve(``int``[][] dp, ``int` `wt, ``                            ``int` `K, ``int` `M, ``int` `used) ``    ``{``        ``// Return 0 if weight becomes less ``        ``// than zero ``        ``if` `(wt < ``0``) ``        ``{``            ``return` `0``;``        ``}`` ` `        ``if` `(wt == ``0``) ``        ``{`` ` `            ``// Return one only if the ``            ``// current path has included ``            ``// edge weight of atleast M ``            ``if` `(used == ``1``)``            ``{``                ``return` `1``;``            ``}``            ``return` `0``;``        ``}`` ` `        ``if` `(dp[wt][used] != -``1``)``        ``{``            ``return` `dp[wt][used];``        ``}`` ` `        ``int` `ans = ``0``;``        ``for` `(``int` `i = ``1``; i <= K; i++) ``        ``{`` ` `            ``// If the current edge weight ``            ``// is greater than or equal to ``            ``// M, set used as true ``            ``if` `(i >= M)``            ``{``                ``ans += solve(dp, wt - i,``                        ``K, M, used | ``1``);``            ``}``            ``else``            ``{``                ``ans += solve(dp, wt - i,``                        ``K, M, used);``            ``}``        ``}``        ``return` `dp[wt][used] = ans;``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args) ``    ``{`` ` `        ``int` `W = ``3``, K = ``3``, M = ``2``;``        ``int``[][] dp = ``new` `int``[W + ``1``][``2``];``        ``for` `(``int` `i = ``0``; i < W + ``1``; i++) ``        ``{``            ``for` `(``int` `j = ``0``; j < ``2``; j++) ``            ``{``                ``dp[i][j] = -``1``;``            ``}``        ``}``        ``System.out.print(solve(dp, W, K, M, ``0``) + ``"\n"``);``    ``}``}`` ` `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python 3 program to count the number of ``# paths with weight W in a K-ary tree ``import` `numpy as np`` ` `# Function to return the number of ways ``# having weight as wt in K-ary tree ``def` `solve(dp, wt, K, M, used) :``             ` `    ``# Return 0 if weight becomes less ``    ``# than zero ``    ``if` `(wt < ``0``) :``        ``return` `0`` ` `    ``if` `(wt ``=``=` `0``) :`` ` `        ``# Return one only if the ``        ``# current path has included ``        ``# edge weight of atleast M ``        ``if` `(used) :``            ``return` `1``        ``return` `0``     ` `    ``if` `(dp[wt][used] !``=` `-``1``) :``        ``return` `dp[wt][used] `` ` `    ``ans ``=` `0``    ``for` `i ``in` `range``(``1``, K ``+` `1``) : `` ` `        ``# If the current edge weight ``        ``# is greater than or equal to ``        ``# M, set used as true ``        ``if` `(i >``=` `M) :``            ``ans ``+``=` `solve(dp, wt ``-` `i, ``                         ``K, M, used | ``1``) ``        ``else` `:``            ``ans ``+``=` `solve(dp, wt ``-` `i, ``                         ``K, M, used) ``     ` `    ``dp[wt][used] ``=` `ans ``     ` `    ``return` `ans`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `: `` ` `    ``W ``=` `3``    ``K ``=` `3``    ``M ``=` `2``    ``dp ``=` `np.ones((W ``+` `1``, ``2``)); ``    ``dp ``=` `-``1` `*` `dp ``    ``print``(solve(dp, W, K, M, ``0``)) `` ` `# This code is contributed by Ryuga`

## C#

 `// C# program to count the number of ``// paths with weight W in a K-ary tree ``using` `System; ``   ` `class` `GFG ``{ ``    ``// Function to return the number of ways ``    ``// having weight as wt in K-ary tree ``    ``public` `static` `int` `solve(``int``[,] dp, ``int` `wt, ``int` `K, ``int` `M, ``int` `used) ``    ``{ ``        ``// Return 0 if weight becomes less ``        ``// than zero ``        ``if` `(wt < 0) ``            ``return` `0; ``       ` `        ``if` `(wt == 0) { ``       ` `            ``// Return one only if the ``            ``// current path has included ``            ``// edge weight of atleast M ``            ``if` `(used == 1) ``                ``return` `1; ``            ``return` `0; ``        ``} ``       ` `        ``if` `(dp[wt,used] != -1) ``            ``return` `dp[wt,used]; ``       ` `        ``int` `ans = 0; ``        ``for` `(``int` `i = 1; i <= K; i++) { ``       ` `            ``// If the current edge weight ``            ``// is greater than or equal to ``            ``// M, set used as true ``            ``if` `(i >= M) ``                ``ans += solve(dp, wt - i, ``                             ``K, M, used | 1); ``            ``else``                ``ans += solve(dp, wt - i, ``                             ``K, M, used); ``        ``} ``        ``return` `dp[wt,used] = ans; ``    ``} ``       ` `    ``// Driver Code to test above function ``    ``static` `void` `Main() ``    ``{ ``        ``int` `W = 3, K = 3, M = 2; ``        ``int``[,] dp = ``new` `int``[W + 1,2];``        ``for``(``int` `i = 0;i < W + 1; i++)``            ``for``(``int` `j = 0; j < 2; j++)``                ``dp[i,j] = -1;``        ``Console.Write(solve(dp, W, K, M, 0) + ``"\n"``);``    ``}``    ``//This code is contributed by DrRoot_``}`
Output:
```3
```

Time Complexity: O(W * K)

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