Count of different ways to express N as the sum of 1, 3 and 4

Last Updated : 29 Mar, 2024

Given N, count the number of ways to express N as sum of 1, 3 and 4.

Examples:

```Input :  N = 4
Output : 4
Explanation: 1+1+1+1
1+3
3+1
4

Input : N = 5
Output : 6
Explanation: 1 + 1 + 1 + 1 + 1
1 + 4
4 + 1
1 + 1 + 3
1 + 3 + 1
3 + 1 + 1```

Approach : Divide the problem into sub-problems for solving it. Let DP[n] be the number of ways to write N as the sum of 1, 3, and 4. Consider one possible solution with n = x1 + x2 + x3 + … xn. If the last number is 1, then sum of the remaining numbers is n-1. So the number that ends with 1 is equal to DP[n-1]. Taking other cases into account where the last number is 3 and 4. The final recurrence would be:

`DPn = DPn-1 + DPn-3 + DPn-4`
```Base case :
DP[0] = DP[1] = DP[2] = 1 and DP[3] = 2```

C++

 `// C++ program to illustrate the number of ` `// ways to represent N as sum of 1, 3 and 4. ` `#include ` `using` `namespace` `std; ` ` `  `// function to count the number of ` `// ways to represent n as sum of 1, 3 and 4 ` `int` `countWays(``int` `n) ` `{ ` `    ``int` `DP[n + 1]; ` ` `  `    ``// base cases ` `    ``DP[0] = DP[1] = DP[2] = 1; ` `    ``DP[3] = 2; ` ` `  `    ``// iterate for all values from 4 to n ` `    ``for` `(``int` `i = 4; i <= n; i++)  ` `        ``DP[i] = DP[i - 1] + DP[i - 3] + DP[i - 4]; ` `     `  `    ``return` `DP[n]; ` `} ` ` `  `// driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` `    ``cout << countWays(n); ` `    ``return` `0; ` `} `

Java

 `// Java program to illustrate  ` `// the number of ways to represent  ` `// N as sum of 1, 3 and 4. ` ` `  `class` `GFG { ` ` `  `    ``// Function to count the  ` `    ``// number of ways to represent  ` `    ``// n as sum of 1, 3 and 4 ` `    ``static` `int` `countWays(``int` `n) ` `    ``{ ` `        ``int` `DP[] = ``new` `int``[n + ``1``]; ` ` `  `        ``// base cases ` `        ``DP[``0``] = DP[``1``] = DP[``2``] = ``1``; ` `        ``DP[``3``] = ``2``; ` ` `  `        ``// iterate for all values from 4 to n ` `        ``for` `(``int` `i = ``4``; i <= n; i++) ` `            ``DP[i] = DP[i - ``1``] + DP[i - ``3``]  ` `                    ``+ DP[i - ``4``]; ` ` `  `        ``return` `DP[n]; ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `n = ``10``; ` `        ``System.out.println(countWays(n)); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by prerna saini. `

Python3

 `# Python program to illustrate the number of ` `# ways to represent N as sum of 1, 3 and 4. ` ` `  `# Function to count the number of ` `# ways to represent n as sum of 1, 3 and 4 ` `def` `countWays(n): ` ` `  `    ``DP ``=` `[``0` `for` `i ``in` `range``(``0``, n ``+` `1``)] ` `     `  `    ``# base cases ` `    ``DP[``0``] ``=` `DP[``1``] ``=` `DP[``2``] ``=` `1` `    ``DP[``3``] ``=` `2` ` `  `    ``# Iterate for all values from 4 to n ` `    ``for` `i ``in` `range``(``4``, n ``+` `1``): ` `        ``DP[i] ``=` `DP[i ``-` `1``] ``+` `DP[i ``-` `3``] ``+` `DP[i ``-` `4``] ` `     `  `    ``return` `DP[n] ` ` `  `     `  `# Driver code  ` `n ``=` `10` `print` `(countWays(n)) ` ` `  `# This code is contributed by Gitanjali. `

