实验名称: 箱子装载问题

实验地点：

实验目的：

1、 理解和复习所学各种算法的概念；

2、  掌握和复习所学各种算法的基本要素；

3、  掌握各种算法的优点和区别；

4、  通过应用范例掌握选择最佳算法的设计技巧与策略；

实验原理

回溯法原理：

从开始结点出发，以深度优先方式搜索整个解空间。这个节点成为活结点，同时也成为当前的扩展节点。在当前的扩展节点处，搜索向纵深方向一致一个新节点。

贪心算法原理：

贪心算法通过一系列的选择来得到问题的解。他所做的每一个选择都是当前状态下局部最好选择，即贪心选择。

分支限界法原理：

每一个活结点只有一次机会成为扩展结点，一旦成为扩展结点，就一次性产生其所有儿子结点。儿子结点中，导致不可行解或者非最优解的被舍弃，其余加入活结点表中。从活结点表中取下一结点成为当前扩展结点，并重复上述结点的扩展过程，一直持续到找到所需的解或活结点表为空为止。

实验内容：

1、使用贪心算法、回溯法、分支限界法解决箱子装载问题。（任选两种）

2、通过上机实验进行算法实现。

3、保存和打印出程序的运行结果，并结合程序进行分析，上交实验报告。

源程序：

（1）贪心算法

