【python】整数划分--（暴力+动态规划）

题目：

题目：
给定一个整数 n 和一个正整数 k，目标是将 n 分为 k 个不同的非空部分，且任意两种分法在无序情况下不能相同。例如，当 n=7, k=3 时，以下三种分法被视为相同的：
1，1，5；
1，5，1；
5，1，1。
请计算有多少种不同的分法。

示例：
对于输入 n=7, k=3，有以下四种不同的分法：
1，1，5
1，2，4
1，3，3
2，2，3

输入格式：
输入包含一组测试数据，每组数据包含两个整数 n 和 k （6

输出格式：
对于每组输入数据，输出一个整数，表示不同分法的数量。

暴力解法： 

n, k = map(int, input().split())

count = 0

# 暴力解法

if k==2:

    for i in range(1,n):

        for j in range(i,n):

            if i+j==n:

                count+=1

    print(count)

elif k==3:

    for i in range(1,n):

        for j in range(i,n):

            for l in range(j,n):

                if i+j+l==n:

                    count+=1

    print(count)

elif k==4:

    for i in range(1,n):

        for j in range(i,n):

            for l in range(j,n):

                for m in range(l,n):

                    if i+j+l+m==n:

                        count+=1

    print(count)

elif k==5:

    for i in range(1,n):

        for j in range(i,n):

            for l in range(j,n):

                for m in range(l,n):

                    for o in range(m,n):

                        if i+j+l+m+o==n:

                            count+=1

    print(count)

elif k==6:

    for i in range(1,n):

        for j in range(i,n):

            for l in range(j,n):

                for m in range(l,n):

                    for o in range(m,n):

                        for p in range(o,n):

                            if i+j+l+m+o+p==n:

                                count+=1

    print(count)

动态规划：是一种用于解决具有重叠子问题和最优子结构性质的问题的算法设计技术。通过将原问题分解为简单的子问题，并以递推的方式从底向上解决子问题，从而达到解决原问题的目的。

• dp[i - j][j] 表示从整数 i 中减去 j 后，将剩余的 i - j 分成 j 份的划分方式数量。
• dp[i - 1][j - 1] 表示从整数 i 中减去 1 后，将剩余的 i - 1 分成 j - 1 份的划分方式数量。

def count_partitions(n, k):
    # 创建动态规划表，并初始化为0
    dp = [[0 for _ in range(k + 1)] for _ in range(n + 1)]
    # base case: 将任何数分成1份只有1种分法
    for i in range(n + 1):
        dp[i][1] = 1
    # 填充动态规划表
    for i in range(2, n + 1):
        for j in range(2, k + 1):
            if i >= j:
                dp[i][j] = dp[i - j][j] + dp[i - 1][j - 1]
    # 返回结果
    return dp[n][k]

# 输入
n, k = map(int, input().split())
# 输出结果
print(count_partitions(n, k))