C#

 `// C# program to illustrate  ` `// the number of ways to represent  ` `// N as sum of 1, 3 and 4. ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to count the  ` `    ``// number of ways to represent  ` `    ``// n as sum of 1, 3 and 4 ` `    ``static` `int` `countWays(``int` `n) ` `    ``{ ` `        ``int` `[]DP = ``new` `int``[n + 1]; ` ` `  `        ``// base cases ` `        ``DP[0] = DP[1] = DP[2] = 1; ` `        ``DP[3] = 2; ` ` `  `        ``// iterate for all values from 4 to n ` `        ``for` `(``int` `i = 4; i <= n; i++) ` `            ``DP[i] = DP[i - 1] + DP[i - 3]  ` `                    ``+ DP[i - 4]; ` ` `  `        ``return` `DP[n]; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 10; ` `        ``Console.WriteLine(countWays(n)); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by vt_m. `

PHP

 ` `

Javascript

 ``

Output

`64`

Time Complexity : O(n)
Auxiliary Space : O(n)

Method – 2: Constant Space Complexity Solution (O(1) space complexity)

In the above solution we are storing all the dp states, i.e. we create n + 1 size dp array, but to calculate the particular dp[i[4] state we only need the dp[i-1], dp[i-3] and dp[i-4] states. so we can use this observation and conclude that we only store the previous 4 states to calculate the current dp[i] state.

so here we use

```dp_i which store dp[i]
dp_i_1 which store dp[i-1]
dp_i_2 which store dp[i-2]
dp_i_3 which store dp[i-3]
dp_i_4 which store dp[i-4] ```

so in this solution we only need 5 variable so space complexity = O(5) ~= O(1)

below is the Implementation for this approach

C++

 `// C++ program to illustrate the number of ways to represent N as sum of 1, 3 and 4. ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// function to count the number of ways to represent n as sum of 1, 3 and 4 ` `int` `countWays(``int` `n) { ` `    ``int` `dp_i, dp_i_1, dp_i_2, dp_i_3, dp_i_4; ` ` `  `    ``if` `(n == 0 || n == 1 || n == 2) ``return` `1; ` `    ``else` `if` `(n == 3) ``return` `2; ` ` `  `    ``// base cases ` `    ``dp_i_4 = dp_i_3 = dp_i_2 = 1; ` `    ``dp_i_1 = 2; ` ` `  `    ``// iterate for all values from 4 to n ` `    ``for` `(``int` `i = 4; i <= n; i++) { ` `        ``dp_i = dp_i_1 + dp_i_3 + dp_i_4; ` `        ``// Updating Variable value so in next Iteration they become relevant  ` `        ``dp_i_4 = dp_i_3; ` `        ``dp_i_3 = dp_i_2; ` `        ``dp_i_2 = dp_i_1; ` `        ``dp_i_1 = dp_i; ` `    ``} ` ` `  `    ``return` `dp_i; ` `} ` ` `  `// driver code ` `int` `main() { ` `    ``int` `n = 10; ` `    ``cout << countWays(n); ` `    ``return` `0; ` `} `

Java

 `import` `java.util.*; ` ` `  `public` `class` `Main { ` `    ``// function to count the number of ways to represent n as sum of 1, 3 and 4 ` `    ``public` `static` `int` `countWays(``int` `n) { ` `        ``int` `dp_i = ``0``, dp_i_1, dp_i_2, dp_i_3, dp_i_4; ` ` `  `        ``if` `(n == ``0` `|| n == ``1` `|| n == ``2``) ``return` `1``; ` `        ``else` `if` `(n == ``3``) ``return` `2``; ` ` `  `        ``// base cases ` `        ``dp_i_4 = dp_i_3 = dp_i_2 = ``1``; ` `        ``dp_i_1 = ``2``; ` ` `  `        ``// iterate for all values from 4 to n ` `        ``for` `(``int` `i = ``4``; i <= n; i++) { ` `            ``dp_i = dp_i_1 + dp_i_3 + dp_i_4; ` `            ``// Updating Variable value so in next Iteration they become relevant  ` `            ``dp_i_4 = dp_i_3; ` `            ``dp_i_3 = dp_i_2; ` `            ``dp_i_2 = dp_i_1; ` `            ``dp_i_1 = dp_i; ` `        ``} ` ` `  `        ``return` `dp_i; ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `main(String[] args) { ` `        ``int` `n = ``10``; ` `        ``System.out.println(countWays(n)); ` `    ``} ` `} `

Python3

 `# Python program to illustrate the number of ways to represent N as sum of 1, 3 and 4. ` ` `  `# function to count the number of ways to represent n as sum of 1, 3 and 4 ` `def` `countWays(n): ` `    ``if` `n ``=``=` `0` `or` `n ``=``=` `1` `or` `n ``=``=` `2``: ` `        ``return` `1` `    ``elif` `n ``=``=` `3``: ` `        ``return` `2` ` `  `    ``# base cases ` `    ``dp_i_4 ``=` `dp_i_3 ``=` `dp_i_2 ``=` `1` `    ``dp_i_1 ``=` `2` ` `  `    ``# iterate for all values from 4 to n ` `    ``for` `i ``in` `range``(``4``, n``+``1``): ` `        ``dp_i ``=` `dp_i_1 ``+` `dp_i_3 ``+` `dp_i_4 ` `        ``# Updating Variable value so in next Iteration they become relevant  ` `        ``dp_i_4, dp_i_3, dp_i_2, dp_i_1 ``=` `dp_i_3, dp_i_2, dp_i_1, dp_i ` ` `  `    ``return` `dp_i ` ` `  `# driver code ` `n ``=` `10` `print``(countWays(n))`

