added code for minimum perfect squares

Author: Ayan Sen

src/main/java/datastructure/lists/problems/LargestAndSmallestNumber.java renamed to src/main/java/algorithms/divideandconquer/LargestAndSmallestNumber.java

@@ -1,4 +1,4 @@
-package datastructure.lists.problems;
+package algorithms.divideandconquer;
 
 /**
  * Created by aysen on 10/16/16.

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

@@ -23,10 +23,11 @@ public int recursiveLCS(char[] firstString, char[] secondString, int positionOfF
             return 0;
         }
         if (firstString[positionOfFirstString] == secondString[positionOfSecondString]) {
-            return recursiveLCS(firstString, secondString, positionOfFirstString - 1, positionOfSecondString - 1, memo) + 1;
+            memo[positionOfFirstString][positionOfSecondString] = recursiveLCS(firstString, secondString, positionOfFirstString - 1, positionOfSecondString - 1, memo) + 1;
         } else {
-            return Math.max(recursiveLCS(firstString, secondString, positionOfFirstString, positionOfSecondString - 1, memo), recursiveLCS(firstString, secondString, positionOfFirstString - 1, positionOfSecondString, memo));
+            memo[positionOfFirstString][positionOfSecondString] = Math.max(recursiveLCS(firstString, secondString, positionOfFirstString, positionOfSecondString - 1, memo), recursiveLCS(firstString, secondString, positionOfFirstString - 1, positionOfSecondString, memo));
         }
+        return memo[positionOfFirstString][positionOfSecondString];
 
     }
 
@@ -35,31 +36,10 @@ public int longestCommonSubsequence(String firstString, String secondString) {
 
         Integer[][] memo = new Integer[firstString.length()][secondString.length()];
 
-        return recursiveLCS(firstString.toCharArray(), secondString.toCharArray(), firstString.length() - 1, secondString.length() - 1,memo);
+        return recursiveLCS(firstString.toCharArray(), secondString.toCharArray(), firstString.length() - 1, secondString.length() - 1, memo);
        /*
         */
     }
 
-    private int lcsIterative(char[] firstString, char[] secondString) {
-
-        //min(f(x-1,y),f(x,y-1)) + 1 if(firstString[i] == secondString[j])
-
-        Integer[][] memo = new Integer[firstString.length][secondString.length];
-        for (int i = 0; i < firstString.length; i++) {
-
-            for (int j = 0; j < secondString.length; j++) {
-                if (i == 0 || j == 0) {
-                    memo[i][j] = 0;
-                } else if (firstString[i] == secondString[j]) {
-                    memo[i][j] = memo[i - 1][j - 1] + 1;
-                } else {
-                    memo[i][j] = Math.max(memo[i][j - 1], memo[i - 1][j]);
-                }
-            }
-        }
-        return memo[firstString.length - 1][secondString.length - 1];
-
-    }
-
 
 }

src/main/java/algorithms/dp/LowestTravelCost.java

