放苹果

input_list = input().split()
m = int(input_list[0])
n = int(input_list[1])

# i 是苹果的数量
# j 是盘子的数量
matrix = [[0 for j in range(11)] for i in range(11)]
for i in range(11):
    for j in range(11):
        if j == 0&nbs***bsp;i == 0:
            matrix[i][j] = 0
            continue
        if j == 1 and i >= 1:
            matrix[i][j] = 1
            continue
        if i == 1 and j >= 1:
            matrix[i][j] = 1
            continue
        if j > 1 and i > 1:
            if i == j:
                ##和j-1相比，增加了一种盘子数量等于苹果数量的情况，这种情况下只有1种摆放方式，每个盘子里面摆一个苹果。
                matrix[i][j] = matrix[i][j - 1] + 1
            if i < j:
                ##如果盘子数量多于苹果数量，多余的盘子并不能增加摆放方式。
                matrix[i][j] = matrix[i][i]
            if i > j:
                ##如果盘子数量少于苹果数量，和j-1相比，只需要考虑j个盘子全部摆满的情况。
                ##全部摆满，意味着没有盘子是空的，每个盘子至少有一个苹果，摆放方式的数量就等于i-j个苹果j个盘子的摆放方式的数量。
                matrix[i][j] = matrix[i][j - 1] + matrix[i - j][j]

# for p in range(11):
#    print(p, matrix[p])

print(matrix[m][n])

from itertools import combinations
m, n = list(map(int, input().split()))
cut_piont = [c for c in range(1,m+1)]
all_method = []
for i in range(1, n+1):
    method = list(combinations(cut_piont, i))
    for j in method:
        d = list(j)[::-1]
        apples = [1] * m
        nums = list()
        a = 0
        while d:
            a = d.pop()
            d = [x - a for x in d]
            if apples:
                nums.append(apples[:a])
                apples = apples[a:]
        c = [sum(i) for i in nums]
        c.sort()
        if c not in all_method and sum(c) == m:
            all_method.append(c)
#print(all_method)
print(len(all_method))

"""函数递归思想,主要表达抽象思维，计算机语言魅力在于，给定了计算路径或者规则，输入和输出就交给晶体管解决了。言归正传哈，不妨设 f(m,n) 为分法总数，接下来就是要给定计算路径了，注意这里的计算路径类似数列递推公式，给出首几项的值，求第n项递推公式，但是计算机不要求具体的计算公式，因为计算机它可以自行迭代啊！故最简单的方法，就是通过找出第n项的前几项式子，看看它们和通项式子的关系式（也就是可迭代路径），观察规律如下：

def f(m, n):

    if m == 0 or n == 1:

        return 1

    if m < n:

        return f(m, m)  

    else:

        return (f(m, n-1) + f(m-n, n))

while True:

    try:

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

        print(f(m,n))

    except:

        break

#最后，各位观众老爷们，动态规划做成了数字游戏推到，创造不易，请点赞支持，谢谢了！

n, m = map(int, input().split(' '))

res = []
temp = []


def iter_counts(n1, m):
    if m == 0:
        sum = 0
        for each in temp:
            sum += each
        if sum != n:
            temp.pop(len(temp)-1)
            return
        if sorted(temp) not in res:
            res.append(sorted(temp))
        temp.pop(len(temp) - 1)
        return
    for i in range(n1+1):
        temp.append(i)
        if m > 0:
            iter_counts(n1-i, m-1)
    temp.pop(len(temp) - 1)

try:
    iter_counts(n, m)
except Exception:
    pass
print(len(res))

inputs=input().strip().split(' ')

mm=int(inputs[0])
nn=int(inputs[1])


# f[m][n]=f[m][n-1]+f[m-n][n] if m>=n
# f[m][n]=f[m][m] if m<n

f = [[1 for i in range(nn+1)] for j in range(mm+1)]
for m in range(2,mm+1):
    for n in range(2,nn+1):
        if m>=n:
            f[m][n]=f[m][n-1]+f[m-n][n]
        else:
            f[m][n]=f[m][m]
print(f[-1][-1])

#想了挺久才想明白
apple,pz = map(int,input().split())
def solution(a,p):
    if a == 0&nbs***bsp;p == 0&nbs***bsp;a == 1&nbs***bsp;p == 1:
        return 1
    elif a < p:
        return solution(a,a)
    return solution(a,p-1) + solution(a-p,p)
print(solution(apple,pz))

m,n=map(int,input().split())
def apple(m,n):
    if m==1&nbs***bsp;n==1 :
        return 1
    elif m==0:
        return 1
    elif m<0:
        return 0
    else:
        return apple(m,n-1)+apple(m-n,n)

print(apple(m,n))

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


def app(a, b):
    if a < b:
        return app(a, a)
    if a <= 1:
        return 1
    return sum([app(a - i, i) for i in range(1, b + 1)])


print(app(m, n))