C#

 `using` `System; ` ` `  `public` `class` `GFG ` `{ ` `    ``// function to count the number of ways to represent n as sum of 1, 3 and 4 ` `    ``public` `static` `int` `CountWays(``int` `n) ` `    ``{ ` `        ``int` `dp_i = 0, dp_i_1, dp_i_2, dp_i_3, dp_i_4; ` ` `  `        ``if` `(n == 0 || n == 1 || n == 2) ``return` `1; ` `        ``else` `if` `(n == 3) ``return` `2; ` ` `  `        ``// base cases ` `        ``dp_i_4 = dp_i_3 = dp_i_2 = 1; ` `        ``dp_i_1 = 2; ` ` `  `        ``// iterate for all values from 4 to n ` `        ``for` `(``int` `i = 4; i <= n; i++) ` `        ``{ ` `            ``dp_i = dp_i_1 + dp_i_3 + dp_i_4; ` `            ``// Updating Variable value so in next Iteration they become relevant  ` `            ``dp_i_4 = dp_i_3; ` `            ``dp_i_3 = dp_i_2; ` `            ``dp_i_2 = dp_i_1; ` `            ``dp_i_1 = dp_i; ` `        ``} ` ` `  `        ``return` `dp_i; ` `    ``} ` ` `  `    ``// driver code ` `    ``public` `static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``int` `n = 10; ` `        ``Console.WriteLine(CountWays(n)); ` `    ``} ` `} `

Javascript

 `function` `countWays(n) { ` `    ``let dp_i, dp_i_1, dp_i_2, dp_i_3, dp_i_4; ` ` `  `    ``if` `(n == 0 || n == 1 || n == 2) ``return` `1; ` `    ``else` `if` `(n == 3) ``return` `2; ` ` `  `    ``// base cases ` `    ``dp_i_4 = dp_i_3 = dp_i_2 = 1; ` `    ``dp_i_1 = 2; ` ` `  `    ``// iterate for all values from 4 to n ` `    ``for` `(let i = 4; i <= n; i++) { ` `        ``dp_i = dp_i_1 + dp_i_3 + dp_i_4; ` `        ``// Updating Variable value so in next Iteration they become relevant  ` `        ``dp_i_4 = dp_i_3; ` `        ``dp_i_3 = dp_i_2; ` `        ``dp_i_2 = dp_i_1; ` `        ``dp_i_1 = dp_i; ` `    ``} ` ` `  `    ``return` `dp_i; ` `} ` ` `  `// driver code ` `let n = 10; ` `console.log(countWays(n)); `

Output

`64`

Time Complexity : O(n)
Auxiliary Space : O(1)

Previous
Next