# Number of ways to cut a stick of length N into in even length at most K units long pieces

• Difficulty Level : Medium
• Last Updated : 02 Aug, 2022

Given a rod of length N units, the task is to find the number of ways to cut the rod into parts such that the length of each part is even and each part is at most K units.

Examples:

Input: N = 6, K = 4
Output:
Explanation:
Rod of length 6 units needs to be into parts having length at most 4 units. Hence cut the rod in three ways:
Way 1: 2 units + 2 units + 2 units
Way 2: 2 units + 4 units
Way 3: 4 units + 2 units

Input: N = 4, K = 2
Output:
Explanation:
Rod of length 4 units needs to be into parts having length at most 2 units. Hence cut the rod in 2 + 2 units.

Approach: The idea is to use dynamic programming where the optimal sub-structure is that the length of each part should be even. Count all the way to cut the rod by calling the function recursively for a piece obtained after a cut.

Below is the implementation of the above approach:

## C++14

 `// C++14 program for the above approach``#include ``using` `namespace` `std;` `// Recursive Function to count``// the total number of ways``int` `solve(``int` `n, ``int` `k, ``int` `mod, ``int` `dp[])``{``    ``// Base case if no-solution exist``    ``if` `(n < 0)``        ``return` `0;` `    ``// Condition if a solution exist``    ``if` `(n == 0)``        ``return` `1;` `    ``// Check if already calculated``    ``if` `(dp[n] != -1)``        ``return` `dp[n];` `    ``// Initialize counter``    ``int` `cnt = 0;``    ``for` `(``int` `i = 2; i <= k; i += 2) {``        ``// Recursive call``        ``cnt = (cnt % mod``               ``+ solve(n - i, k, mod, dp)``                     ``% mod)``              ``% mod;``    ``}` `    ``// Store the answer``    ``dp[n] = cnt;` `    ``// Return the answer``    ``return` `cnt;``}` `// Driver code``int` `main()``{` `    ``const` `int` `mod = 1e9 + 7;``    ``int` `n = 4, k = 2;``    ``int` `dp[n + 1];``    ``memset``(dp, -1, ``sizeof``(dp));``    ``int` `ans = solve(n, k, mod, dp);``    ``cout << ans << ``'\n'``;` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Recursive Function to count``// the total number of ways``static` `int` `solve(``int` `n, ``int` `k, ``int` `mod, ``int` `dp[])``{``    ` `    ``// Base case if no-solution exist``    ``if` `(n < ``0``)``        ``return` `0``;` `    ``// Condition if a solution exist``    ``if` `(n == ``0``)``        ``return` `1``;` `    ``// Check if already calculated``    ``if` `(dp[n] != -``1``)``        ``return` `dp[n];` `    ``// Initialize counter``    ``int` `cnt = ``0``;``    ``for``(``int` `i = ``2``; i <= k; i += ``2``)``    ``{``        ` `        ``// Recursive call``        ``cnt = (cnt % mod + solve(n - i, k, mod,``               ``dp) % mod) % mod;``    ``}` `    ``// Store the answer``    ``dp[n] = cnt;` `    ``// Return the answer``    ``return` `cnt;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `mod = (``int``)(1e9 + ``7``);``    ``int` `n = ``4``, k = ``2``;``    ` `    ``int` `[]dp = ``new` `int``[n + ``1``];``    ``for``(``int` `i = ``0``; i < n + ``1``; i++)``        ``dp[i] = -``1``;``        ` `    ``int` `ans = solve(n, k, mod, dp);``    ` `    ``System.out.println(ans);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Recursive function to count``# the total number of ways``def` `solve(n, k, mod, dp):``    ` `    ``# Base case if no-solution exist``    ``if` `(n < ``0``):``        ``return` `0` `    ``# Condition if a solution exist``    ``if` `(n ``=``=` `0``):``        ``return` `1` `    ``# Check if already calculated``    ``if` `(dp[n] !``=` `-``1``):``        ``return` `dp[n]` `    ``# Initialize counter``    ``cnt ``=` `0``    ``for` `i ``in` `range``(``2``, k ``+` `1``, ``2``):``        ` `        ``# Recursive call``        ``cnt ``=` `((cnt ``%` `mod ``+``                ``solve(n ``-` `i, k, mod, dp) ``%``                                    ``mod) ``%` `mod)``                                   ` `    ``# Store the answer``    ``dp[n] ``=` `cnt` `    ``# Return the answer``    ``return` `int``(cnt)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``mod ``=` `1e9` `+` `7``    ``n ``=` `4``    ``k ``=` `2``    ` `    ``dp ``=` `[``-``1``] ``*` `(n ``+` `1``)``    ``ans ``=` `solve(n, k, mod, dp)``    ` `    ``print``(ans)``    ` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Recursive function to count``// the total number of ways``static` `int` `solve(``int` `n, ``int` `k, ``int` `mod, ``int` `[]dp)``{``    ` `    ``// Base case if no-solution exist``    ``if` `(n < 0)``        ``return` `0;` `    ``// Condition if a solution exist``    ``if` `(n == 0)``        ``return` `1;` `    ``// Check if already calculated``    ``if` `(dp[n] != -1)``        ``return` `dp[n];` `    ``// Initialize counter``    ``int` `cnt = 0;``    ``for``(``int` `i = 2; i <= k; i += 2)``    ``{``        ` `        ``// Recursive call``        ``cnt = (cnt % mod + solve(n - i, k, mod,``               ``dp) % mod) % mod;``    ``}` `    ``// Store the answer``    ``dp[n] = cnt;` `    ``// Return the answer``    ``return` `cnt;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `mod = (``int``)(1e9 + 7);``    ``int` `n = 4, k = 2;``    ` `    ``int` `[]dp = ``new` `int``[n + 1];``    ``for``(``int` `i = 0; i < n + 1; i++)``        ``dp[i] = -1;``        ` `    ``int` `ans = solve(n, k, mod, dp);``    ` `    ``Console.WriteLine(ans);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output

```1
```

Time complexity: O(n*k)
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up