Add files via upload

Author: vamsee91

CoinChange.java

@@ -0,0 +1,54 @@
+package dp;
+
+import java.util.Arrays;
+
+/**
+ * Given a value N, if we want to make change for N cents, and we have infinite supply of each of
+ * S = { S1, S2, .. , Sm} valued coins, how many ways can we make the change? The order of coins
+ * doesn’t matter.
+ * For example, for N = 4 and S = {1,2,3}, there are four solutions: {1,1,1,1},{1,1,2},{2,2},{1,3}.
+ * So output should be 4. For N = 10 and S = {2, 5, 3, 6}, there are five solutions: {2,2,2,2,2},
+ * {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}. So the output should be 5.
+ */
+public class CoinChange {
+
+    public static void main(String[] args) {
+        rdp(5, new int[]{1, 2, 3});
+        rdp(10, new int[]{2, 5, 3, 6});
+        rdp(50, new int[]{1, 2});
+        dp(5, new int[]{1, 2, 3});
+        dp(10, new int[]{2, 5, 3, 6});
+        dp(50, new int[]{1, 2});
+    }
+
+    static void dp(int N, int[] s) {
+        int[][] dp = new int[N + 1][s.length + 1];
+        for (int j = 0; j <= s.length; dp[0][j] = 1, j++);
+
+        for (int i = 1; i <= N; i++) {
+            for (int j = 1; j <= s.length; j++) {
+                dp[i][j] = dp[i][j - 1];
+                if (i - s[j - 1] >= 0) {
+                    dp[i][j] += dp[i - s[j - 1]][j];
+                }
+            }
+        }
+        System.out.println(dp[N][s.length] + " no of ways in i");
+    }
+
+    static void rdp(int N, int[] s) {
+        Arrays.sort(s);
+        System.out.println(rcc(N, s, 0) + " no of ways in r");
+    }
+
+    static int rcc(int N, int[] s, int index) {
+        if (N == 0) return 1;
+        int num = 0;
+        for (int j = index; j < s.length; j++) {
+            if (s[j] <= N) {
+                num += rcc(N - s[j], s, j);
+            }
+        }
+        return num;
+    }
+}

EditDistance.java

@@ -0,0 +1,49 @@
+package dp;
+
+
+public class EditDistance {
+
+    private static final int MATCH = 0;
+    private static final int INSERT = 1;
+    private static final int DELETE = 2;
+    private static final int TRANSPOSE = 3;
+
+    public static void main(String[] args) {
+        char[] x = "thou shall not".toCharArray();
+        char[] y = "you should not".toCharArray();
+        //char[] x = "saketh".toCharArray();
+        //char[] y = "sakeht".toCharArray();
+        long now = System.currentTimeMillis();
+        System.out.println(editDistance(x, y) + " " + (System.currentTimeMillis() - now));
+    }
+
+    private static int editDistance(char[] x, char[] y) {
+        int[][] dist = new int[x.length + 1][y.length + 1];
+        int[] costs = new int[TRANSPOSE + 1];
+
+        // row init
+        for (int i = 0; i <= x.length; i++) {
+            dist[i][0] = i;
+        }
+        // column init
+        for (int j = 0; j <= y.length; j++) {
+            dist[0][j] = j;
+        }
+
+        for (int i = 1; i <= x.length; i++) {
+            for (int j = 1; j <= y.length; j++) {
+                costs[MATCH] = dist[i - 1][j - 1] + ((x[i - 1] == y[j - 1]) ? 0 : 1);
+                costs[INSERT] = dist[i][j - 1] + 1;
+                costs[DELETE] = dist[i - 1][j] + 1;
+                costs[TRANSPOSE] = (i > 1 && j > 1 && x[i - 1] == y[j - 2] && x[i - 2] == y[j - 1])
+                        ? dist[i - 2][j - 2] + 1 : Integer.MAX_VALUE;
+                dist[i][j] = costs[MATCH];
+                for (int e = INSERT; e <= TRANSPOSE; e++) {
+                    dist[i][j] = Math.min(dist[i][j], costs[e]);
+                }
+            }
+        }
+
+        return dist[x.length][y.length];
+    }
+}

EggDropping.java

