【编程马拉松】【024-放苹果】

【编程马拉松算法目录】

---

【024-放苹果】【工程下载>>>】

---

1 题目描述

---

　　把 M 个同样的苹果放在 N 个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
　　注意：5、1、1 和 1、5、1 是同一种分法，即顺序无关。

1.1 输入描述:

---

　　输入包含多组数据。
　　每组数据包含两个正整数 m和n（1≤m, n≤20）。

1.2 输出描述:

---

　　对应每组数据，输出一个整数k，表示有k种不同的分法。

1.3 输入例子:

---

7 3

1.4 输出例子:

---

8

2 解题思路

---

2.1 解法一

---

　　放苹果，后一个盘子不能比前一个盘子放的平果数多。可以用动态规划算法实现，但是存在子问题重叠，时间复杂度高。

2.2 解法二

---

　　设f(m,n)为m个苹果，n个盘子的放法数目，则先对n作讨论，
　　　* 当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m)f(m,n)=f(m,m)
　　　* 当n<=m：不同的放法可以分成两类：
　　　　(a)有至少一个盘子空着，即相当于f(m,n)=f(m,n-1);
　　　　(b)所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n)=f(m-n,n).而总的放苹果的放法数目等于两者的和，即f(m,n)=f(m,n-1)+f(m-n,n)递归出口条件说明：当n=1时，所有苹果都必须放在一个盘子里，所以返回1；当没有苹果可放时，定义为1种放法；递归的两条路，第一条n会逐渐减少，终会到达出口n==1;第二条m会逐渐减少，因为n>m时，我们会returnf(m,m)　所以终会到达出口m==0．
　　综上递推公式为：

f(m,n)=⎧ ⎩ ⎨ 1f(m,m)f(m,n−1)+f(m−n,n) m=0orn=1n>m>0m≥n>1  

$$f(m,n)= \begin{cases} 1&m=0 \;or\; n=1\\ f(m,m)&n>m>0\\ f(m,n-1)+f(m-n,n)&m≥n>1 \end{cases}$$

2.3 解法三

---

　　该问题可以变形为：求将一个整数m划分成n个数有多少种情况，其公式为：

