购买商品【国立武汉大学东湖校区考研上机试题 -- 多种解法 -- C++，java】

😊😊 😊😊
不求点赞，只求耐心看完，指出您的疑惑和写的不好的地方，谢谢您。本人会及时更正感谢。希望看完后能帮助您理解算法的本质
😊😊 😊😊

题目：

1.选择结构：编写一个智能购物计算小程序，在一家商店有书本、铅笔、橡皮、可乐、零食五种商品，商品价格如下表所示。假如小明带了20元，且必须购买一本书，剩余的钱还可以购买哪种商品，可以购买几件，购买完后又能剩余多少钱？

肯定是剩余0元啊，因为无论剩余奇数还是偶数，我都可以用商品抵消。

法一：暴搜

分析：

现在有4种商品，其中每种商品有无穷多件，请问还可以购买哪些物品，请你输出所有不同的方案。之后再考虑(购买后还剩余多少钱，每种物品购买了几件。)
记住：[1 1 2] 和 [1 2 1] 是同一种方案！
所有钱 = 背包容积；
物品的价格 = 物品体积；
由于每件物品可以无穷选，所以说是完全背包问题！
完全背包选多少件，只取决于背包的容积的大小！

1. 递归的出口：当所选物品的体积==背包容积的时候，处理答案，并且返回！大于的话，说明当前选法不合法。直接剪枝返回！
2. 递归的参数：所选物品的总体积！
3. 递归的计算：
   本题中，每种物品有选或者不选两种方法的计算是01背包模型的，而这里是完全背包，每种物品可以选也可以不选，可以选1件，或者2件，，等等，，，；所以说，递归处理的时候，就需要枚举所有的组合，背包模型实质上是一种组合问题的解决模型之一！递归可以枚举所有的组合选法，但是会出现重复递归的现象，所以说，dp最好，后续会给出dp的分析！
4. 另外如何避免方案重复呢？
   【铅笔，铅笔，可乐】【铅笔，可乐，铅笔】是同一种选法！是重复的，而递归的时候会枚举到！接下来就是重点了：
   去重方式：
   1.记录路径，将路径进行排序 [1 2 1] 排序后 = [1 1 2]，再转化为字符串插入到set中去！
   2.从代码枚举的原理上去去重，开一个last变量，记录上一次所选物品的编号，从而避免了，无论何种情况都会从第一件物品开始枚举的情况；比如：[1 1 1] 序列，回溯到：[1 _ _] 序列，然后 递归到：[ 1 2 _ ] 序列，然后若不记录last那么就会出现：[ 1 2 1 ]，而 [1 2 1 ] 和 [1 1 2] 是重复的，并且 [ 1 1 2] 序列必定是在 [1 1 _] 序列里面已经枚举过了的！所以对于序列 [1 2 1] 无需再去搜索！
   想深入了解可以看看这篇博客：
   以题目来剖析算法本质

当然了也可以逆向递归！

C++代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <unordered_map>

using namespace std;

const int N = 20;
vector<int> path;
int w[N];	//每件物品的体积!
int n, m;	//物品的数量和背包的容积! 
string str[N] = {"", "书本", "铅笔", "橡皮", "可乐", "零食"};
int cnt[N];

void dfs (int cost, int last)
{
	if (cost > m) return ;
	
	if (cost == m)
	{
		cout << str[1] << ' ';	//把书本算上！ 
		for (int i=0; i < path.size(); i ++)
			cout << str[path[i]] << ' ';
		puts("");
		for (int i=1; i <= n; i ++)	//输出每种物品购买了多少件！
			cout << str[i] << ": " << cnt[i] << " (件)" << endl; 
		
		puts("");
		return ;
	}
	
	for (int i=last; i <= n; i ++)
	{
		path.push_back(i);	//记录物品编号 
		cnt[i] ++;	//表示第i号物品的数量++！ 
		dfs (cost + w[i], i);
		path.pop_back();
		cnt[i] --;	//记得恢复！ 
	}
}

int main()
{
	cin >> n >> m;
	for (int i=1; i <= n; i ++)
		cin >> w[i];
	puts("所有的方案为：");
	m -= w[1];
	cnt[1] ++; 
	dfs(0, 2);
	return 0;
 } 

Java代码：

package org.ljx;

import com.sun.scenario.effect.impl.sw.java.JSWColorAdjustPeer;

import java.util.*;

public class Main {
    static int n, m;
    static int[] cnt=new int[100];
    static int[] w = new int[100];
    static String[] str = new String[]{"", "书本", "铅笔", "橡皮", "可乐", "零食"};
    static ArrayList<Integer> list = new ArrayList<Integer>();

