0-1背包问题

回溯法：适用于背包容量C远大于物品个数N，时间复杂度Ｏ（２*N ）

import java.util.Arrays;
import java.util.Scanner;

public class Knapsack {
private Bag[] bags;
private int capacity;
private int[] x;
private int maxValue;
private int currentValue;
private int currentWeight;
int count = 0;

public Knapsack(Bag[] bags, int capacity){
this.bags = bags;
this.capacity = capacity;
this.x = new int[bags.length];
this.maxValue = 0;
this.currentValue = 0;
this.currentWeight = 0;
}

public int getMaxValue(){
//sort the bag in decrease order by value/weight
Arrays.sort(bags);
getMaxValue(0);
return this.maxValue;
}

private void getMaxValue(int level){
count ++;
//find a answer
if(level >= bags.length){
if(currentValue > maxValue)
maxValue = currentValue;
return;
}
//choose the current bag
if(this.currentWeight + bags[level].weight <= this.capacity){
this.x[level] = 1;
this.currentValue += bags[level].value;
this.currentWeight += bags[level].weight;
getMaxValue(level + 1);
this.currentValue -= bags[level].value;
this.currentWeight -= bags[level].weight;
}
//check next bag if currentValue + result of full knapsack > bestValue
if(bound(level + 1)){
this.x[level] = 0;
getMaxValue(level + 1);
}
}

private boolean bound(int level){
float max = this.currentValue;
int available = this.capacity - this.currentWeight;
//use the result of full knapsack with capacity 'available' as the bound
while(level < bags.length && bags[level].weight <= available){
available -= bags[level].weight;
max += bags[level].value;
level++;
}
if(level < bags.length){
max += available * bags[level].price;
}
return max >= this.maxValue;
}

private static class Bag implements Comparable<Bag>{
int weight;
int value;
float price;

public Bag(int weight, int value) {
super();
this.weight = weight;
this.value = value;
this.price = (float)value / (float)weight;
}

@Override
public int compareTo(Bag other) {
if((other.price - this.price) > 0) return 1;
else return -1;
}
}

public static void main(String[] args){
Scanner stdIn = new Scanner(System.in);
while(stdIn.hasNext()){
int capacity = stdIn.nextInt();
if(capacity <= 0) break;
int bagNum = stdIn.nextInt();
Bag[] bags = new Bag[bagNum];
for(int i = 0; i < bagNum; i++){
int weight = stdIn.nextInt();
int value = stdIn.nextInt();
bags[i] = new Bag(weight, value);
}

Knapsack OJ = new Knapsack(bags, capacity);
System.out.println(OJ.getMaxValue());
System.out.println(OJ.count);
}
}
}

分支限界算法：采用优先队列对子集树进行搜索。对于某个结点，上界 = 剩余背包容量的完全背包最优解 + 当前收益。算法不断扩展结点，直至子集树的叶结点成为扩展结点为止。此时，该叶结点相应的解为最优解，优先队列所有活结点的上界值均不超过该叶结点的价值收益（对于该结点，收益上界 = 当前收益）。