dp[m][n]={1dp[m−n][n]+dp[m−1][n−1] n=1n>1  

$$dp[m][n]= \begin{cases} 1 & n=1 \\ dp[m-n][n]+dp[m-1][n-1] & n>1 \end{cases}$$
　　对于变形后的问题，存在两种情况：
　　(a) n份中不包含1的分法，为保证每份都>=2，可以先拿出n个1分到每一份，然后再把剩下的m-n分成n份即可，分法有:dp[m-n][n]
　　(b) n份中至少有一份为1的分法，可以先那出一个1作为单独的1份，剩下的m-1再分成n-1份即可，分法有：dp[m-1][n-1]
　　要求可以放苹果的数，m可以被划分为1到k(k=min{n,m})，所以总的方置方法数有dp[m][1]+…+dp[m][k]
　　这种方式和解法二非常相似，只是思考的角度不一样。

3 算法实现

---

import java.util.Scanner;

/**
 * Author: 王俊超
 * Time: 2016-05-24 20:28
 * CSDN: http://blog.csdn.net/derrantcm
 * Github: https://github.com/Wang-Jun-Chao
 * Declaration: All Rights Reserved !!!
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        Scanner scanner = new Scanner(Main.class.getClassLoader().getResourceAsStream("data.txt"));
        while (scanner.hasNext()) {
            int m = scanner.nextInt();
            int n = scanner.nextInt();

            System.out.println(placeApple4(m, n));
        }

        scanner.close();
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // 【解法三】
    /////////////////////////////////////////////////////////////////////////////////////

    /**
     * 放苹果
     * 变形：求将一个整数m划分成n个数有多少种情况
     * dp[m][n] = dp[m-n][n] + dp[m-1][n-1]; 对于变形后的问题，存在两种情况：
     * 1. n 份中不包含 1 的分法，为保证每份都 >= 2，可以先拿出 n 个 1 分到每一份，
     *      然后再把剩下的 m- n 分成 n 份即可，分法有: dp[m-n][n]
     * 2. n 份中至少有一份为 1 的分法，可以先那出一个 1 作为单独的1份，剩下的 m- 1 再分成 n- 1 份即可，
     *      分法有：dp[m-1][n-1]
     * 3. 要求可以放苹果的数，m可以被划分为1到k(k=min{n, m})，所以总的方置方法数有dp[m][1]+...+dp[m][k]
     * @param m 苹果个数
     * @param n 盘子个数
     * @return 共的放法数目
     */

    /**
     * 【非递归实现】
     * 放苹果
     *
     * @param m 苹果个数
     * @param n 盘子个数
     * @return 共的放法数目
     */
    private static int placeApple4(int m, int n) {
        int row = m + 1;
        int col = n + 1;
        // 最多可以放的盘子个数
        int min = Math.min(m, n);

        int[][] dp = new int[row][col];

        // 只有一个盘子时，则只有一种放法
        for (int i = 1; i < row; i++) {
            dp[i][1] = 1;
        }

        for (int i = 1; i < row; i++) {
            for (int j = 2; j < col; j++) {
                if (i > j) {
                    dp[i][j] = dp[i - j][j] + dp[i - 1][j - 1];
                } else if (i == j) {
                    dp[i][j] = 1;
                }
            }
        }


        int rst = 0;
        for (int i = 1; i <= min; i++) {
            rst += dp[m][i];
        }

        return rst;
    }


    /////////////////////////////////////////////////////////////////////////////////////
    // 【解法二】
    /////////////////////////////////////////////////////////////////////////////////////

    /**
     * 解题分析：
     * 设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，
     * 当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)
     * 当n<=m：不同的放法可以分成两类：
     * 1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);
     * 2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n) = f(m-n,n).
     * 而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n)
     * 递归出口条件说明：
     * 当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
     * 当没有苹果可放时，定义为１种放法；
     * 递归的两条路，第一条n会逐渐减少，终会到达出口n==1;
     * 第二条m会逐渐减少，因为n>m时，我们会return f(m,m)　所以终会到达出口m==0．
     */

    /**
     * 【非递归实现】
     * 放苹果
     *
     * @param m 苹果个数
     * @param n 盘子个数
     * @return 共的放法数目
     */
    private static int placeApple3(int m, int n) {

        int row = m + 1;
        int col = n + 1;

        int[][] dp = new int[row][col];

        for (int i = 0; i < row; i++) {
            dp[i] = new int[n + 1];
        }

        for (int i = 0; i < row; i++) {
            for (int j = 1; j < col; j++) {

                if (i == 0 || j == 1) {
                    dp[i][j] = 1;
                    continue;
                }

                if (j > i) {
                    dp[i][j] = dp[i][i];
                } else {
                    dp[i][j] = dp[i][j - 1] + dp[i - j][j];
                }
            }
        }


        return dp[m][n];
    }


    /**
     * 【递归实现】
     * 放苹果
     *
     * @param m 苹果个数
     * @param n 盘子个数
     * @return 共的放法数目
     */
    private static int placeApple2(int m, int n) {  //m个苹果放在n个盘子中共有几种方法
        //因为我们总是让m>=n来求解的，所以m-n>=0,所以让m=0时候结束，如果改为m=1，
        //则可能出现m-n=0的情况从而不能得到正确解
        if (m == 0 || n == 1) {
            return 1;
        }

        if (n > m) {
            return placeApple2(m, m);
        } else {
            return placeApple2(m, n - 1) + placeApple2(m - n, n);
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    // 【解法一】下面的方法时间复杂度过高，发生了子问题重叠
    /////////////////////////////////////////////////////////////////////////////////////

    /**
     * 放苹果
     *
     * @param m 苹果个数
     * @param n 盘子个数
     * @return 共的放法数目
     */
    private static int placeApple(int m, int n) {

        // 用于保存结果
        int[] rst = {0};
        // 第一个盘子数放的苹果数
        placeApple(m, n, m, rst);
        // 下面和上面一行实现同样的效果
//        for (int i = m; i >= 0; i--) {
//            placeApple(i, n - 1, m - i, rst);
//        }

        return rst[0];
    }

    /**
     * 放苹果，后一个盘子不能比前一个盘子放的平果数多
     *
     * @param max  当前盘子最多可以放多少个苹果
     * @param n    剩下要放的盘子数目
     * @param left 剩下的苹果数目
     * @param rst  保存结果
     */
    private static void placeApple(int max, int n, int left, int[] rst) {

        // 放最后可以放的盘子
        if (n == 1) {
            // 还剩下left个，不能为负数，可以选择的数目大于剩下的数目
            if (max >= left && left >= 0) {
                rst[0]++;
            }
        }
        // 不是最后一个可以
        else if (n > 1) {
            // 当前盘子可以放[0,max个]
            for (int i = max; i >= 0; i--) {
                placeApple(i, n - 1, left - i, rst);
            }

        }
    }
}

4 测试结果

---

5 其它信息

---

因为markddow不好编辑，因此将文档的图片上传以供阅读。Pdf和Word文档可以在Github上进行【下载>>>】。