    public static void dfs (int cost, int last){
        if (cost > m) return;
        if (cost == m){
            System.out.printf("%s ",str[1]);
            //如何输出ArraList里面的元素！
            for (int i=0; i < list.size(); i ++)
                System.out.printf("%s ", str[list.get(i)]);
            System.out.println();
            for (int i=1; i <= n; i ++) {
                System.out.printf("%s : %d (件)", str[i], cnt[i]);
                System.out.println();
            }
            System.out.println();
            return;
        }

        //递归：
        for (int i=last; i <= n; i ++){
            cnt[i] ++;
            list.add(i);
            dfs (cost + w[i], i);
            cnt[i] --;
            list.remove(list.size()-1);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        for (int i=1; i <= n; i ++)
            w[i] = sc.nextInt();
        m -= w[1];
        cnt[1] ++;
        dfs (0, 2);
    }
}

法二：二进制枚举选法：

法三：完全背包

草稿本：

可以定义成private static int pop_back()吗？public 方法和private方法的区别？

可以将pop_back()方法定义为private static int
pop_back()，但是这会限制该方法的访问范围。private访问修饰符表示该方法只能在当前类内部访问，其他类无法直接访问该方法。而public访问修饰符表示该方法可以在任何地方访问。

如果您希望在其他类中使用pop_back()方法，可以将其定义为public方法。如果您希望限制该方法只在当前类中使用，可以将其定义为private方法。但是，在实际编程中，通常会将通用方法定义为public方法，以便其他类可以使用该方法。

另外，将pop_back()方法定义为static方法表示该方法属于类而不属于对象。这意味着您可以在没有创建类对象的情况下调用该方法。如果不将方法定义为static方法，则必须先创建类对象，然后才能调用该方法。因此，如果您想要直接从类中调用方法，可以将其定义为static方法。

未去重版本： 本人舍不得删除，未去重指的是：[1 1 2] [1 2 1]这样的序列应该是同一个序列的，但是并没有去重！

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
using namespace std;

const int N = 1e2 + 10;
int prices[N];	//每件商品的价格
int money, n;
vector<int> res;	//记录方案;	先记录方案不记录数量嘛 
unordered_map<int, string> Hash = {
	{1, "书本"}, {2, "铅笔"}, {3, "橡皮"}, {4, "可乐"}, {5, "零食"}
};
int cnt[N];

void dfs (int money)	//当前搜到了第u件物品：选择u作为参数，递归的出口，当 u > n 的时候。 但是本题特殊的就是每件物品可以一直选下去。直到钱不够为止。
{	 
	if (money < 1)	//递归的出口！ 输出方案！ 
	{
		int len = res.size();
		for (int i=0; i < len; i ++)
			cout << Hash[res[i]] << ' ';	//输出每件物品的编号！ 

		puts("");
		
		for (int i=2; i <= 5; i ++)
			cout << Hash[i] << "数量：" << cnt[i] << endl;
			
		puts("");
		return ;
	}
	
	for (int i=2; i <= n; i ++)	 	//枚举n件物品(除第一件外)
	{
		if (prices[i] <= money)	//前提是当前物品的价格小于存款！ 
		{
			money -= prices[i];
			cnt[i] ++;
			res.push_back(i);	//把该物品入队！	i代表每件物品的编号！ 
			
			dfs (money);
			
			cnt[i] --;
			money += prices[i];
			res.pop_back();	//弹出该件物品！ 
		} 
	} 
 } 

int main()
{
	cin >> money >> n;	//输入存款，物品数量！! 
	for (int i=1; i <= n; i ++)
		cin >> prices[i];	//输入每件商品的价格! 
	money -= prices[1];		//减去书本的价格！
	dfs (money);	//从第二件物品开始搜索！
	 
	return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <unordered_map>

using namespace std;

const int N = 20;
vector<int> path;
int w[N];	//每件物品的体积!
int n, m;	//物品的数量和背包的容积! 

void dfs (int cost, int last)
{
	if (cost > m) return ;
	
	if (cost == m)
	{
		for (int i=0; i < path.size(); i ++)
			cout << path[i] << ' ';
		puts("");
		return ;
	}
	
	for (int i=last; i <= n; i ++)
	{
		path.push_back(i);	//记录物品编号 
		dfs (cost + w[i], i);
		path.pop_back();
	}
}

int main()
{
	cin >> n >> m;
	for (int i=1; i <= n; i ++)
		cin >> w[i];
	m -= w[1];
	dfs(0, 2);
	return 0;
 }