public class Knapsack {
private Bag[] bags;
private int capacity;
private int maxValue;
//current expand node
private Node current;
private PriorityQueue<Node> queue;
private boolean[] bestX;

public Knapsack(Bag[] bags, int capacity){
this.bags = bags;
this.capacity = capacity;
this.maxValue = 0;
this.bestX = new boolean[this.bags.length + 1];
this.queue = new PriorityQueue<Node>();
}

public int getMaxValue(){
int level = 0;
Arrays.sort(bags);
this.current = new Node(0, 0, 0, bound(0), false, null);
while(level  != bags.length){
//try to choose the bags[level]
if(current.currentWeight + bags[level].weight <= this.capacity){
if(current.currentValue + bags[level].value > maxValue){
maxValue = current.currentValue + bags[level].value;
}
queue.add(new Node(level + 1, current.currentValue + bags[level].value,
current.currentWeight + bags[level].weight, current.upBound, true, current));
}
//try to discard the bags[level]
float upBound = bound(level + 1);
if( upBound >= maxValue){
queue.add(new Node(level + 1, current.currentValue,
current.currentWeight, upBound, false, current));
}
current = queue.poll();
level = current.level;
}
return current.currentValue;
}

public void showSolution(){
calSolution();
for(int i = 1; i < bags.length; i++){
if(bestX[i]) System.out.printf("%d ", i);
}
if(bestX[bags.length]){
System.out.print(bags.length);
}
System.out.println();
}

private void calSolution(){
while(null != current.parent){
this.bestX[current.level] = current.choose;
current = current.parent;
}
}

private float bound(int level){
float max = 0;
int available = 0;
if(0 == level){
max = 0;
available = this.capacity;
}else{
max = current.currentValue;
available = this.capacity - current.currentWeight;
}
//use the result of full knapsack with capacity 'available' as the bound
while(level < bags.length && bags[level].weight <= available){
available -= bags[level].weight;
max += bags[level].value;
level++;
}
if(level < bags.length){
max += available * bags[level].price;
}
return max;
}

private class Node implements Comparable<Node>{
int level;
int currentValue;
int currentWeight;
float upBound;
boolean choose;
Node parent;

@Override
public int compareTo(Node o) {
if(this.upBound < o.upBound) return 1;
else return -1;
}

public Node(int level, int currentValue, int currentWeight,
float upBound, boolean choose, Node parent) {
super();
this.level = level;
this.currentValue = currentValue;
this.currentWeight = currentWeight;
this.upBound = upBound;
this.choose = choose;
this.parent = parent;
}
}

private static class Bag implements Comparable<Bag>{
int weight;
int value;
float price;

public Bag(int weight, int value) {
super();
this.weight = weight;
this.value = value;
this.price = (float)value / (float)weight;
}

@Override
public int compareTo(Bag other) {
if((this.price- other.price) < 0) return 1;
else return -1;
}
}
}

动态规划：由于大多数情况下，部分子问题不用求解，故适合采用备忘录方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Knapsack {
private int W;
private int n;
private int[] w;
private int[] v;
private int[][] f;
private int countCall = 0;

public Knapsack(int W, int n, int[] w, int[] v){
this.W = W;
if(n != w.length || n != v.length){
throw new IllegalArgumentException();
}
this.n = n;
this.w = w;
this.v = v;
this.f = new int[n + 1][W + 1];
}

/**
* 0-1背包问题，对于K相对物品个数n较大的情况，备忘录方法效率更高
* 它可以避免计算一些不可达的子问题空间	 *
* @return the
*/
public int oneZeroKnapsack(){
for(int i = 0; i <= n; i++)
for(int j = 0; j <= W; j++)
f[i][j] = Integer.MAX_VALUE;
return lookup_chain(n , W);
}

public void showObjects(){
int i = n , j = W;
while(i > 0){
if(f[i][j] != f[i-1][j]){
System.out.println(i);
j -= w[i-1];
}
i--;
}
}
private int lookup_chain(int i , int j){
countCall++;
if( Integer.MAX_VALUE != f[i][j]) return f[i][j];
if( i <= 0 || j <= 0 ) return 0;

if(w[i-1] > j){
f[i][j] = lookup_chain(i-1, j);
}
else{
int choose = lookup_chain(i-1, j-w[i-1]) + v[i-1];
int noChoose = lookup_chain(i-1 ,j);
if(choose > noChoose)
f[i][j] = choose;
else f[i][j] =noChoose;
}
return f[i][j];
}
private class Node implements Comparable<Node>{
int weight;
private int value;
int seq;
float price;

public Node(int weight, int value , int seq){
this.weight = weight;
this.value = value;
this.seq = seq;
this.price = value / weight;
}

@Override
public int compareTo(Node o) {
if (o.price - this.price > 0) return 1;
else return -1;
}
}
}

ＤＰ算法：对于物品重量较小，且背包容量Ｃ＝Ｏ（Ｎ）时，适合采用传统的自底向上的DP算法（时间复杂度为O（ＣＮ））。但此场景比较少见，故未给出该算法