动态规划+递归

Java语言
问题：将m个苹果放入n个盘子的方法数
方法一：动态规划（与递归思想其实都是一样的）
状态转移式：
dp[m][n]=dp[m][n-1]+dp[m-n][n]
其中：
dp[m][n]:将将m个苹果放入n个盘子的方法数（分为以下两种情况—————有盘子是空的，没有盘子是空的）
dp[m][n-1]：将m个苹果放入n-1个盘子中的方法数（要求至少有一个盘子是空的的情况，虽然在这个表达式里看起来好像是只有一个盘子是空的，但实际上继续算下去，别的盘子也可以是空的，可以自己举个例子就明白了，总体是至少有一个盘子是空的的情况）
dp[m-n][n]：将m-n个苹果放入n个盘子中的方法数（没有盘子是空的，所以每个盘子都放了一个，只剩m-n个苹果了，要放进n个盘子里）

import java.util.Scanner;

public class Main {
   public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int m=sc.nextInt();
            int n=sc.nextInt();
            int dp[][]=new int[m+1][n+1];
            for(int i=0;i<=m;i++){//不然dp[0][2]填不进去啊
                for(int j=1;j<=n;j++){
                                //j=1,放进一个盘子里只有一种方法；i<=1举例推得要为1
                    if(j==1||i<=1){
                        dp[i][j]=1;
                    }
                    else{
                        if(i>=j){//等于的时候算这里
                            dp[i][j]=dp[i][j-1]+dp[i-j][j];
                        }
                        else{
                            dp[i][j]=dp[i][i];
                        }
                    }
                }
            }
            System.out.println(dp[m][n]);
        }
    }

方法二：递推
一个道理

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        Main apple=new Main();
        while(sc.hasNext()){
            int m=sc.nextInt();
            int n=sc.nextInt();
            int s=apple.numberWays(m,n);
            System.out.println(s);
        }
    }
    public int numberWays(int m,int n){
        int num;
        if(m<=1||n==1){
            return 1;
        }
        if(m>=n){
            num=numberWays(m,n-1)+numberWays(m-n,n);
        }
        else{
            num=numberWays(m,m);
        }
        return num;
    }
}