@@ -2,12 +2,11 @@
 
 import java.util.*;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 
 
 public class LowestTravelCost {
 
-    private int findLowestCostRecursive(int[] daysOfTravel, int currentValidity, int currentIndex, Map<Integer, Integer> costValidityMap, Map<Integer, Integer> memo) {
+    private int findLowestCostRecursive(int[] daysOfTravel, int currentValidity, int currentIndex, Map<Integer, Integer> costValidityMap, Integer[] memo) {
 
         if (currentValidity >= 30 || currentIndex == daysOfTravel.length) {
             return 0;
@@ -20,8 +19,8 @@ private int findLowestCostRecursive(int[] daysOfTravel, int currentValidity, int
             minimumCost = Collections.min(costValidityMap.entrySet().stream().map(tuple -> findLowestCostRecursive(daysOfTravel, currentValidity, currentIndex + 1, costValidityMap, memo)).collect(Collectors.toList()));
 
         } else {
-            if (memo.containsKey(dayOfMonth)) {
-                return memo.get(dayOfMonth);
+            if (memo[dayOfMonth] != null) {
+                return memo[dayOfMonth];
             }
             List<Integer> minimumCosts = new ArrayList<>();
             costValidityMap.entrySet().forEach(tuple -> {
@@ -30,15 +29,15 @@ private int findLowestCostRecursive(int[] daysOfTravel, int currentValidity, int
             minimumCost = Collections.min(minimumCosts);
         }
 
-        memo.put(dayOfMonth, minimumCost);
+        memo[dayOfMonth] = minimumCost;
         return minimumCost;
     }
 
 
     public int findLowestTravelCost(int[] daysOfTravel) {
         Map<Integer, Integer> costValidityMap = new HashMap<>();
         costValidityMap.entrySet();
-        Map<Integer, Integer> memo = new HashMap<>();
+        Integer[] memo = new Integer[31];
         costValidityMap.put(2, 1);
         costValidityMap.put(7, 7);
         costValidityMap.put(25, 30);

src/main/java/algorithms/dp/MinimumPerfectSquares.java

@@ -0,0 +1,33 @@
+package algorithms.dp;
+
+public class MinimumPerfectSquares {
+    /**
+     * Given a number, find the minimum number of perfect squares adding upto that number
+     *
+     * @param n
+     * @return
+     */
+    public int findMinimumPerfectSquaresAddingToSum(final int n) {
+        Integer[] memo = new Integer[n + 1];
+
+        return findMinimumPerfectSquaresAddingToSumRecursively(n, memo);
+    }
+
+    private int findMinimumPerfectSquaresAddingToSumRecursively(final int n, Integer[] memo) {
+        if (n == 0) {
+            return 0;
+        } else if (memo[n] != null) {
+            return memo[n];
+        } else {
+            int absoluteMin = n;
+            for (int i = 1; (i * i) <= n; i++) {
+                int currentMin = 1 + findMinimumPerfectSquaresAddingToSumRecursively(n - (i * i), memo);
+                if (currentMin < absoluteMin) {
+                    absoluteMin = currentMin;
+                }
+            }
+            memo[n] = absoluteMin;
+            return absoluteMin;
+        }
+    }
+}

src/main/java/algorithms/dp/ShortestPath.java

@@ -3,9 +3,6 @@
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Created by aysen on 10/25/16.
- */
 public class BinaryMaxHeap<T extends Comparable> implements Heap<T> {
 
     List<T> heap;

src/main/java/datastructure/heap/BinaryMaxHeap.java

@@ -3,9 +3,6 @@
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Created by aysen on 10/25/16.
- */
 public class BinaryMinHeap<T extends Comparable> implements Heap<T> {
 
     List<T> heap;

src/main/java/datastructure/heap/BinaryMinHeap.java

@@ -7,9 +7,6 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-/**
- * Created by aysen on 10/26/16.
- */
 public class HeapProblems {
 
     public static List<Integer> sortListUsingHeap(List<Integer> numbers) {

src/main/java/datastructure/heap/problems/HeapProblems.java

@@ -57,5 +57,30 @@ public static Integer maximumProductOfSubarray(Integer[] array) {
         }
     }
 
+    /**
+     * Given an array of positive and negative numbers find the maximum sum of sub array
+     *
+     * @param array input array
+     * @return maximum sum
+     */
+    public static Integer findMaxSumOfSubArray(Integer[] array) {
+        {
+            int maxSum = 0;
+            int runningMax = 0;
+            for (int i = 0; i < array.length; i++) {
+                Integer currentNumber = array[i];
+                if (currentNumber > 0) {
+                    runningMax = runningMax + currentNumber;
+                    maxSum = Math.max(runningMax, maxSum);
+                }
+                if (currentNumber < 0) {
+                    runningMax = Math.max(0, runningMax + currentNumber);
+
+                }
+            }
+            return maxSum;
+        }
+    }
+
 
 }

src/main/java/datastructure/lists/problems/ListProblems.java

@@ -1,6 +1,7 @@
 package algorithm.dp;
 
 import algorithms.dp.LongestCommonSubsequence;
+import org.junit.Assert;
 import org.junit.Test;
 
 /**
@@ -11,6 +12,6 @@ public class LCSTest {
     @Test
     public void testLcs() {
         LongestCommonSubsequence lcs = new LongestCommonSubsequence();
-        System.out.println(lcs.longestCommonSubsequence("thanksa", "halkoa"));
+        Assert.assertEquals(lcs.longestCommonSubsequence("thanksa", "halkoa"), 3);
     }
 }