牛客-HJ61-放苹果

方法一：递归法

思路：设f(m,n)为m个苹果，n个盘子的放苹果方式数目，则先对n进行讨论：

1. n>m：此时苹果少，盘子多，那肯定会有n-m个盘子永远空着，去掉它们对放苹果的放法没有影响，此时，f(m,n) = f(m,m)。
2. n<=m：此时苹果多，盘子少，做以下考虑：
   • 有盘子为空，此时，f(m,n) = f(m,n-1)。
   • 假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，此时，可以从每个盘中拿掉一个苹果，并不会影响最终的放法数目，即，f(m,n) = f(m-n,n)。

于是，根据以上情况，我们可以得到最终的放法数目：f(m,n) = f(m,n-1) + f(m-n,n) 。
递归的base case：当 n = 1,所有苹果都只能放到一个盘中，返回 1。当没有苹果时候，定义为1种方法；
可以写出以下代码：

import java.io.*;
public class Main {
   
    public static void main(String[] args) throws Exception{
   
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = "";
        while ((str = br.readLine()) != null) {
   
            String[] strs = str.split(" ");
            int m = Integer.parseInt(strs[0]);
            int n = Integer.parseInt(strs[1]);
            System.out.println(helper(m, n));
        }
    }
    public static int helper(int m, int n) {
   
        if (m == 0 || n == 1) {
    // helper(m, n-1)的出口
            return 1;
        } else if (m < n) {
    // 苹果少，盘子多. helper(m - n, n)的出口
            return helper(m, m);
        } else {
    // 苹果多，盘子少
            return helper(m, n-1) + helper(m - n, n);
        }
    }
}

时间复杂度： O(2^N )，画出递归树，执行时间复杂度即为2^N （同斐波拉契数列）。
空间复杂度： O(N)，递归栈的深度。

方法二：动态规划法

思路：dp就是把递归写成遍历的方式，拿dp表来存调用过程中的中间值，从而避免重复计算，降低时间复杂度。可以写出以下代码：

import java.io.*;
public class Main {
   
    public static void main(String[] args) throws Exception{
   
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = "";
        while ((str = br.readLine()) != null) {
   
            String[] strs = str.split(" ");
            int m = Integer.parseInt(strs[0]);
            int n = Integer.parseInt(strs[1]);
            int[][] dp = new int[m + 1][n + 1];
            // 没苹果了
            for (int i = 0; i < n + 1; i++) {
   
                dp[0][i] = 1;
            }
            // 只有一个盘了
            for (int i = 0; i < m + 1; i++) {
   
                dp[i][1] = 1;
            }
            for (int i = 1; i < m + 1; i++) {
    // 从有1个苹果开始遍历
                for (int j = 2; j < n + 1; j++) {
    // 从有两个盘开始遍历
                    if (i < j) {
   // 苹果少，盘子多
                        dp[i][j] = dp[i][i];
                    } else {
   // 苹果多，盘子少
                        // 两种情况
                        // 情况一：有盘子为空，假设有一个盘子为空，则(m,n)问题转化为将m个苹果放在n-1个盘子上 dp[i][j - 1]
                        // 情况二：假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，
                        // 即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上每个盘子都要放苹果 dp[i - j][j]
                        dp[i][j] = dp[i][j - 1] + dp[i - j][j];
                    }
                }
            }
            System.out.println(dp[m][n]);
        }
    }
}

时间复杂度： O(2^N )，画出递归树，执行时间复杂度即为2^N （同斐波拉契数列）。
空间复杂度： O(N)，递归栈的深度。