AcWing-3. Complete knapsack problem (java implementation)

AcWing-3. Complete knapsack problem

topic description

There are N items and a knapsack of capacity V, and infinite pieces of each item are available.

The volume of the i-th item is vi, and the value is wi.

Solve which items to put into the backpack so that the total volume of these items does not exceed the capacity of the backpack and the total value is the largest.
output the maximum value.

input format

In the first line, two integers, N and V, are separated by spaces, which represent the number of items and the volume of the backpack respectively.

Then there are N lines, and each line has two integers vi, wi, separated by spaces, representing the volume and value of the i-th item respectively.

output format

Output an integer representing the maximum value.

data range

0<N,V≤1000
0<vi,wi≤1000

Input sample:

4 5
1 2
2 4
3 4
4 5

Sample output:

10

Ideas (plain version)

$$Staterepresentation:f(i,j),Representsallvaluesetsselectedfrom1toiwhose\; capacitydoesnotexceedj$$

$$Attributes:Max$$

$$the\; core:Thelastnumberiis\; nottakenorkistaken(the\; maximum\; valueofkisthe\; maximumpossiblenumberofi,thatis,the\; totalcapacitydoes\; notexceedjaftertakingki)$$

$$statedivision:f(i-1,j)take0i,\_1i\_\dots \dots ,kibecomef(i,\_j)$$

The state transition equation can be obtained by state division:
$$f(i,j)=Max(f(i-1,j),f(i-1,j-vi)+wi,f(i-1,j-2\ast vi)+2\ast wi,\dots \dots ,f(i-1,j-k\ast vi)+k\ast wi)$$

core code

		for(int i=1;i<=n;i++) {
    
    
			for(int j=1;j<=v;j++) {
    
    
				dp[i][j] = dp[i-1][j];
				if(a[i].v<=j) {
    
    
					for(int k=1;k<=j/a[i].v;k++) {
    
    
						dp[i][j] = Math.max(dp[i][j],dp[i-1][j-k*a[i].v]+k*a[i].w);
					}
				}
			}
		}

full code

package acWing003;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
public class Main {
    
    
	static int N = 1010;
	static int n,v;
	static Pair a[] = new Pair[N];
	static int dp[][] = new int[N][N];
	public static void main(String[] args) throws Exception{
    
    
		Read r = new Read();
		n = r.nextInt();v = r.nextInt();
		for(int i=1;i<=n;i++) {
    
    
			a[i] = new Pair(r.nextInt(),r.nextInt());
		}
		for(int i=1;i<=n;i++) {
    
    
			for(int j=1;j<=v;j++) {
    
    
				dp[i][j] = dp[i-1][j];
				if(a[i].v<=j) {
    
    
					for(int k=1;k<=j/a[i].v;k++) {
    
    
						dp[i][j] = Math.max(dp[i][j],dp[i-1][j-k*a[i].v]+k*a[i].w);
					}
				}
			}
		}
		System.out.println(dp[n][v]);
	}
}
class Pair{
    
    
	int v,w;
	public Pair(int a,int b){
    
    
		v = a;
		w = b;
	}
}
class Read{
    
    
	StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	public int nextInt() throws Exception{
    
    
		st.nextToken();
		return (int)st.nval;
	}
}

optimization (state optimization)

The state transition equation can be obtained by state division:
$$f(i,j)=Max\left(f\right(i-1,j),f(i-1,j-vi)+wi,f(i-1,j-2\ast vi)+2\ast wi,\dots \dots ,f(i-1,j-k\ast vi)+k\ast wi)$$

$$f(i,j-vi)=Max(f(i-1,j-vi),f(i-1,j-2\ast vi)+wi,\dots \dots ,f(i-1,j-k\ast vi)+(k-1)\ast wi)$$

Combined to obtain the final state transition equation:
$$f(i,j)=Max\left(f\right(i-1,j),f(i,j-vi)+wi)$$

core code

		for(int i=1;i<=n;i++) {
    
    
			for(int j=1;j<=v;j++) {
    
    
				dp[i][j] = dp[i-1][j];
				if(a[i].v<=j) {
    
    
					dp[i][j] = Math.max(dp[i][j],dp[i][j-a[i].v]+a[i].w);
				}
			}
		}

full code

package acWing003;
//	读入和Pair类都在朴素版
public class Main2 {
    
    
	static int N = 1010;
	static int n,v;
	static Pair a[] = new Pair[N];
	static int dp[][] = new int[N][N];
	public static void main(String[] args) throws Exception{
    
    
		Read r = new Read();
		n = r.nextInt();v = r.nextInt();
		for(int i=1;i<=n;i++) {
    
    
			a[i] = new Pair(r.nextInt(),r.nextInt());
		}
		for(int i=1;i<=n;i++) {
    
    
			for(int j=1;j<=v;j++) {
    
    
				dp[i][j] = dp[i-1][j];
				if(a[i].v<=j) {
    
    
					dp[i][j] = Math.max(dp[i][j],dp[i][j-a[i].v]+a[i].w);
				}
			}
		}
		System.out.println(dp[n][v]);
	}
}

Optimization (use rolling array dimensionality reduction)

The combined final state transition equation is:
$$f(i,j)=Max(f(i-1,j),f(i,j-vi)+wi)$$
It can be seen from the state equation that only the current line and the previous line need to be used, so the concept of rolling array can be used to reduce the two-dimensional to one-dimensional, namely:
$$f(j)=Max(f(j),f(j-vi)+wi)$$

core code

		for(int i=1;i<=n;i++) {
    
    
			for(int j=a[i].v;j<=v;j++) {
    
    
				dp[j] = Math.max(dp[j],dp[j-a[i].v]+a[i].w);
			}
		}

full code

package acWing003;
//	读入和Pair类都在朴素版
public class Main3 {
    
    
	static int N = 1010;
	static int n,v;
	static Pair a[] = new Pair[N];
	static int dp[] = new int[N];
	public static void main(String[] args) throws Exception{
    
    
		Read r = new Read();
		n = r.nextInt();v = r.nextInt();
		for(int i=1;i<=n;i++) {
    
    
			a[i] = new Pair(r.nextInt(),r.nextInt());
		}
		for(int i=1;i<=n;i++) {
    
    
			for(int j=a[i].v;j<=v;j++) {
    
    
				dp[j] = Math.max(dp[j],dp[j-a[i].v]+a[i].w);
			}
		}
		System.out.println(dp[v]);
	}
}