BloomFilter and DP code added

Author: gkcs

Competitive Programming.iml

@@ -14,5 +14,31 @@
     <orderEntry type="library" name="chelper" level="project" />
     <orderEntry type="library" name="Maven: junit:junit:4.12" level="project" />
     <orderEntry type="library" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
+    <orderEntry type="library" name="Maven: com.google.apis:google-api-services-youtube:v3-rev194-1.23.0" level="project" />
+    <orderEntry type="library" name="Maven: com.google.api-client:google-api-client:1.23.0" level="project" />
+    <orderEntry type="library" name="Maven: com.google.oauth-client:google-oauth-client:1.23.0" level="project" />
+    <orderEntry type="library" name="Maven: com.google.code.findbugs:jsr305:1.3.9" level="project" />
+    <orderEntry type="library" name="Maven: com.google.http-client:google-http-client-jackson2:1.23.0" level="project" />
+    <orderEntry type="library" name="Maven: com.fasterxml.jackson.core:jackson-core:2.1.3" level="project" />
+    <orderEntry type="library" name="Maven: com.google.guava:guava-jdk5:17.0" level="project" />
+    <orderEntry type="library" name="Maven: com.google.api-client:google-api-client-extensions:1.6.0-beta" level="project" />
+    <orderEntry type="library" name="Maven: com.google.oauth-client:google-oauth-client-extensions:1.6.0-beta" level="project" />
+    <orderEntry type="library" name="Maven: com.googlecode.jsontoken:jsontoken:1.0" level="project" />
+    <orderEntry type="library" name="Maven: com.google.code.gson:gson:1.4" level="project" />
+    <orderEntry type="library" name="Maven: commons-codec:commons-codec:1.4" level="project" />
+    <orderEntry type="library" name="Maven: com.google.collections:google-collections:1.0" level="project" />
+    <orderEntry type="library" name="Maven: joda-time:joda-time:1.6" level="project" />
+    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpcore:4.0.1" level="project" />
+    <orderEntry type="library" name="Maven: javax.servlet:servlet-api:2.5" level="project" />
+    <orderEntry type="library" name="Maven: javax.jdo:jdo2-api:2.3-eb" level="project" />
+    <orderEntry type="library" name="Maven: javax.transaction:transaction-api:1.1" level="project" />
+    <orderEntry type="library" name="Maven: com.google.http-client:google-http-client-extensions:1.6.0-beta" level="project" />
+    <orderEntry type="library" name="Maven: com.google.http-client:google-http-client:1.6.0-beta" level="project" />
+    <orderEntry type="library" name="Maven: com.google.guava:guava:r09" level="project" />
+    <orderEntry type="library" name="Maven: org.apache.httpcomponents:httpclient:4.0.3" level="project" />
+    <orderEntry type="library" name="Maven: commons-logging:commons-logging:1.1.1" level="project" />
+    <orderEntry type="library" name="Maven: org.codehaus.jackson:jackson-core-asl:1.9.1" level="project" />
+    <orderEntry type="library" name="Maven: xpp3:xpp3:1.1.4c" level="project" />
+    <orderEntry type="library" name="Maven: com.google.protobuf:protobuf-java:2.2.0" level="project" />
   </component>
 </module>

pom.xml

@@ -25,7 +25,15 @@
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.apis</groupId>
+            <artifactId>google-api-services-youtube</artifactId>
+            <version>v3-rev194-1.23.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.api-client</groupId>
+            <artifactId>google-api-client-extensions</artifactId>
+            <version>1.6.0-beta</version>
+        </dependency>
     </dependencies>
-
-
 </project>

src/main/java/main/java/course/BloomFilter.java

@@ -0,0 +1,51 @@
+package main.java.course;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+class BloomFilterMain {
+    public static void main(String[] args) {
+        BloomFilter bloomFilter = new BloomFilter(1000);
+        bloomFilter.mark(141432);
+        bloomFilter.mark(2354364);
+        System.out.println(bloomFilter.isMarked(141432));
+        System.out.println(bloomFilter.isMarked(723));
+        //This should be false, but bloom filters provide no guarantee on definite existence
+        System.out.println(bloomFilter.isMarked(1432));
+    }
+}
+
+public class BloomFilter<T> {
+    private final long[] points;
+    private final int size;
+    private final List<Function<T, Integer>> hashFunctions;
+
+    BloomFilter(final int size) {
+        this.size = size;
+        points = new long[(size + 63) >> 6];
+        hashFunctions = Arrays.asList(multiplyWith(29), multiplyWith(19), multiplyWith(17));
+    }
+
+    private Function<T, Integer> multiplyWith(final int i) {
+        return t -> (t.hashCode() * i) % size;
+    }
+
+    public void mark(int hash) {
+        hash %= size;
+        points[hash >> 6] |= (1 << (hash & 63));
+    }
+
+    public boolean isMarked(int hash) {
+        hash %= size;
+        return (points[hash >> 6] & (1 << (hash & 63))) != 0;
+    }
+
+    public void add(final T value) {
+        hashFunctions.stream().map(function -> function.apply(value)).forEach(this::mark);
+    }
+
+    public boolean exists(final T value) {
+        return hashFunctions.stream().map(function -> function.apply(value)).allMatch(this::isMarked);
+    }
+}

