本文目录一览:
- 1、关于这个java语言描述的0-1背包问题是否有错误?
- 2、背包问题算法java实现
- 3、回溯法解决0-1背包问题 java写的 求大神指点~~~~(>_
- 4、java写背包问题没看懂
- 5、01背包问题变种:从给定的N个正数中选取若干个数之和最接近M的JAVA写法
- 6、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;i1;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;in;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;
}
//int n=w.length-1;
for(int i=1;in;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/D20.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];
}
}