【编程马拉松算法目录】
【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 31.4 输出例子:
82 解题思路
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
2.3 解法三
该问题可以变形为：求将一个整数m划分成n个数有多少种情况，其公式为：
dp[m][n]={1dp[m?n][n]+dp[m?1][n?1] n=1n>1
对于变形后的问题，存在两种情况：
(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上进行【下载>>>】。
时间： 2024-10-07 09:56:14