问题说明:
假设有一个背包的负重最多可达8公斤，而希望在背包中装入负重范围内可得之总价物
品，假设是水果好了，水果的编号、单价与重量如下所示：
0
李子
4KG
NT$4500
1
苹果
5KG
NT$5700
2
橘子
2KG
NT$2250
3
草莓
1KG
NT$1100
解法背包问题是关于最佳化的问题，要解最佳化问题可以使用「动态规划」 （Dynamicprogramming） ，从空集合开始，每增加一个元素就先求出该阶段的最佳解，直到所有的元素加入至集合中，最后得到的就是最佳解。
下面我们看下代码:
/*
问题:
假设有一个背包的负重最多可达8公斤，而希望在背包中装入负重范围内可得之总价物品
算法说明:
采用动态规划,在当前阶段求解出最好的解,如此反复
日期:2013/8/18
张威
*/ #include <iostream>
#include <time.h>
using namespace std; #define MAXSIZE 8 //定义全局变量
char name[][] = {"李子","苹果","橘子","草莓","甜瓜"};//水果名称
int wight[] = {,,,,};//单个水果所占斤数
int price[] = {,,,,};//单个水果的价值
int perkg_price[];//每斤水果的价钱
int perkg_num[] = {,,,,}; void GetNmae(int num)
{
for (int i = ;i <= ;i++)
{
cout<<name[num][i];
}
} void GetBestAnswer(int currentwigh)
{
//判断递归终止条件
if (currentwigh >= MAXSIZE)
{
cout<<"包裹已经满了,无法再装进东西"<<endl;
}
else
{
//check用来表证到底剩下来的物品里面还有没有能装进去背包里的
bool check = true;
int i = ;
for (;i <= ;i++)
{
//若是没有进入到这个条件内,说明剩下来的物品的重量都超过了背包剩余重量,到此结束.否则i就代表当前所能选中的最优解
if (wight[perkg_num[i]] <= MAXSIZE-currentwigh)
{
check = false;
break;
}
}
if (check == true)
{
cout<<"已经装不进去任何水果了"<<endl;
}
else
{
//得到最优解,并且将当前重量增加,进入下一次递归
currentwigh += wight[perkg_num[i]];
cout<<"购买了";
GetNmae(perkg_num[i]);
cout<<endl;
GetBestAnswer(currentwigh);
}
}
} int main()
{
//计算出每斤水果的价钱,便于动态规划时求出当前最佳解
for (int i = ;i <= ;i++)
{
perkg_price[i] = price[i] / wight[i];
}
//对perkg_num进行排序,同时保证单价和perkg_num之间的一一对应关系.即两个数组要同时变化
//采用的是冒泡排序,在元素进行交换时perkg_num和perkg_price同时变化
for (int i = ;i <= ;i++)
{
for (int j = i;j <= ;j++)
{
if (perkg_price[j] < perkg_price[j+])
{
int temp1 = perkg_price[j];
int temp2 = perkg_num[j];
perkg_price[j] = perkg_price[j+];
perkg_price[j+] = temp1;
perkg_num[j] = perkg_num[j+];
perkg_num[j+] = temp2;
}
}
}
//开始计算求解
GetBestAnswer();
return ;
}
背包问题
在这里,算法的主要思想有两个:1.通过冒泡排序得到一个单价表,并将物品的ID与之配对起来.这样我们在每次的递归中通过ID找到物品的相应属性,筛选出当前步骤的最优解出来
2.通过递归,传递当前的重量,得到还剩余的重量,根据前面的单价表,筛选出可选的最优解,然后将重量变化进入下一次递归.
这是最大空间为8的运行结果: 这是最大空间为29的运行结果:
下面附上指导书上面的代码:
#include <stdio.h>
#include <stdlib.h>
#define LIMIT 8
// 重量限制
#define N 5
// 物品种类
#define MIN 1
// 最小重量
struct body {
char name[];
int size;
int price;
};
背
包
负
重 valu
e item ０ 背
包
负
重 valu
e item ０ typedef struct body object;
int main(void) {
int item[LIMIT+] = {};
int value[LIMIT+] = {};
int newvalue, i, s, p;
object a[] = {{"李子", , },
{"苹果", , },
{"橘子", , },
{"草莓", , },
{"甜瓜", , }};
for(i = ; i < N;i++) {
for(s = a[i].size; s <= LIMIT;s++) {
p = s - a[i].size;
newvalue = value[p] + a[i].price;
if(newvalue > value[s]) {// 找到阶段最佳解
value[s] = newvalue;
item[s] = i;
}
}
}
printf("物品\t价格\n");
for(i = LIMIT;i >= MIN;i = i - a[item[i]].size) {
printf("%s\t%d\n",
a[item[i]].name, a[item[i]].price);
}
printf("合计\t%d\n", value[LIMIT]);
return ;
}
Java
class Fruit {
private String name;
private int size;
private int price;
public Fruit(String name,int size, int price){
this.name = name;
this.size = size;
this.price = price;
}
public String getName(){
return name;
}
public int getPrice(){
return price;
}
public int getSize() {
return size;
}
}
public class Knapsack {
public static void main(String[] args){
final int MAX = ;
final int MIN = ;
int[] item = new int[MAX+];
int[] value = new int[MAX+];
Fruit fruits[] = {
new Fruit("李子", , ),
new Fruit("苹果", , ),
new Fruit("橘子", , ),
new Fruit("草莓", , ),
new Fruit("甜瓜", , )};
for(int i = ; i < fruits.length;i++) {
for(int s = fruits[i].getSize(); s <= MAX;s++){
int p = s - fruits[i].getSize();
int newvalue = value[p] +
fruits[i].getPrice();
if(newvalue > value[s]) {// 找到阶段最佳解
value[s] = newvalue;
item[s] = i;
}
}
}
System.out.println("物品\t价格");
for(int i = MAX;
i >= MIN;
i = i - fruits[item[i]].getSize()) {
System.out.println(fruits[item[i]].getName()+
"\t" + fruits[item[i]].getPrice());
}
System.out.println("合计\t" + value[MAX]);
}
}
指导书上面的代码
我居然没想到使用结构体,失策失策,都没用什么高级点的数据结构,看起来貌似很复杂的样子.明天再看