01背包问题（几种算法解）

 

标题：	0-1背包问题
时 限：	1000 ms
内存限制：	10000 K
总时限：	3000 ms
描述：	需对容量为c 的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高。
输入：	多个测例，每个测例的输入占三行。第一行两个整数：n（n<=10）和c，第二行n个整数分别是w1到wn，第三行n个整数分别是p1到pn。n 和 c 都等于零标志输入结束。
输出：	每个测例的输出占一行，输出一个整数，即最佳装载的总价值。
输入样例：	1 2 1 1 2 3 2 2 3 4 0 0
输出样例：	1 4
提示：
来源：

 

import java.sql.Array;
import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    static double c = 0;
    static int n = 0;
    static double[] w;
    static double[] p;
    static double cw;
    static double cp;
    static double bestp;

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        ArrayList<Integer> list=new ArrayList<Integer>();
        Scanner myscanner = new Scanner(System.in);
        n = myscanner.nextInt();
        c = myscanner.nextDouble();
        
        while (!(n == 0 && c == 0)) {
            double[] pp = new double[n + 1];
            double[] ww = new double[n + 1];
            for (int i = 1; i <= n; i++) {
                ww[i] = myscanner.nextDouble();
            }
            for (int i = 1; i <= n; i++) {
                pp[i] = myscanner.nextDouble();
            }          
            Knapsack(pp, ww, c);
            //System.out.println("最大价值为：" + bestp);
            list.add((int) bestp);
            //System.out.println("请输入背包容量n的大小：");
            n = myscanner.nextInt();
            //System.out.println("请输入背包容量c的大小：");
            c = myscanner.nextDouble();
        }
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static class Element implements Comparable {
        int id;
        double d;

        private Element(int idd, double dd) {
            id = idd;
            d = dd;
        }

        public int compareTo(Object x) {
            double xd = ((Element) x).d;
            if (d < xd)
                return -1;
            if (d == xd)
                return 0;
            return 1;
        }

        public boolean equals(Object x) {
            return d == ((Element) x).d;
        }
    }

    public static double Knapsack(double[] pp, double[] ww, double cc) {
        c = cc;
        cw = 0.0;
        cp = 0.0;
        n = pp.length - 1;
        bestp = 0.0;

        Element[] q = new Element[n];

        for (int i = 1; i <= n; i++) {
            q[i - 1] = new Element(i, pp[i] / ww[i]);
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (q[j].d > q[j + 1].d) {
                    double temp = q[j].d;
                    q[j].d = q[j + 1].d;
                    q[j + 1].d = temp;
                }
            }
        }

        p = new double[n + 1];
        w = new double[n + 1];
        for (int i = 1; i <= n; i++) {
            p[i] = pp[q[n - i].id];
            w[i] = ww[q[n - i].id];
        }

        backtrack(1);
        return bestp;
    }

    public static void backtrack(int i) {
        if (i > n) {
            bestp = cp;
            return;
        }

        if (cw + w[i] <= c) {
            cw += w[i];
            cp += p[i];
            backtrack(i + 1);
            cw -= w[i];
            cp -= p[i];
        }

        if (bound(i + 1) > bestp) {
            backtrack(i + 1);
        }
    }

    public static double bound(int i) {
        double cleft = c - cw;
        double bound = cp;
        while (i <= n && w[i] <= cleft) {
            cleft -= w[i];
            bound += p[i];
            i++;
        }

        if (i <= n) {
            bound += p[i] * cleft / w[i];
        }

        return bound;
    }
}