本文目录一览：

关于这个java语言描述的0-1背包问题是否有错误？
背包问题算法java实现
[回溯法解决0-1背包问题 java写的求大神指点~~~~(>_)
java写背包问题没看懂
01背包问题变种：从给定的N个正数中选取若干个数之和最接近M的JAVA写法
0-1背包问题java代码

关于这个java语言描述的0-1背包问题是否有错误？

有点问题：

public static void knapsack(int[] v, int[] w, int c, int[][] m) {
    int n = v.length - 1;
    int jMax = Math.min(w[n] - 1, c);
    for (int j = 0; j <= jMax; j++)
        m[n][j] = 0;
    for (int j = w[n]; j <= c; j++)
        m[n][j] = v[n];
    for (int i = n - 1; i > 1; i--) {
        jMax = Math.min(w[i] - 1, c);
        for (int j = 0; j <= jMax; j++)
            m[i][j] = m[i + 1][j];
        for (int j = w[i]; j <= c; j++)
            m[i][j] = Math.max(m[i + 1][j], m[i + 1][j - w[i]] + v[i]);
    }
    m[1][c] = m[2][c];
    if (c >= w[1])
        m[1][c] = Math.max(m[1][c], m[2][c - w[1]] + v[1]);
}

public static void traceback(int[][] m, int[] w, int c, int[] x) {
    int n = w.length - 1;
    for (int i = 1; i < n; i++) {
        if (m[i][c] == m[i + 1][c]) x[i] = 0;
        else {
            x[i] = 1;
            c -= w[i];
        }
    }
    x[n] = (m[n][c] > 0) ? 1 : 0;
}

背包问题算法java实现

任何语言都是一样的，贪心算法，先按价值除重量排序，一个一个的加到背包里，当超过背包允许的重量后，去掉最后加进去一个，跳过这一个以后再加后面的，如果还是超重，再跳过这个，一直到价值最大化位置。

回溯法解决0-1背包问题 java写的求大神指点~~~~(>_

因为你把n和c 定义为static ,而且初始化为0。数组也为静态的，一个类中静态的变量在这个类加载的时就会执行，所以当你这类加载的时候，你的数组

static int[] v = new int[n];
static int[] w = new int[n];

就已经初始化完毕，而且数组大小为0。在main方法里动态改变n的值是改变不了已经初始化完毕的数组的大小的，因为组已经加载完毕。我建议你可以在定义n,c时就为其赋初值。比如（static int n=2 static int c=3）

java写背包问题没看懂

m[][] 就是一个二维数组。你平时看见的a[] 这样的数组是用来定义一维数组的，里面放的东西你应该明白。二维数组其实和一维数组差不多，只不过二维数组的m[]放的是另外一个m1[]这样的数组。两个数组就从线变成了面，类似于XY坐标图了。这就是二维数组，面上的关系。

01背包问题变种：从给定的N个正数中选取若干个数之和最接近M的JAVA写法

BIAS0 := (C - MA(C, 2)) / MA(C, 2) * 100;
BIAS1 := (C - MA(C, 12)) / MA(C, 12) * 100;
BIAS2 := (C - MA(C, 26)) / MA(C, 26) * 100;
BIAS3 := (C - MA(C, 48)) / MA(C, 48) * 100;
HXL := V / CAPITAL * 100;
D1 := INDEXC;
D2 := MA(D1, 56);
DR2 := D1 / D2 * 0.94;
E1 := (C - HHV(C, 12)) / HHV(C, 12) * 10;
E2 := (C - REF(C, 26)) / REF(C, 26) * 10;

0-1背包问题java代码

import java.io.BufferedInputStream;
import java.util.Scanner;
public class test {
    public static int[] weight = new int[101];
    public static int[] value = new int[101];
    public static void main(String[] args) {
        Scanner cin = new Scanner(new BufferedInputStream(System.in));
        int n = cin.nextInt();
        int W = cin.nextInt();
        for (int i = 0; i < n; ++i) {
            weight[i] = cin.nextInt();
            value[i] = cin.nextInt();
        }
        cin.close();
        System.out.println(solve(0, W, n)); // 普通递归
        System.out.println("=========");
        System.out.println(solve2(weight, value, W)); // 动态规划表
    }
    public static int solve(int i, int W, int n) {
        int res;
        if (i == n) {
            res = 0;
        } else if (W < weight[i]) {
            res = solve(i + 1, W, n);
        } else {
            res = Math.max(solve(i + 1, W, n), solve(i + 1, W - weight[i], n) + value[i]);
        }
        return res;
    }
    public static int solve2(int[] weight, int[] value, int W) {
        int[][] dp = new int[weight.length + 1][W + 1];
        for (int i = weight.length - 1; i >= 0; --i) {
            for (int j = W; j >= 0; --j) {
                dp[i][j] = dp[i + 1][j]; // 从右下往左上，i+1就是刚刚记忆过的背包装到i+1重量时的最大价值
                if (j + weight[i] <= W) { // dp[i][j]就是背包已经装了j的重量时，能够获得的最大价值
                    dp[i][j] = Math.max(dp[i][j], value[i] + dp[i + 1][j + weight[i]]); // 当背包重量为j时，要么沿用刚刚装的，本次不装，最大价值dp[i][j]，要么就把这个重物装了，那么此时背包装的重量为j+weight[i]，
                    // 用本次的价值value[i]加上背包已经装了j+weight[i]时还能获得的最大价值，因为是从底下往上，刚刚上一步算过，可以直接用dp[i+1][j+weight[i]]。
                    // 然后选取本次不装weight[i]重物时获得的最大价值以及本次装weight[i]重物获得的最大价值两者之间的最大值
                }
            }
        }
        return dp[0][0];
    }
}

java背包问题,背包问题例子