@@ -0,0 +1,51 @@
+package dp;
+
+/**
+ * Given an N story building and a supply of k eggs, find the strategy which minimizes (in the worst
+ * case) the number of experimental drops required to determine the break floor.
+ */
+public class EggDropping {
+
+    public static void main(String[] args) {
+        System.out.println(solve(8, 4));
+        System.out.println(solve(256, 15));
+        System.out.println(solve(1024, 15));
+        System.out.println(solve(100, 2));
+        System.out.println(solve(100, 3));
+    }
+
+    private static int solve(int n, int k) {
+        int[][] cost = new int[n + 1][k + 1];
+
+        for (int i = 1; i <= n; i++) cost[i][1] = i;
+        for (int j = 1; j <= k; j++) cost[1][j] = 1;
+
+        for (int i = 2; i <= n; i++) {
+            for (int j = 2; j <= k; j++) {
+                cost[i][j] = Integer.MAX_VALUE;
+                for (int x = 1; x <= i; x++) {
+                    int c = 1 + Math.max((cost[x - 1][j - 1]), cost[i - x][j]);
+                    if (c < cost[i][j]) {
+                        cost[i][j] = c;
+                    }
+                }
+            }
+        }
+        return cost[n][k];
+    }
+
+
+    static int  rsolve(int e, int f) {
+        return rdp(e, f, f);
+    }
+
+    // FIXME stackoverflow error because of recursive calls
+    static int rdp(int e, int f, int k) {
+        if (f <= 1) return 1;
+        if (e == 1) return f;
+        if (e <= 0) return Integer.MAX_VALUE;
+
+        return 1 + Math.min(rdp(e - 1, f - 1, k), rdp (e, k - f, k));
+
+    }
+}

FindInterval.java

@@ -0,0 +1,45 @@
+package com.leetcode;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class FindInterval {
+
+	public static void main(String[] args) {
+		Interval []intervals = new Interval[3];
+		intervals[0] = new Interval(3,4);
+		intervals[1] = new Interval(2,3);
+		intervals[2] = new Interval(1,2);
+		int []arr = findRightInterval(intervals);
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+	}
+
+	private static int[] findRightInterval(Interval[] intervals) {
+		int []res = new int[intervals.length];
+		int len = intervals.length;
+		if (len == 1) {
+			int []a = new int[1];
+			a[0] = -1;
+			return a;
+		}
+		HashMap<Integer, Integer> map = new HashMap<Integer,Integer>();
+		for (int i = 0; i < len; i++) {
+			map.put(intervals[i].start, i);
+		}
+		Arrays.sort(intervals, (a, b)->(a.start - b.start));
+		for (int i = 0; i < len; i++) {
+			int tar = intervals[i].end;
+			int left = i+1;
+			int right = len ;
+			while (left < right) {
+				int mid = (left + right)/2;
+				if (intervals[mid].start < tar) { left = mid + 1; }
+				else { right = mid; }
+			}
+			res[map.get(intervals[i].start)] = (right == len) ? -1 : map.get(intervals[right].start);
+		}
+		return res;
+	}
+}

Interval.java

@@ -0,0 +1,16 @@
+package com.leetcode;
+
+public class Interval {
+	public int start;
+	public int end;
+	
+	public Interval() {
+		this.start = 0;
+		this.end = 0;
+	}
+	
+	public Interval(int start, int end) {
+		this.start = start;
+		this.end = end;
+	}
+}

Knapsack.java

@@ -0,0 +1,49 @@
+package dp;
+
+/**
+ * Given weights and values of n items, put these items in a knapsack of capacity W to get the
+ * maximum total value in the knapsack. In other words, given two integer arrays val[0..n-1] and
+ * wt[0..n-1] which represent values and weights associated with n items respectively. Also given
+ * an integer W which represents knapsack capacity, find out the maximum value subset of val[]
+ * such that sum of the weights of this subset is smaller than or equal to W. You cannot break an
+ * item, either pick the complete item, or don’t pick it (0-1 property)
+ */
+public class Knapsack {
+
+    public static void main(String[] args) {
+        rknapsack(5, new int[]{60, 100, 120}, new int[]{1, 2, 3});
+        rknapsack(10, new int[]{60, 100, 120, 130, 140}, new int[]{1, 2, 3, 4, 5});
+        rknapsack(10, new int[]{0, 60, 100, 120, 130, 140}, new int[]{0, 1, 2, 3, 4, 5});
+        dp(5, new int[]{60, 100, 120}, new int[]{1, 2, 3});
+        dp(10, new int[]{60, 100, 120, 130, 140}, new int[]{1, 2, 3, 4, 5});
+        dp(10, new int[]{0, 60, 100, 120, 130, 140}, new int[]{0, 1, 2, 3, 4, 5});
+    }
+
+    static void dp(int W, int[] values, int[] weights) {
+        int dp[][] = new int[values.length + 1][W + 1];
+
+        for (int i = 1; i <= values.length; i++) {
+            for (int j = 1; j <= W; j++) {
+                dp[i][j] = dp[i - 1][j];
+                if (weights[i - 1] <= j) {
+                    dp[i][j] = Math.max(dp[i][j], values[i - 1] + dp[i - 1][j - weights[i - 1]]);
+                }
+            }
+        }
+
+        System.out.println("DP knapsack max : " + dp[values.length][W]);
+    }
+
+    static void rknapsack(int W, int[] values, int[] weights) {
+        System.out.println("Recursive knapsack max : " + rdp(W, values, weights, values.length -1));
+    }
+
+    static int rdp(int W, int[] values, int[] weights, int i) {
+        if (i < 0) return 0;
+        int value = rdp(W, values, weights, i - 1);
+        if (weights[i] <= W) {
+            value = Math.max(value, values[i] + rdp(W - weights[i], values, weights, i - 1));
+        }
+        return value;
+    }
+}

