Skip to content
Related Articles

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 <bits/stdc++.h>
using namespace std;
  
// Function to return the number of ways
// having weight as wt in K-ary tree
int solve(int dp[][2], 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][2];
    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.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

My Personal Notes arrow_drop_up
Recommended Articles
Page :