Merge pull request neetcode-gh#357 from miladra/main

Add 198, 213, 5, 647, 62, 300

Author: neetcode-gh

java/152-Maximum-Product-Subarray.java

@@ -1,5 +1,7 @@
 class Solution {
     public int maxProduct(int[] nums) {
+        if (nums.length == 1) return nums[0];
+        
         int res = nums[0];
         int max = 1;
         int min = 1;

java/198-House-Robber.java

@@ -0,0 +1,31 @@
+class Solution {
+    public int rob(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        if (nums.length == 1) return nums[0];
+        if (nums.length == 2) return Math.max(nums[0], nums[1]);
+        
+        int robWithOutIncludingLastHouse = 0, robWithIncludingLastHouse = 0;
+
+        for (int n : nums) {
+            int temp = Math.max(robWithOutIncludingLastHouse + n, robWithIncludingLastHouse);
+            robWithOutIncludingLastHouse = robWithIncludingLastHouse;
+            robWithIncludingLastHouse = temp;
+        }
+        return robWithIncludingLastHouse;
+    }
+    
+    public int robDP(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        if (nums.length == 1) return nums[0];
+        if (nums.length == 2) return Math.max(nums[0], nums[1]);
+        
+        int[] dp = new int[nums.length];
+        dp[0] = nums[0];
+        dp[1] = Math.max(nums[0], nums[1]);
+        
+        for (int i = 2; i < nums.length; i++) {
+            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
+        }
+        return dp[nums.length - 1];
+    }
+}

java/213-House-RobberII.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int rob(int[] nums) {
+        
+     
+        if(nums.length == 0 ) return 0;
+        if(nums.length == 1 ) return nums[0];
+        
+        return Math.max(robHelper(nums,0,nums.length - 2) , robHelper(nums , 1 , nums.length - 1));
+    }
+    public int robHelper(int[] nums , int start , int end){
+     int rob1 = 0;
+     int rob2 = 0;
+     for (int i = start; i <= end; i++) {
+            int temp = Math.max(rob1 + nums[i], rob2);
+            rob1 = rob2;
+            rob2 = temp;
+        }
+        return rob2;
+    }
+}

java/300-Longest-Increasing-Subsequence.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        //O(n^2)
+       if(nums.length == 1) return 1;
+        
+       int[] LIS = new int[nums.length];
+        Arrays.fill(LIS,1);
+        int maximumSoFar = 1;
+        
+        for (int i = nums.length - 1 ; i >= 0; i--) {
+            for(int j= i + 1 ; j < nums.length ; j++){
+                if (nums[i] < nums[j]) {
+                    LIS[i] = Math.max(1 + LIS[j], LIS[i]);
+                }
+            }
+            maximumSoFar = Math.max(maximumSoFar, LIS[i]);
+        }
+        return maximumSoFar;
+    }
+}

java/5-Longest-Palindromic-Substring.java

@@ -0,0 +1,43 @@
+class Solution {
+    public String longestPalindrome(String s) {
+
+        int strLength = s.length();
+
+        if (strLength < 2) {
+            return s;
+        }
+
+        int resultLength = 0;
+        String result = "";
+
+        for (int i = 0; i < s.length(); i++) {
+            //Odd length
+            int l = i, r = i;
+            while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
+                if ((r - l + 1) > resultLength) {
+                    result = s.substring(l, r + 1);
+                    resultLength = r - l + 1;
+                }
+                l -= 1;
+                r += 1;
+            }
+
+            // even length
+            l = i;
+            r = i + 1;
+            while (l >= 0 && r < s.length() && s.charAt(l) == s.charAt(r)) {
+                if ((r - l + 1) > resultLength) {
+                    result = s.substring(l, r + 1);
+                    resultLength = r - l + 1;
+                }
+                l -= 1;
+                r += 1;
+            }
+
+
+        }
+
+        return result;
+
+    }
+}

java/62-Unique-Paths.java

@@ -0,0 +1,22 @@
+class Solution {
+    public static int uniquePaths(int m, int n) {
+           int[][] dp = new int[m][n];
+   
+           // Fill out last row
+           for (int j = 0; j < n; j++) {
+               dp[m-1][j] = 1;
+           }
+   
+           // Fill out last column
+           for (int i = 0; i < m; i++) {
+               dp[i][n-1] = 1;
+           }
+   
+           for (int i = m - 2; i >= 0; i--) {
+               for (int j = n - 2; j >= 0; j--) {
+                   dp[i][j] = dp[i][j + 1] + dp[i + 1][j];
+               }
+           }
+           return dp[0][0];
+       }
+   }

java/647-Palindromic-Substrings.java

@@ -0,0 +1,27 @@
+class Solution {
+    public int countSubstrings(String s) {
+
+        if (s.length() < 2) {
+            return s.length();
+        }
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            // Odd Length
+            int left = i, right = i;
+            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+                result++;
+                left--;
+                right++;
+            }
+            // Even Length
+            left = i;
+            right = i + 1;
+            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+                result++;
+                left--;
+                right++;
+            }
+        }
+        return result;
+    }
+}