LBS.java

@@ -0,0 +1,21 @@
+package dp;
+
+/**
+ * Given an array arr[0 … n-1] containing n positive integers, a subsequence of arr[] is called
+ * Bitonic if it is first increasing, then decreasing. Write a function that takes an array as
+ * argument and returns the length of the longest bitonic subsequence.
+
+ * A sequence, sorted in increasing order is considered Bitonic with the decreasing part as empty.
+ * Similarly, decreasing order sequence is considered Bitonic with the increasing part as empty
+ */
+public class LBS {
+
+    public static void main(String[] args) {
+        /*rlbs(new int[]{1, 11, 2, 10, 4, 5, 2, 1});
+        rlbs(new int[]{12, 11, 40, 5, 3, 1});
+        rlbs(new int[]{80, 60, 30, 40, 20, 10});*/
+    }
+
+    /* Solution - can be solved as combination of LIS and LDS */
+
+}

LCA.java

@@ -0,0 +1,35 @@
+package dp;
+
+/**
+ * Longest Commong Array(Substring)
+ */
+public class LCA {
+
+    public static void main(String[] args) {
+        rsolve("COMBINATION".toCharArray(), "PERMUTATION".toCharArray());
+        rsolve("COMBINATION".toCharArray(), "COMBUSTION".toCharArray());
+        rsolve("MICHAELANGELO".toCharArray(), "HEIROGLYPHOLOGY".toCharArray());
+        rsolve("ABCDEFG".toCharArray(), "HKLMNABCIJ".toCharArray());
+        rsolve("forgeeksskeegfor".toCharArray(), "rofgeeksskeegrof".toCharArray());
+    }
+
+    static int max;
+    static void rsolve(char[] m, char[] n) {
+        max = 0;
+        rdp(m, n, m.length - 1, n.length - 1);
+        System.out.println("recursive lcs " + max);
+    }
+
+    static int rdp(char[] m, char[] n, int i, int j) {
+        if (i < 0 || j < 0) return 0;
+        if (m[i] == n[j]) {
+            int tmp = 1 + rdp(m, n, i - 1, j - 1);
+            max = Math.max(tmp, max);
+            return tmp;
+        } else {
+            int tmp = Math.max(rdp(m, n, i - 1, j), rdp(m, n, i, j - 1));
+            max = Math.max(tmp, max);
+            return 0;
+        }
+    }
+}

LCS.java

@@ -0,0 +1,32 @@
+package dp;
+
+/**
+ * Longest Common Subsequence
+ */
+public class LCS {
+
+    public static void main(String[] args) {
+        rsolve("COMBINATION".toCharArray(), "PERMUTATION".toCharArray());
+        rsolve("COMBINATION".toCharArray(), "COMBUSTION".toCharArray());
+        rsolve("MICHAELANGELO".toCharArray(), "HEIROGLYPHOLOGY".toCharArray());
+        rsolve("ABCDEFG".toCharArray(), "HKLMNABCIJ".toCharArray());
+        rsolve("forgeeksskeegfor".toCharArray(), "rofgeeksskeegrof".toCharArray());
+    }
+
+    static void rsolve(char[] m, char[] n) {
+        System.out.println("recursive lcs " + rdp(m, n, 0, 0));
+    }
+
+    static int rdp(char[] m, char[] n, int i, int j) {
+        if (i >= m.length || j >= n.length) return 0;
+        int max = 0;
+        if (m[i] == n[j]) {
+            max = 1 + rdp(m, n, i + 1, j + 1);
+        } else {
+            max = Math.max(max, rdp(m, n, i, j + 1));
+            max = Math.max(max, rdp(m, n, i + 1, j));
+        }
+        return max;
+    }
+
+}