计算将数字分为4部分的方式数量

给定一个正整数n，请找到将n分为四部分或将n表示为四个正整数之和的方法。这里n从0到5000不等。
例子 ：

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)

方法1(简单的解决方案)运行四个嵌套的循环以生成所有可能的不同的四联体。下面是简单算法的C++实现。
下面是上述方法的实现：

C++

// A Simple C++ program to count number of ways to
// represent a number n as sum of four.
#include
using namespace std;
 
// Returns count of ways
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
int main()
{
   int n = 8;
   cout << countWays(n);
   return 0;
}

Java

// 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 ways
static 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));
    }
}

Python3

# A Simple python3 program to count
# number of ways to represent a number
# n as sum of four.
 
# Returns count of ways
def 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 Code
if __name__ == "__main__":
 
    n = 8
    print (countWays(n))
 
# This code is contributed by ita_c

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 ways
static 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 Code
static public void Main ()
{
    int n = 8;
    Console.WriteLine(countWays(n));
}
}
 
// This code is contributed by Sachin

Javascript

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

输出 ：

5

上述解决方案的时间复杂度为O(n ⁴ )
方法2(使用动态编程)
这个想法是基于下面的递归解决方案。

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)
 

下面是基于以上思想的解决方案的动态编程。

C++

// A Dynamic Programming based solution to count number
// of ways to represent n as sum of four numbers
#include
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 program
int main()
{
   int n = 8;
   cout << countWays(n) << endl;
   return 0;
}

Java

// A Dynamic Programming based solution to count number
// of ways to represent n as sum of four numbers
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 program
public static void main(String[] args)
{
    int n = 8;
    System.out.println(countWays(n));
}
}
 
/* This code contributed by PrinciRaj1992 */

Python3

# 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 Code
n = 8
print(countWays(n))
 
# This code is contributed
# by sahishelangia

C＃

// A Dynamic Programming based solution to count number
// of ways to represent n as sum of four numbers
using 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 code
public static void Main(String[] args)
{
    int n = 8;
    Console.WriteLine(countWays(n));
}
}
 
// This code contributed by Rajput-Ji

Java脚本

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

输出 ：

5