Count number of ways to divide a number in 4 parts

12 Aug, 2021
Given a positive integer n, find number of ways to divide n in four parts or represent n as sum of four positive integers. Here n varies from 0 to 5000.Examples :  
Input:  n =  5
Output: 1
There is only one way (1, 1, 1, 2)

Input:  n =  6
Output: 2
There are two ways (1, 1, 1, 3) and 
(1, 1, 2, 2)

Input:  n =  8
Output: 5
There are five ways (2, 2, 2, 2), (1, 1, 1, 5),
(1, 1, 3, 3), (1, 1, 2, 4) and (1, 2, 2, 3)
 
Method 1 (Simple Solution) Run four nested loops to generate all possible different quadruplet. Below is C++ implementation of the simple algorithm. Below is the implementation of above approach:  
C++
Java
Python3
C#
PHP
Javascript
// A Simple C++ program to count number of ways to// represent a number n as sum of four.#include<bits/stdc++.h>using namespace std; // Returns count of waysint countWays(int n){    int counter = 0; // Initialize result     // Generate all possible quadruplet and increment    // counter when sum of a quadruplet is equal to n    for (int i = 1; i < n; i++)        for (int j = i; j < n; j++)            for (int k = j; k < n; k++)                for (int l = k; l < n; l++)                    if (i + j + k + l == n)                       counter++;    return counter;} // Driver programint main(){   int n = 8;   cout << countWays(n);   return 0;}
// A Simple Java  program to count number of ways to// represent a number n as sum of four. import java.io.*; class GFG {     // Returns count of waysstatic int countWays(int n){    int counter = 0; // Initialize result     // Generate all possible quadruplet and increment    // counter when sum of a quadruplet is equal to n    for (int i = 1; i < n; i++)        for (int j = i; j < n; j++)            for (int k = j; k < n; k++)                for (int l = k; l < n; l++)                    if (i + j + k + l == n)                    counter++;    return counter;} // Driver program         public static void main (String[] args) {        int n = 8;        System.out.println (countWays(n));    }}
# A Simple python3 program to count# number of ways to represent a number# n as sum of four. # Returns count of waysdef countWays(n):     counter = 0 # Initialize result     # Generate all possible quadruplet    # and increment counter when sum of    # a quadruplet is equal to n    for i in range(1, n):        for j in range(i, n):            for k in range(j, n):                for l in range(k, n):                    if (i + j + k + l == n):                        counter += 1    return counter # Driver Codeif __name__ == "__main__":     n = 8    print (countWays(n)) # This code is contributed by ita_c
// A Simple C# program to count number// of ways to represent a number n as// sum of four.using System; class GFG{         // Returns count of waysstatic int countWays(int n){    int counter = 0; // Initialize result     // Generate all possible quadruplet    // and increment counter when sum of    // a quadruplet is equal to n    for (int i = 1; i < n; i++)        for (int j = i; j < n; j++)            for (int k = j; k < n; k++)                for (int l = k; l < n; l++)                    if (i + j + k + l == n)                    counter++;    return counter;} // Driver Codestatic public void Main (){    int n = 8;    Console.WriteLine(countWays(n));}} // This code is contributed by Sachin
<?php// A Simple PHP program to count// number of ways to represent// a number n as sum of four. // Returns count of waysfunction countWays($n){    // Initialize result    $counter = 0;     // Generate all possible quadruplet    // and increment counter when sum    // of a quadruplet is equal to n    for ($i = 1; $i < $n; $i++)        for ( $j = $i; $j < $n; $j++)            for ($k = $j; $k < $n; $k++)                for ( $l = $k; $l < $n; $l++)                    if ($i + $j + $k + $l == $n)                    $counter++;    return $counter;} // Driver Code$n = 8;echo countWays($n);     // This code is contributed by m_kit?>
<script> // A Simple Javascript  program to count number of ways to// represent a number n as sum of four.            // Returns count of ways    function countWays(n)    {        let counter = 0; // Initialize result           // Generate all possible quadruplet and increment        // counter when sum of a quadruplet is equal to n        for (let i = 1; i < n; i++)            for (let j = i; j < n; j++)                for (let k = j; k < n; k++)                    for (let l = k; l < n; l++)                        if (i + j + k + l == n)                        counter++;        return counter;    }         let n = 8;    document.write(countWays(n));         // This code is contributed by rag2127 </script>
Output :  
5
Time complexity of above solution is O(n4)Method 2 (Uses Dynamic Programming) The idea is based on below recursive solution. 
countWays(n, parts, nextPart) = ∑countWays(n, parts, i)
                          nextPart <= i  Input number
