Add files via upload

Author: jpa99

DP/Edit_Distance.java

@@ -0,0 +1,71 @@
+import java.util.Arrays;
+
+public class Edit_Distance {
+	
+	/*Edit (Levenshtein Distance) Algorithm
+
+	 Problem (informal): Given two strings, find minimum number of deletions, insertions, or replacements required to transform 
+	 
+	 Algorithm: If characters are same, continue, else, consider removal, deletion, and replacement and consider minimum recursively
+	 
+	 Complexity:
+	 	* Time - O(n^2) 
+	 	* Space - O(n^2) with memoization and O(1) without
+	 	
+	 Functions Defined:
+	 	* editDistanceIterative() - Bottom up implementation, finds minimum iteratively
+	 	* editDistanceRecursive() - Top down implementation, recursive
+	 	
+	 */
+
+	static int[][] dp;
+	public static void main(String[] args) {
+		String a = "hey if you like this repository, you should give it a star!";
+		String b = "I'd appreciate any feedback or requests -- just fork this repo and add to the README.md";
+		
+		dp = new int [a.length()+1][b.length()+1];
+		
+		for(int[] row :dp){
+			Arrays.fill(row, -1);
+		}
+		
+		System.out.println(editDistanceIterative(a, b));
+		System.out.println(editDistanceTD(a, b));
+
+	}
+	
+	public static int editDistanceIterative(String a, String b){
+		int[][] dp = new int[a.length()+1][b.length()+1];
+		for(int i=0; i <= a.length();i++){
+			for(int j=0; j <= b.length();j++){
+				if(i==0 || j==0)
+					dp[i][j] = i+j;
+				else if(a.charAt(i-1) == b.charAt(j-1))
+					dp[i][j] = dp[i-1][j-1];
+				else
+					dp[i][j] = 1 + Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]);
+			}
+		}
+		return dp[a.length()][b.length()];
+	}
+	
+	//minimal # of insertions, substitutions, deletions required to change String a to b
+	public static int editDistanceTD(String a, String b){
+		int m = a.length();
+		int n = b.length();
+		if(dp[m][n] !=-1){ 
+			return dp[m][n];
+		}
+		if(m==0 || n==0){
+			dp[m][n] = m+n;
+			return dp[m][n];
+		}
+		if(a.charAt(m-1) == b.charAt(n-1)){
+			dp[m][n] = editDistanceTD(a.substring(0, m-1), b.substring(0, n-1));
+			return dp[m][n];
+		}
+		dp[m][n] = 1 + Math.min(Math.min(editDistanceTD(a.substring(0, m-1), b), editDistanceTD(a, b.substring(0,  n-1))), editDistanceTD(a.substring(0, m-1), b.substring(0, n-1)));
+		return dp[m][n];
+	}
+
+}

DP/Knapsack.java

@@ -0,0 +1,51 @@
+import cern.colt.Arrays;
+import java.util.*;
+
+public class Knapsack {
+	
+	/*0-1 Knapsack Probelm
+
+	 Problem (informal): Given set of items with cost and weight, find subset of items such that net weight does not exceed W and set has maximum total cost
+	 
+	 Algorithm: Recursive -- try each possible item and calculate max of remaining
+	 
+	 Complexity:
+	 	* Time - O(nW) where W is the maximum weight possible
+	 	* Space - O(n) only one array for number of items.
+	 	
+	 Functions Defined:
+	 	* knapsackTD() - Recursively consideres one less item and maximum of remaining subset
+	 	* fractionalknapsack() - Pretty trivial -- greedy algorithm suffices. Solved in O(nlogn) but also possible in O(n) via weighted medians 
+	 	
+	 */
+	static int[][] items;
+	static int maxweight;
+	public static void main(String[] args){
+		int[][] itemsx = {{60, 10}, {100, 20}, {120, 30}};
+		//{cost, weight}
+		items = itemsx;
+		maxweight = 50;
+		boolean[] insert = new boolean[items.length];
+		//System.out.println(knapsackBU(items, maxweight));
+		System.out.println(knapsackTD(maxweight, insert));
+	}
+	
+	public static int knapsackTD(int maxweight, boolean[] insert){
+		int max = 0;
+		for(int i=0;i<items.length;i++){
+			if(!insert[i] && maxweight >= items[i][1]){
+				boolean[] insertclone = insert.clone();
+				insertclone[i] = true;
+				max = Math.max(items[i][0] + knapsackTD(maxweight - items[i][1], insertclone), max);
+			}
+		}
+		return max;
+	}
+	
+	public static void fractionalknapsack(){
+		//greedy
+		//I don't think it's necessary to implement this since it's pretty straightforward.
+		//Just find the item with largest cost and take as much of it as possible. If you take all of it, continue to next largest.
+	}
+	
+}

