Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Formatted with Google Java Formatter

Browse Source
This commit is contained in:
github-actions 2021-09-17 17:03:36 +00:00
parent e6fb81d1bb
commit f981a2b979
3 changed files with 94 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
DynamicProgramming/BruteForceKnapsack.java
View File

@ -4,40 +4,38 @@ package DynamicProgramming;
of 0-1 Knapsack problem */ of 0-1 Knapsack problem */
public class BruteForceKnapsack { public class BruteForceKnapsack {
// A utility function that returns // A utility function that returns
// maximum of two integers // maximum of two integers
static int max(int a, int b) { static int max(int a, int b) {
return (a > b) ? a : b; return (a > b) ? a : b;
} }
// Returns the maximum value that // Returns the maximum value that
// can be put in a knapsack of // can be put in a knapsack of
// capacity W // capacity W
static int knapSack(int W, int wt[], int val[], int n) { static int knapSack(int W, int wt[], int val[], int n) {
// Base Case // Base Case
if (n == 0 || W == 0) if (n == 0 || W == 0) return 0;
return 0;
// If weight of the nth item is // If weight of the nth item is
// more than Knapsack capacity W, // more than Knapsack capacity W,
// then this item cannot be included // then this item cannot be included
// in the optimal solution // in the optimal solution
if (wt[n - 1] > W) if (wt[n - 1] > W) return knapSack(W, wt, val, n - 1);
return knapSack(W, wt, val, n - 1);
// Return the maximum of two cases: // Return the maximum of two cases:
// (1) nth item included // (1) nth item included
// (2) not included // (2) not included
else else
return max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), knapSack(W, wt, val, n - 1)); return max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), knapSack(W, wt, val, n - 1));
} }
// Driver code // Driver code
public static void main(String args[]) { public static void main(String args[]) {
int val[] = new int[] { 60, 100, 120 }; int val[] = new int[] {60, 100, 120};
int wt[] = new int[] { 10, 20, 30 }; int wt[] = new int[] {10, 20, 30};
int W = 50; int W = 50;
int n = val.length; int n = val.length;
System.out.println(knapSack(W, wt, val, n)); System.out.println(knapSack(W, wt, val, n));
} }
} }

55
DynamicProgramming/DyanamicProgrammingKnapsack.java
View File

@ -3,37 +3,34 @@ package DynamicProgramming;
// A Dynamic Programming based solution // A Dynamic Programming based solution
// for 0-1 Knapsack problem // for 0-1 Knapsack problem
public class DyanamicProgrammingKnapsack { public class DyanamicProgrammingKnapsack {
static int max(int a, int b) { static int max(int a, int b) {
return (a > b) ? a : b; return (a > b) ? a : b;
} }
// Returns the maximum value that can // Returns the maximum value that can
// be put in a knapsack of capacity W // be put in a knapsack of capacity W
static int knapSack(int W, int wt[], int val[], int n) { static int knapSack(int W, int wt[], int val[], int n) {
int i, w; int i, w;
int K[][] = new int[n + 1][W + 1]; int K[][] = new int[n + 1][W + 1];
// Build table K[][] in bottom up manner // Build table K[][] in bottom up manner
for (i = 0; i <= n; i++) { for (i = 0; i <= n; i++) {
for (w = 0; w <= W; w++) { for (w = 0; w <= W; w++) {
if (i == 0 || w == 0) if (i == 0 || w == 0) K[i][w] = 0;
K[i][w] = 0; else if (wt[i - 1] <= w) K[i][w] = max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]);
else if (wt[i - 1] <= w) else K[i][w] = K[i - 1][w];
K[i][w] = max(val[i - 1] + K[i - 1][w - wt[i - 1]], K[i - 1][w]); }
else }
K[i][w] = K[i - 1][w];
}
}
return K[n][W]; return K[n][W];
} }
// Driver code // Driver code
public static void main(String args[]) { public static void main(String args[]) {
int val[] = new int[] { 60, 100, 120 }; int val[] = new int[] {60, 100, 120};
int wt[] = new int[] { 10, 20, 30 }; int wt[] = new int[] {10, 20, 30};
int W = 50; int W = 50;
int n = val.length; int n = val.length;
System.out.println(knapSack(W, wt, val, n)); System.out.println(knapSack(W, wt, val, n));
} }
} }

79
DynamicProgramming/MemoizationTechniqueKnapsack.java
View File

@ -1,59 +1,56 @@
package DynamicProgramming; package DynamicProgramming;
// Here is the top-down approach of // Here is the top-down approach of
// dynamic programming // dynamic programming
public class MemoizationTechniqueKnapsack { public class MemoizationTechniqueKnapsack {
//A utility function that returns // A utility function that returns
//maximum of two integers // maximum of two integers
static int max(int a, int b) { static int max(int a, int b) {
return (a > b) ? a : b; return (a > b) ? a : b;
} }
//Returns the value of maximum profit // Returns the value of maximum profit
static int knapSackRec(int W, int wt[], int val[], int n, int[][] dp) { static int knapSackRec(int W, int wt[], int val[], int n, int[][] dp) {
// Base condition // Base condition
if (n == 0 || W == 0) if (n == 0 || W == 0) return 0;
return 0;
if (dp[n][W] != -1) if (dp[n][W] != -1) return dp[n][W];
return dp[n][W];
if (wt[n - 1] > W) if (wt[n - 1] > W)
// Store the value of function call // Store the value of function call
// stack in table before return // stack in table before return
return dp[n][W] = knapSackRec(W, wt, val, n - 1, dp); return dp[n][W] = knapSackRec(W, wt, val, n - 1, dp);
else
else // Return value of table after storing
return dp[n][W] =
max(
(val[n - 1] + knapSackRec(W - wt[n - 1], wt, val, n - 1, dp)),
knapSackRec(W, wt, val, n - 1, dp));
}
// Return value of table after storing static int knapSack(int W, int wt[], int val[], int N) {
return dp[n][W] = max((val[n - 1] + knapSackRec(W - wt[n - 1], wt, val, n - 1, dp)),
knapSackRec(W, wt, val, n - 1, dp));
}
static int knapSack(int W, int wt[], int val[], int N) { // Declare the table dynamically
int dp[][] = new int[N + 1][W + 1];
// Declare the table dynamically // Loop to initially filled the
int dp[][] = new int[N + 1][W + 1]; // table with -1
for (int i = 0; i < N + 1; i++) for (int j = 0; j < W + 1; j++) dp[i][j] = -1;
// Loop to initially filled the return knapSackRec(W, wt, val, N, dp);
// table with -1 }
for (int i = 0; i < N + 1; i++)
for (int j = 0; j < W + 1; j++)
dp[i][j] = -1;
return knapSackRec(W, wt, val, N, dp); // Driver Code
} public static void main(String[] args) {
int val[] = {60, 100, 120};
int wt[] = {10, 20, 30};
//Driver Code int W = 50;
public static void main(String[] args) { int N = val.length;
int val[] = { 60, 100, 120 };
int wt[] = { 10, 20, 30 };
int W = 50; System.out.println(knapSack(W, wt, val, N));
int N = val.length; }
System.out.println(knapSack(W, wt, val, N));
}
} }