回溯算法非递归背包问题c语言,回溯算法---0-1背包问题

引言：这道题目老师强调了肯定要考，所以只有硬着头皮将其复习了;下面是自己学习回溯算法的学习，仅供参考；

一：基本概念：

回溯算法：“回朔法”有通用的解题方法之称。使用它可以系统搜索一个问题的所有解或者一个解。回溯法是一个即带有系统性有带有跳跃性的算法。它在问题的解空间树中，按照深度优先的策略，从根节点出发搜索解空间树。算法搜索到解空间的任意一点时先判断该点是否包含问题的解，如果肯定不包含，就跳过对以该节点为根的子树的搜索，逐层向其祖先节点回溯。否则，进入该子树，继续按照深度优先策略搜索。回朔法求问题，要回溯到根，并且根节点的所有子树都要遍历完才结束。回溯法求解问题时，只要求得一个解就可以结束，这种以深度优先方式系统的搜索问题解的方法称之为回朔法；

适用于：组合数较大的问题！

使用回朔法求解时，有两种方法可以避免无效搜索:

1：使用约束函数在扩展节点处剪去不满足约束的子树

2：使用限界函数剪去得不到最优解的子树；

子集树：当所给的问题从n个元素的集合S中找出满足某种性质的子集时，相应的解空间树称为子集树。

排序树：当所给的问题是确定n个元素满足某种性质的排列时，相应的解空间树称之为排列树。排序树通常有n！叶结点。

使用回溯法求解问题通常包含以下3个步骤：

1：针对所给问题，定义问题的解空间

2：确定易于搜索的解空间的结构

3：以深度优先的方式搜索解空间，并在搜索的过程中用剪支函数避免无效搜索；

二：问题描述：

现在有一个载重为10kg的背包，共有5件物品可以装载，他们的重量以及各个物品对应的价值如下：

重量：{3.4kg,2.5kg,6kg,4kg,9.0kg};

价值：{3,2.5,5,9,6.2};

问怎么样装载这些物品使得最终所得的价值最大？

求解步骤：

1：明确该问题可用回溯法求解，它的解空间可以使用子集树来表示。

2：计算出各个物品的单位重量价值分别为：{0.88,1,0.83,2.25,0.699};

讲这些物品按照单位重量价值递减的顺序排列：{4kg,2.5kg,3.4kg,6kg,9.0kg}

3:按照这个排序我们先装入物品4和物品2以及物品1；此时背包中已经装入了9.9kg的物品了；还剩下0.1kg;我们将再装入0.1kg的物品3；最终得到的总价值为：14.58;我们可以知道这个实例的优值不会超多14.58；

4：按照上述回溯顺序我们继续计算最终得出按照上述方法装载所得到的解就是最优解；

上代码：

package huisuo;

import java.util.Arrays;

public class Package {

//先定义一个类，用来表示物品

class MyElement implements Comparable{

//物品重量

float weight;

//物品价值

float value;

//是否带走物品

boolean take = false;

public MyElement(float w,float v){

this.weight = w;

this.value = v;

}

//比较物品的均值：用来排序

@Override

public int compareTo(Object o) {

MyElement o1 = (MyElement)o;

float currentR = value/weight;

float R = o1.value/o1.weight;

if(currentR

return 1;

}else{

return -1;

}

}

}

private MyElement[] myelements;//物品的集合

private float S;//背包的容量

private float nowWeight;//记录当前已经装载的物品的总重量

private float nowPrice;//记录当前已经拿到物品的总价值

private float betterPrice;//记录当前已经装的物品的最好价格

public Package(float[] w,float[] v,float s){

int len = w.length;

this.S = s;

myelements = new MyElement[len];

for(int i =0;i

myelements[i] = new MyElement(w[i],v[i]);

}

//默认是从小到大排序，但是我们将其改了。此时排序是从大到小；

Arrays.sort(myelements);

System.out.println("物品的价值为："+" "+"物品重量！");

for(int i = 0;i

System.out.print(myelements[i].value+" "+myelements[i].weight);

System.out.println();

}

}

/**

* 用于打印已经装入背包的物品

* @param myelements

*/

public void Output(MyElement[] myelements){

System.out.println("现在装入的物品为(重量)：");

int len = myelements.length;

for(int i = 0 ;i

if(myelements[i].take){

System.out.print(myelements[i].weight+" ");

}

}

}

/**

* 递归搜索这颗树

* @param t 表示递归树的层数

*/

public void traceBack(int t){

if(t>=myelements.length){

System.out.println("已经找到合适的策略");

betterPrice = nowPrice;

Output(myelements);

return;

}

//首先进入左子树

if(nowWeight+myelements[t].weight

//进入左子树

nowWeight += myelements[t].weight;

nowPrice += myelements[t].value;

myelements[t].take = true;

traceBack(t+1);

nowWeight-=myelements[t].weight;

System.out.println("恢复现场");

//恢复现场

nowPrice -= myelements[t].value;

myelements[t].take = false;

}else{

float rightP=bound(t+1);

System.out.println("aaaaaaaaaa"+rightP);

if(rightP>betterPrice){

traceBack(t+1);

}

}

}

/**

* 查询装载当前节点右子树的节点时的总价值

* @param i

* @return

*/

public float bound(int i){

//计算当前给右背包留下的容量

float cleft = S - nowWeight;

//右子树如果一个节点都装不下时；最好的价值仍然是当前的价值

float bound = nowPrice;

int len = myelements.length;

while(imyelements[i].weight){

cleft -=myelements[i].weight;

bound+= myelements[i].value;

i++;

myelements[i].take = true;

}

return bound;

}

public static void main(String[] args) {

float[] w = {3.4f,2.5f,6f,4f,9.0f};

float[] v = {3f,2.5f,5f,9f,6.2f};

float s = 10;

Package package1 = new Package(w,v,s);

package1.traceBack(0);

}

}