DP/LCS.java

@@ -0,0 +1,91 @@
+import java.util.*;
+import cern.colt.Arrays;
+
+public class LCS {
+	
+	/*Longest Common Subsequence (LCS)
+
+	 Problem (informal): Given two arrays, find largest subsequence of both arrays
+	 
+	 Algorithm: If elements at position i are equal, find LCS of subarrays [0, i-1], else find max of both possible cases 
+	 
+	 Complexity:
+	 	* Time - O(n^2) 
+	 	* Space - O(n^2) with memoization and O(1) without
+	 	
+	 Functions Defined:
+	 	* iterativeLCS() - Bottom up implementation, finds longest length and reconstructs sequence
+	 	* recursiveLCS() - Top down implementation, only outputs length of sequence
+	 	
+	 */
+	
+	static int[] arr1;
+	static int[] arr2;
+	static int[][] dp;
+	
+	static Stack<Integer> solution = new Stack<Integer>();
+	public static void main(String[] args) {
+		int[] arrA = {1, 2, 3, 4, 7, 5, 9};
+		int[] arrB = {1, 4, 3, 7, 9, 5};
+		
+		arr1 = arrA;
+		arr2 = arrB;
+		
+		System.out.println(Arrays.toString(iterativeLCS(arrA, arrB)));
+
+	}
+	
+	public static int[] iterativeLCS(int[] a, int[] b){
+		int[][] dp = new int[a.length+1][b.length+1];
+		for(int i = 1; i <= a.length; i++){
+			for(int j = 1; j <= b.length; j++){
+				if(a[i-1] == b[j-1]){
+					dp[i][j] =  1 + dp[i-1][j-1];
+				}
+				else{
+					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);	
+				}
+			}
+		}
+		
+		int[] lcs = new int[dp[a.length][b.length]];
+		int index = lcs.length-1;
+		int i=a.length; int j = b.length;
+		
+		while(i > 0 && j > 0){
+			if(a[i-1] == b[j-1]){
+				lcs[index] = a[i-1];
+				i--; j--; index--;
+			}
+			else if(dp[i-1][j] >= dp[i][j-1])
+				i--;	
+			else
+				j--;		
+		}
+		
+		return lcs;
+	}
+	
+	public static int recursiveLCS(int a, int b){
+		if(a < 0 || b < 0) return 0;
+		
+		if(arr1[a] == arr2[b]){
+			solution.push(arr1[a]);
+			dp[a][b] = 1 + recursiveLCS(a-1, b-1);
+			return dp[a][b];
+		}
+		int opt1 = recursiveLCS(a, b-1);
+		int opt2 = recursiveLCS(a-1, b);
+		
+		if(opt1 >= opt2){
+			dp[a][b] = opt1;
+		}
+		
+		else{
+			dp[a][b] = opt2;
+		}
+		
+		return dp[a][b];
+	}
+
+}

DP/maxDonations.java

@@ -0,0 +1,53 @@
+
+public class maxDonations {
+	
+	/*Maximum Donations (Topcoder)
+
+	 Problem (informal): Given set S of values, find subset Q of values with maximum sum such that no two values in Q are adjacent in S
+	 
+	 Algorithm: Recursive -- two possibilities at each branch, test both
+	 
+	 Complexity:
+	 	* Time - O(n^2) - each branches off into two possibilities
+	 	* Space - O(n^2) due to DP array 
+	 	
+	 Functions Defined:
+	 	* maxDonations() - main algorithm
+	 */
+	
+	static int[] arr;
+	static int len;
+	static int[][] dp;
+
+	public static void main(String[] args) {
+		int[] arr2 = {10, 3, 2, 5, 7, 8};
+		//{10, 4, 5}
+		arr = arr2;
+		len = arr.length;
+		dp = new int[len][len];
+		
+		
+		
+
+	}
+	
+	public static int maxDonations(int start, int end){
+		if(end - start ==2) return Math.max(Math.max(arr[start], arr[end]), arr[start+1]);
+		if(end - start <=1) return Math.max(arr[start], arr[end]);
+
+		int start1 = (start+1)%len;
+		
+		int val = arr[start];
+		int start2 = start, end2 = end;
+		if(start == 0){
+			start2+=2;
+			
+		}
+		else{
+			start2+=2;
+		}
+		dp[start][end] = Math.max(maxDonations(start1, end), val + maxDonations(start2, end2));
+		return dp[start][end];
+	}
+
+}