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

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:

DP_{n = 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 <bits/stdc++.h> 

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

<?php 
// PHP 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 

function countWays($n) 
{ 

    $DP = array(); 

    // base cases 

    $DP[0] = $DP[1] = $DP[2] = 1; 

    $DP[3] = 2; 

    // iterate for all  

    // values from 4 to n 

    for ($i = 4; $i <= $n; $i++)  

        $DP[$i] = $DP[$i - 1] +  

                  $DP[$i - 3] +  

                  $DP[$i - 4]; 

    return $DP[$n]; 
} 

// Driver Code 

$n = 10; 

echo countWays($n); 

// This code is contributed 
// by Sam007 
?>

Javascript

<script> 

// Javascript 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 

function countWays(n) 
{ 

    var DP = []; 

    DP.length = 10; 

    DP.fill(0); 

    // Base cases 

    DP[0] = DP[1] = DP[2] = 1; 

    DP[3] = 2; 

    // Iterate for all values from 4 to n 

    for(var i = 4; i <= n; i++) 

        DP[i] = DP[i - 1] + DP[i - 3] +  

                DP[i - 4]; 

    return DP[n]; 
} 

// Driver code 

var n = 10; 

document.write(countWays(n)); 

// This code is contributed by bunnyram19    

</script>

Output

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 <bits/stdc++.h> 

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

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

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

Article Tags :

Combinatorial

DSA

Dynamic Programming