parts    --> Count of parts of n. Initially parts = 4
nextPart --> Starting point for next part to be tried
             We try for all values from nextPart to n.

We initially call the function as countWays(n, 4, 1)
 
Below is Dynamic Programming based on solution of above idea. 
C++
Java
Python3
C#
PHP
Javascript
// A Dynamic Programming based solution to count number// of ways to represent n as sum of four numbers#include<bits/stdc++.h>using namespace std;int dp[5001][5001][5]; // "parts" is number of parts left, n is the value left// "nextPart" is starting point from where we start trying// for next part.int countWaysUtil(int n, int parts, int nextPart){    // Base cases    if (parts == 0 && n == 0) return 1;    if (n <= 0 || parts <= 0) return 0;     // If this subproblem is already solved    if (dp[n][nextPart][parts] != -1)       return dp[n][nextPart][parts];     int ans = 0; // Initialize result     // Count number of ways for remaining number n-i    // remaining parts "parts-1", and for all part    // varying from 'nextPart' to 'n'    for (int i = nextPart; i <= n; i++)        ans += countWaysUtil(n-i, parts-1, i);     // Store computed answer in table and return    // result    return (dp[n][nextPart][parts] = ans);} // This function mainly initializes dp table and// calls countWaysUtil()int countWays(int n){    memset(dp, -1, sizeof(dp));    return countWaysUtil(n, 4, 1);} // Driver programint main(){   int n = 8;   cout << countWays(n) << endl;   return 0;}
// A Dynamic Programming based solution to count number// of ways to represent n as sum of four numbersclass GFG{ static int dp[][][] = new int[5001][5001][5]; // "parts" is number of parts left, n is the value left// "nextPart" is starting point from where we start trying// for next part.static int countWaysUtil(int n, int parts, int nextPart){    // Base cases    if (parts == 0 && n == 0) return 1;    if (n <= 0 || parts <= 0) return 0;     // If this subproblem is already solved    if (dp[n][nextPart][parts] != -1)    return dp[n][nextPart][parts];     int ans = 0; // Initialize result     // Count number of ways for remaining number n-i    // remaining parts "parts-1", and for all part    // varying from 'nextPart' to 'n'    for (int i = nextPart; i <= n; i++)        ans += countWaysUtil(n-i, parts-1, i);     // Store computed answer in table and return    // result    return (dp[n][nextPart][parts] = ans);} // This function mainly initializes dp table and// calls countWaysUtil()static int countWays(int n){    for(int i = 0; i < 5001; i++)    {        for(int j = 0; j < 5001; j++)        {            for(int l = 0; l < 5; l++)            dp[i][j][l] = -1;        }    }    return countWaysUtil(n, 4, 1);} // Driver programpublic static void main(String[] args){    int n = 8;    System.out.println(countWays(n));}} /* This code contributed by PrinciRaj1992 */
# A Dynamic Programming based solution# to count number of ways to represent# n as sum of four numbers dp = [[[-1 for i in range(5)]           for i in range(501)]           for i in range(501)] # "parts" is number of parts left, n is# the value left "nextPart" is starting# point from where we start trying# for next part.def countWaysUtil(n, parts, nextPart):         # Base cases    if (parts == 0 and n == 0):        return 1    if (n <= 0 or parts <= 0):        return 0     # If this subproblem is already solved    if (dp[n][nextPart][parts] != -1):        return dp[n][nextPart][parts]     ans = 0 # Initialize result     # Count number of ways for remaining    # number n-i remaining parts "parts-1",    # and for all part varying from    # 'nextPart' to 'n'    for i in range(nextPart, n + 1):        ans += countWaysUtil(n - i, parts - 1, i)     # Store computed answer in table    # and return result    dp[n][nextPart][parts] = ans    return (ans) # This function mainly initializes dp# table and calls countWaysUtil()def countWays(n):    return countWaysUtil(n, 4, 1) # Driver Coden = 8print(countWays(n)) # This code is contributed# by sahishelangia
// A Dynamic Programming based solution to count number// of ways to represent n as sum of four numbersusing System;     class GFG{ static int [,,]dp = new int[5001, 5001, 5]; // "parts" is number of parts left, n is the value left// "nextPart" is starting point from where we start trying// for next part.static int countWaysUtil(int n, int parts, int nextPart){    // Base cases    if (parts == 0 && n == 0) return 1;    if (n <= 0 || parts <= 0) return 0;     // If this subproblem is already solved    if (dp[n,nextPart,parts] != -1)    return dp[n,nextPart,parts];     int ans = 0; // Initialize result     // Count number of ways for remaining number n-i    // remaining parts "parts-1", and for all part    // varying from 'nextPart' to 'n'    for (int i = nextPart; i <= n; i++)        ans += countWaysUtil(n - i, parts - 1, i);     // Store computed answer in table and return    // result    return (dp[n,nextPart,parts] = ans);} // This function mainly initializes dp table and// calls countWaysUtil()static int countWays(int n){    for(int i = 0; i < 5001; i++)    {        for(int j = 0; j < 5001; j++)        {            for(int l = 0; l < 5; l++)            dp[i, j, l] = -1;        }    }    return countWaysUtil(n, 4, 1);} // Driver codepublic static void Main(String[] args){    int n = 8;    Console.WriteLine(countWays(n));}} // This code contributed by Rajput-Ji
<?php// A Dynamic Programming based solution to// count number of ways to represent n as// sum of four numbers$dp = array_fill(0, 501,      array_fill(0, 501,      array_fill(0, 5, -1))); // "parts" is number of parts left, n is// the value left "nextPart" is starting// point from where we start trying// for next part.function countWaysUtil($n, $parts, $nextPart){    global $dp;         // Base cases    if ($parts == 0 && $n == 0) return 1;    if ($n <= 0 || $parts <= 0) return 0;     // If this subproblem is already solved    if ($dp[$n][$nextPart][$parts] != -1)    return $dp[$n][$nextPart][$parts];     $ans = 0; // Initialize result     // Count number of ways for remaining    // number n-i remaining parts "parts-1",    // and for all part varying from    // 'nextPart' to 'n'    for ($i = $nextPart; $i <= $n; $i++)        $ans += countWaysUtil($n - $i,                              $parts - 1, $i);     // Store computed answer in table    // and return result    return ($dp[$n][$nextPart][$parts] = $ans);} // This function mainly initializes dp// table and calls countWaysUtil()function countWays($n){    return countWaysUtil($n, 4, 1);} // Driver Code$n = 8;echo countWays($n); // This code is contributed by chandan_jnu?>
<script>// A Dynamic Programming based solution to count number// of ways to represent n as sum of four numbers    let dp = new Array(5001);         for(let i = 0; i < 5001; i++)    {        dp[i] = new Array(5001);        for(let j = 0; j < 5001; j++)        {            dp[i][j] = new Array(5);        }    }         // "parts" is number of parts left, n is the value left    // "nextPart" is starting point from where we start trying    // for next part.    function countWaysUtil(n,parts,nextPart)    {             // Base cases        if (parts == 0 && n == 0)            return 1;        if (n <= 0 || parts <= 0)            return 0;              // If this subproblem is already solved        if (dp[n][nextPart][parts] != -1)            return dp[n][nextPart][parts];              let ans = 0; // Initialize result              // Count number of ways for remaining number n-i        // remaining parts "parts-1", and for all part        // varying from 'nextPart' to 'n'        for (let i = nextPart; i <= n; i++)            ans += countWaysUtil(n - i, parts - 1, i);              // Store computed answer in table and return        // result        return (dp[n][nextPart][parts] = ans);    }         // This function mainly initializes dp table and    // calls countWaysUtil()    function countWays(n)    {        for(let i = 0; i < 5001; i++)        {            for(let j = 0; j < 5001; j++)            {                for(let l = 0; l < 5; l++)                    dp[i][j][l] = -1;            }        }        return countWaysUtil(n, 4, 1);    }         // Driver program    let n = 8;    document.write(countWays(n));         // This code is contributed by avanitrachhadiya2155</script>
Output :  
5
Time Complexity: O(n3). There are Θ(n2) entries, every entry is filled only once and filling an entry takes O(n) time.Auxiliary Space: O(n2) 
Method 3 (A O(n2 Log n) Solution) We can use the solution discussed in this post to find all quadruplets.Thanks to Gaurav Ahirwar for suggesting above solutions.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
jit_t
Sach_Code
ukasp
sahilshelangia
Chandan_Kumar
princiraj1992
Rajput-Ji
rag2127
avanitrachhadiya2155
pankajsharmagfg
Algorithms
Mathematical
Mathematical
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.