N表示两个或多个正整数之和的方法套装2

给定数字N，任务是找到可以划分N的路数，即可以将N表示为正整数之和的路数。
注意： N也应被视为本身将其表示为正整数之和的一种方式。
例子：

Input: N = 5 
Output: 7 
5 can be partitioned in the following ways: 
5 
4 + 1 
3 + 2 
3 + 1 + 1 
2 + 2 + 1 
2 + 1 + 1 + 1 
1 + 1 + 1 + 1 + 1
Input: N = 10 
Output: 42 
 

这篇文章已经在将n写成两个或多个正整数之和的方法中进行了讨论。在这篇文章中，讨论了一种有效的方法。
方法(使用欧拉重复)：
如果p(n)是N的分区数，则可以通过以下生成函数生成它：
$\sum_{n=0}^\infty p(n)x^n = \prod_{k=1}^\infty \left(\frac {1}{1-x^k} \right)$
使用该公式和欧拉五角数定理，我们可以得出p(n)的以下递归关系：(有关更多详细信息，请参阅Wikipedia文章)
$p(n) = p(n - 1) + p (n - 2) - p(n - 5) - p(n - 7) + \cdots + (-1)^{|{k} - 1|} \frac{k(3k - 1)}{2}$
其中k = 1，-1，2，-2，3，-3，…，p(n)= 0(n <0)。
下面是上述方法的实现：

C++

// C++ implementation of above approach
#include 
using namespace std;
 
// Function to find the number
// of partitions of N
long long partitions(int n)
{
    vector p(n + 1, 0);
 
    // Base case
    p[0] = 1;
 
    for (int i = 1; i <= n; ++i) {
        int k = 1;
        while ((k * (3 * k - 1)) / 2 <= i) {
            p[i] += (k % 2 ? 1 : -1) * p[i - (k * (3 * k - 1)) / 2];
 
            if (k > 0)
                k *= -1;
            else
                k = 1 - k;
        }
    }
 
    return p[n];
}
 
// Driver code
int main()
{
    int N = 20;
    cout << partitions(N);
    return 0;
}

Java

// Java implementation of above approach
class GFG
{
 
    // Function to find the number
    // of partitions of N
    static long partitions(int n)
    {
        long p[] = new long[n + 1];
 
        // Base case
        p[0] = 1;
 
        for (int i = 1; i <= n; ++i)
        {
            int k = 1;
            while ((k * (3 * k - 1)) / 2 <= i)
            {
                p[i] += (k % 2 != 0 ? 1 : -1) *
                    p[i - (k * (3 * k - 1)) / 2];
 
                if (k > 0)
                {
                    k *= -1;
                }
                else
                {
                    k = 1 - k;
                }
            }
        }
        return p[n];
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int N = 20;
        System.out.println(partitions(N));
    }
}
 
// This code is contributed by Rajput-JI

Python 3

# Python 3 implementation of
# above approach
 
# Function to find the number
# of partitions of N
def partitions(n):
 
    p = [0] * (n + 1)
 
    # Base case
    p[0] = 1
 
    for i in range(1, n + 1):
        k = 1
        while ((k * (3 * k - 1)) / 2 <= i) :
            p[i] += ((1 if k % 2 else -1) *
                    p[i - (k * (3 * k - 1)) // 2])
 
            if (k > 0):
                k *= -1
            else:
                k = 1 - k
 
    return p[n]
 
# Driver code
if __name__ == "__main__":
    N = 20
    print(partitions(N))
 
# This code is contributed
# by ChitraNayal

C#

// C# implementation of above approach
using System;
 
class GFG
{
 
    // Function to find the number
    // of partitions of N
    static long partitions(int n)
    {
        long []p = new long[n + 1];
 
        // Base case
        p[0] = 1;
 
        for (int i = 1; i <= n; ++i)
        {
            int k = 1;
            while ((k * (3 * k - 1)) / 2 <= i)
            {
                p[i] += (k % 2 != 0 ? 1 : -1) *
                    p[i - (k * (3 * k - 1)) / 2];
 
                if (k > 0)
                {
                    k *= -1;
                }
                else
                {
                    k = 1 - k;
                }
            }
        }
        return p[n];
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int N = 20;
        Console.WriteLine(partitions(N));
    }
}
 
// This code has been contributed by 29AjayKumar

PHP

 0)
                $k *= -1;
            else
                $k = 1 - $k;
        }
    }
    return $p[$n];
}
 
// Driver Code
$N = 20;
print(partitions($N));
 
// This code is contributed
// by mits
?>

Javascript

// javascript implementation of above approach   
// Function to find the number
    // of partitions of N
    function partitions(n)
    {
        var p = Array(n + 1).fill(0);
 
        // Base case
        p[0] = 1;
 
        for (i = 1; i <= n; ++i)
        {
            var k = 1;
            while ((k * (3 * k - 1)) / 2 <= i)
            {
                p[i] += (k % 2 != 0 ? 1 : -1) * p[i - (k * (3 * k - 1)) / 2];
 
                if (k > 0) {
                    k *= -1;
                } else {
                    k = 1 - k;
                }
            }
        }
        return p[n];
    }
 
    // Driver code
     
        var N = 20;
        document.write(partitions(N));
 
// This code is contributed by todaysgaurav

输出：

627

时间复杂度：O(N√N)
空间复杂度：O(N)