src/main/java/main/java/course/BloomFilterMain.java

@@ -0,0 +1,18 @@
+package main.java.dp;
+
+public class CoinChange {
+    private static long countWays(int coins[], int amount) {
+        final long[] table = new long[amount + 1];
+        table[0] = 1;
+        for (final int value : coins) {
+            for (int j = value; j <= amount; j++) {
+                table[j] += table[j - value];
+            }
+        }
+        return table[amount];
+    }
+
+    public static void main(String args[]) {
+        System.out.println(countWays(new int[]{1, 2, 3}, 4));
+    }
+}

src/main/java/main/java/dp/CoinChange.java

@@ -0,0 +1,23 @@
+package main.java.dp;
+
+public class LongestCommonSubsequence {
+    int lcs(char[] A, char[] B, int m, int n) {
+        final int dp[][] = new int[m + 1][n + 1];
+        for (int x = 1; x <= m; x++) {
+            for (int y = 1; y <= n; y++) {
+                if (A[x - 1] == B[y - 1]) {
+                    dp[x][y] = dp[x - 1][y - 1] + 1;
+                } else {
+                    dp[x][y] = Math.max(dp[x - 1][y], dp[x][y - 1]);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+
+    public static void main(String[] args) {
+        final char[] A = "AGGTAB".toCharArray(), B = "GXTXAYB".toCharArray();
+        System.out.println("LCS: " + new LongestCommonSubsequence().lcs(A, B, A.length, B.length));
+    }
+
+}

src/main/java/main/java/dp/LongestCommonSubsequence.java

@@ -0,0 +1,24 @@
+package main.java.dp;
+
+public class LongestCommonSubstring {
+
+    private static int findLCS(char A[], char B[], int m, int n) {
+        int dp[][] = new int[m + 1][n + 1];
+        int result = 0;
+        for (int x = 1; x <= m; x++) {
+            for (int y = 1; y <= n; y++) {
+                if (A[x - 1] == B[y - 1]) {
+                    dp[x][y] = dp[x - 1][y - 1] + 1;
+                    result = Integer.max(result, dp[x][y]);
+                }
+            }
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        final String a = "www.gkcs.tech", b = "www.youtube.gkcs";
+        System.out.println("Length of Longest Common Substring is "
+                + findLCS(a.toCharArray(), b.toCharArray(), a.length(), b.length()));
+    }
+}

src/main/java/main/java/dp/LongestCommonSubstring.java

@@ -0,0 +1,29 @@
+package main.java.dp;
+
+public class LongestIncreasingSubsequence {
+    private static int lis(int arr[], int n) {
+        int dp[] = new int[n];
+        int x, y, max = 0;
+        for (x = 0; x < n; x++) {
+            dp[x] = 1;
+        }
+        for (x = 1; x < n; x++) {
+            for (y = 0; y < x; y++) {
+                if (arr[x] > arr[y] && dp[x] < dp[y] + 1) {
+                    dp[x] = dp[y] + 1;
+                }
+            }
+        }
+        for (x = 0; x < n; x++) {
+            if (max < dp[x]) {
+                max = dp[x];
+            }
+        }
+        return max;
+    }
+
+    public static void main(String args[]) {
+        int arr[] = {10, 22, 9, 33, 21, 50, 41, 60};
+        System.out.println("LIS: " + lis(arr, arr.length));
+    }
+}

src/main/java/main/java/dp/LongestIncreasingSubsequence.java

@@ -0,0 +1,26 @@
+package main.java.dp;
+
+import java.util.Arrays;
+
+public class LongestRepeatingSubsequence {
+    static int findLongestRepeatingSubSeq(String str) {
+        int n = str.length();
+        int[][] dp = new int[n + 1][n + 1];
+        for (int x = 1; x <= n; x++) {
+            for (int y = 1; y <= n; y++) {
+                if (str.charAt(x - 1) == str.charAt(y - 1) && x != y)
+                    dp[x][y] = 1 + dp[x - 1][y - 1];
+                else
+                    dp[x][y] = Math.max(dp[x][y - 1], dp[x - 1][y]);
+            }
+        }
+        for (final int[] row : dp) {
+            System.out.println(Arrays.toString(row));
+        }
+        return dp[n][n];
+    }
+
+    public static void main(String[] args) {
+        System.out.println(findLongestRepeatingSubSeq("aabpqrarqa"));
+    }
+}

src/main/java/main/java/dp/LongestRepeatingSubsequence.java

@@ -0,0 +1,37 @@
+package main.java.dp;
+
+import java.util.Arrays;
+
+public class MatrixChain {
+    static int MatrixChainOrder(int p[], int n) {
+        final int dp[][] = new int[n][n];
+        int start, end, partition, blockLength, q;
+        for (start = 1; start < n; start++) {
+            dp[start][start] = 0;
+        }
+        for (blockLength = 2; blockLength < n; blockLength++) {
+            for (start = 1; start < n - blockLength + 1; start++) {
+                end = start + blockLength - 1;
+                dp[start][end] = Integer.MAX_VALUE;
+                for (partition = start; partition <= end - 1; partition++) {
+                    q = dp[start][partition]
+                            + dp[partition + 1][end]
+                            + p[start - 1] * p[partition] * p[end];
+                    if (q < dp[start][end]) {
+                        dp[start][end] = q;
+                    }
+                }
+            }
+        }
+        System.out.println(Arrays.deepToString(dp));
+        return dp[1][n - 1];
+    }
+
+    public static void main(String args[]) {
+        int arr[] = new int[]{7, 2, 1, 4, 5};
+        int size = arr.length;
+
+        System.out.println("Minimum number of multiplications is " +
+                MatrixChainOrder(arr, size));
+    }
+}

src/main/java/main/java/dp/MatrixChain.java

@@ -0,0 +1,37 @@
+package main.java.dp;
+
+public class OptimalBST {
+    static int optimalSearchTree(final int freq[], final int n) {
+        final int cost[][] = new int[n + 1][n + 1];
+        final int prefixSums[] = new int[n];
+        prefixSums[0] = freq[0];
+        for (int i = 1; i < n; i++) {
+            prefixSums[i] = prefixSums[i - 1] + freq[i];
+        }
+        for (int i = 0; i < n; i++) {
+            cost[i][i] = freq[i];
+        }
+        for (int lengthOfBlock = 2; lengthOfBlock <= n; lengthOfBlock++) {
+            for (int start = 0; start <= n - lengthOfBlock + 1; start++) {
+                final int end = start + lengthOfBlock - 1;
+                cost[start][end] = Integer.MAX_VALUE;
+                for (int root = start; root <= end; root++) {
+                    final int currentCost = ((root > start) ? cost[start][root - 1] : 0)
+                            + ((root < end) ? cost[root + 1][end] : 0) +
+                            prefixSums[Math.min(end, prefixSums.length - 1)] - (start > 0 ? prefixSums[start - 1] : 0);
+                    if (currentCost < cost[start][end]) {
+                        cost[start][end] = currentCost;
+                    }
+                }
+            }
+        }
+        return cost[0][n - 1];
+    }
+
+    public static void main(String[] args) {
+        int keys[] = {10, 12, 20};
+        int freq[] = {34, 8, 50};
+        int n = keys.length;
+        System.out.println("Optimal BST cost " + optimalSearchTree(freq, n));
+    }
+}

src/main/java/main/java/dp/OptimalBST.java

@@ -0,0 +1,29 @@
+package main.java.dp;
+
+public class SubsetSum {
+    private static boolean isSubsetSum(final int set[], int n, int sum) {
+        final boolean subset[][] = new boolean[sum + 1][n + 1];
+        for (int i = 0; i <= n; i++) {
+            subset[0][i] = true;
+        }
+        for (int i = 1; i <= sum; i++) {
+            for (int j = 1; j <= n; j++) {
+                subset[i][j] = subset[i][j - 1];
+                if (i >= set[j - 1]) {
+                    subset[i][j] = subset[i][j] ||
+                            subset[i - set[j - 1]][j - 1];
+                }
+            }
+        }
+        return subset[sum][n];
+    }
+
+    public static void main(String args[]) {
+        int set[] = {3, 34, 4, 12, 5, 2};
+        if (isSubsetSum(set, set.length, 9)) {
+            System.out.println("Found a subset with given sum");
+        } else {
+            System.out.println("No subset with given sum");
+        }
+    }
+}