#include<stdio.h>
#include<stdlib.h>
void swap(int &x, int &y){  //交换 int t;t = x;x = y;y = t;
}
void sort(int w[], int t[], int n)  //排序，有小到大
{for (int m = 0; m<n; m++)    //为每个物品编序号 t[m] = m;int i, j;int lastExchangeIndex;i = n - 1;while (i>0){lastExchangeIndex = 0;for (j = 0; j<i; j++){if (w[j + 1]<w[j]){swap(w[j + 1], w[j]);  //物品的重量交换lastExchangeIndex = j;swap(t[j], t[j + 1]);}}i = lastExchangeIndex;}
}
void loading(int x[], int w[], int c, int n, int *t)    //最有装载
{sort(w, t, n);for (int i = 0; i<n; i++)x[i] = 0;for (int j = 0; j<n&&w[t[j]] <= c; j++){x[t[j]] = 1;c -= w[t[j]];       //装入 }
}
int main(){int n, c;printf("请输入物品个数：");scanf("%d", &n);printf("请输入最大容量：");scanf("%d", &c);int x[200]; //存储物品编号 int w[200];    //存储每个物品重量for (int i = 0; i<n; i++){printf("请输入第%d个物品重量：", i);scanf("%d", &w[i]);}int *t = new int[n];    //物品是否装入for (int j = 0; j<n; j++)x[j] = 0;   //初始化物品均未装入loading(x, w, c, n, t);printf("装入物品编号为：");for (int k = 0; k<n; k++)if (x[k] == 1)printf("%d ", t[k]);return 0;}

（2）回溯法

#include<stdio.h>
#include<stdlib.h>
#define num 100
int bestx[num] = { 0 };    //存放最优解
int w[num]; //集装箱重量
int x[num]; //解
int bestw = 0; //最优装船重量
int cw = 0;    //当前已装船重量
int n;  //集装箱个数
int c1; //第一船的重量
int c2; //第二船的重量//限界函数
int bound(int t)        // 选择当前节点又分支的剩余集装箱重之和
{int rw = 0;for (int i = t + 1; t<n; t++)rw = rw + w[i];return (rw + cw);    //上界
}
//递归求解
void loadingRec(int t){int i;if (t>n)        //到底叶子节点，求得一个可行解{if (cw>bestw){       //当前解比以前解更优 bestw = cw;for (i = 1; i <= n; i++)bestx[i] = x[i];};return;}else{if (cw + w[t]<c1)        //左分支满足约束条件{x[t] = 1;cw = cw + w[t];loadingRec(t + 1);      //前进继续搜索下一节点//回溯；回复cw与x[t]的值cw = cw - w[t];x[t] = 0;}if (bound(t)>bestw)        //右分支满足限界条件loadingRec(t + 1);}
}
int main(){n = 4;      //集装箱个数printf("集装箱个数:");scanf("%d",&n); printf("集装箱重量:");w[1] = 4, w[2] = 5, w[3] = 3, w[4] = 2;      //集装箱重量for(int i=1;i<=n;i++){scanf("%d",&w[i]);}c1 = 8;       //第一个船重量c2 = 7;        //第二个船重量printf("第一个船重量:");scanf("%d",&c1);printf("第二个船重量:"); scanf("%d",&c2); cw = 0;bestw = 0;loadingRec(1);     //从第一个集装箱开始装箱printf("第一船的最优装载量为：%d\n", bestw);printf("第一船的最优解为");for (int i = 1; i <= n; i++)printf("%d ", bestx[i]);//求剩余集装箱的重量int cw2 = 0;for (int i = 0; i <= n; i++)if (bestx[i] == 0)cw2 += w[i];if (cw2>c2)printf("无法将剩余集装箱转入第二船，问题无解");elseprintf("可以将剩余集装箱装入第二船，问题有解");getchar();
}

（3）分支限界法

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include<queue>
#define num 100
float w[num];   //集装箱重量
int x[num]; //解
float c;
int n;  //集装箱个数
float bestw;
using namespace std;
template<class Type>
class HeapNode;
template<class Type>
class bbnode;
template<class Type>
void AddLiveNode(priority_queue<HeapNode<Type> > &H,bbnode<Type>  *E,Type wt,bool ch,int lev);
template<class Type>
Type MaxLoading(Type w[],Type c,int n,int bestx[]);
template<class Type>
class bbnode
{friend void AddLiveNode<Type>(priority_queue<HeapNode<Type>  > &H,bbnode<Type>  *E,Type wt,bool ch,int lev);friend Type MaxLoading<Type>(Type*,Type,int,int*);friend class AdjacencyGraph;//邻接矩阵public:bbnode<Type> *parent;//指向父节点的指针bool Lchild;//左儿子结点标志
};
template<class Type>
class HeapNode
{friend void AddLiveNode<Type>(priority_queue<HeapNode<Type> > &H,bbnode<Type>  *E,Type wt,bool ch,int lev);friend Type MaxLoading<Type>(Type *,Type,int,int*);public:operator Type () const{return uweight;}public:bbnode<Type>  *ptr;//指向活结点在子集树中相应结点的指针Type uweight;//活结点优先级(上界)int level;//活结点在子集树中所处的层序号
};
//将活结点加入到表示活结点优先队列的最大堆H中
template<class Type>
void AddLiveNode(priority_queue<HeapNode<Type>  > &H,bbnode<Type>  *E,Type wt,bool ch,int lev)
{bbnode<Type>  *b = new bbnode<Type> ;b->parent = E;b->Lchild = ch;HeapNode<Type>N;N.ptr = b;N.uweight = wt;N.level = lev;H.push(N);
}
//优先队列式分支限界法,返回最优载重量,bestx返回最优解
//优先级是当前载重量+剩余重量
template<class Type>
Type MaxLoading(Type w[],Type c,int n,int bestx[])
{priority_queue<HeapNode<Type> > H;//定义最大堆的容量为1000Type *r = new Type [n+1];//剩余重量r[n] = 0;for(int j = n - 1;j > 0;j--){r[j] = r[j+1] + w[j+1];}//初始化int i = 1;//当前扩展结点所在的层bbnode <Type> *E = 0;//当前扩展结点Type Ew = 0;//扩展结点所相应的载重量//搜索子集空间树while(i != n + 1)//非叶子节点{//检查当前扩展结点的儿子节点if(Ew+w[i] <= c){AddLiveNode(H,E,Ew+w[i]+r[i],true,i+1);//左儿子结点为可行结点}AddLiveNode(H,E,Ew+r[i],false,i+1);//右儿子结点HeapNode<Type>N =H.top();//取下一扩展结点H.pop();//下一扩展结点,将最大值删去i = N.level;E = N.ptr;Ew = N.uweight - r[i-1];//当前优先级为上一优先级-上一结点重量}//构造当前最优解,类似回溯的过程for(int j = n;j > 0;j--){bestx[j] = E->Lchild;E = E->parent;}return Ew;
}
int main(){printf("轮船重量:");scanf("%f",&c);printf("请输入物品个数：");scanf("%d", &n);printf("物品的重量:");for(int i=1;i<=n;i++){scanf("%f",&w[i]);}bestw=MaxLoading<float>(w,c,n,x);cout<<"分支限界选择结果为："<<endl;for(int i=1;i<=n;i++){cout<<x[i]<<" ";}cout<<endl;cout<<"最优装载重量为："<<bestw<<endl;return 0;
}

实验结果：

（1）贪心算法

贪心算法并没有求得最优解。

（2）回溯法

（3）分支限界法

心得与体会：

1、 理解和复习贪心算法、回溯法、分支限界法的概念；

2、  掌握和复习贪心算法、回溯法、分支限界法的基本要素；

3、  掌握贪心算法、回溯法、分支限界法的优点和区别；

4、  通过应用范例掌握选择最佳算法的设计技巧与策略；