add

Author: shashankch

src/LeetcodeQuestions/HouseRobber.java

@@ -0,0 +1,58 @@
+package LeetcodeQuestions;
+
+// https://leetcode.com/problems/house-robber/
+// https://leetcode.com/problems/house-robber-ii/
+public class HouseRobber {
+
+    // linear..
+    public static int houserob(int nums[]) {
+
+        if (nums.length == 0) {
+            return 0;
+        }
+        int[] dp = new int[nums.length + 1];
+        dp[0] = 0;
+        dp[1] = nums[0];
+        for (int i = 2; i < nums.length + 1; i++) {
+            dp[i] = Math.max(dp[i - 1], nums[i - 1] + dp[i - 2]);
+        }
+        return dp[nums.length];
+    }
+
+
+    // when houses are in circular fashion..
+
+    public static int houserobCircular(int nums[]) {
+        if (nums.length == 0)
+            return 0;
+
+        if (nums.length == 1)
+            return nums[0];
+
+        int maxExcludeFirst = helper(nums, 1, nums.length);
+        int maxExcludeLast = helper(nums, 0, nums.length - 1);
+
+        return Math.max(maxExcludeFirst, maxExcludeLast);
+
+
+    }
+
+    public static int helper(int[] nums, int start, int end) {
+        int prevMax = 0;
+        int currentMax = 0;
+
+        for (int i = start; i < end; i++) {
+            int newMax = Math.max(currentMax, nums[i] + prevMax);
+
+            prevMax = currentMax;
+            currentMax = newMax;
+        }
+
+        return currentMax;
+    }
+
+
+    public static void main(String[] args) {
+
+    }
+}

src/LeetcodeQuestions/uniquePath.java

@@ -6,23 +6,120 @@
 // https://leetcode.com/problems/unique-paths-ii/
 public class uniquePath {
 
-   
 
-    public static boolean uniquePathone() {
+    //O(M*N)
+    public static int uniquePathwithObstacles(int arr[][]) {
 
 
+        int r = arr.length;
+        int c = arr[0].length;
 
+        if (arr[0][0] == 1) {
+            return 0;
+        }
+
+        arr[0][0] = 1;
+
+        for (int i = 1; i < r; i++) {
+
+            arr[i][0] = (arr[i][0] == 0 && arr[i - 1][0] == 1) ? 1 : 0;
+        }
+
+
+        for (int i = 1; i < r; i++) {
+
+            arr[0][i] = (arr[0][i] == 0 && arr[0][i - 1] == 1) ? 1 : 0;
+        }
+
+
+        for (int i = 1; i < r; i++) {
+
+            for (int j = 1; j < c; j++) {
+
+                if (arr[i][j] == 0) {
+                    arr[i][j] = arr[i - 1][j] + arr[i][j - 1];
+                } else {
+                    arr[i][j] = 0;
+                }
+            }
+        }
+
+
+        return arr[r - 1][c - 1];
 
 
     }
 
 
+    // Unique paths without any obstacles recursive and dp solution ...
+    public int uniquePaths(int m, int n) {
+
+        return solve(0, 0, m, n);
+    }
+// recursive
+    public int solve(int i, int j, int m, int n) {
+        if (i >= m || j >= n)
+            return 0;
+        if (i == m - 1 && j == n - 1)
+            return 1;
+        return solve(i + 1, j, m, n) + solve(i, j + 1, m, n);
+    }
+
+
+    int[][] dp = new int[101][101];
+// dp ...
+    public int uniquePathsDP(int m, int n) {
+
+        for (int i = 0; i < m; i++)
+            for (int j = 0; j < n; j++)
+                dp[i][j] = -1;
+
+        return solvedp(0, 0, m, n);
+    }
+
+    public int solvedp(int i, int j, int m, int n) {
+        if (i >= m || j >= n)
+            return 0;
+        if (i == m - 1 && j == n - 1)
+            return 1;
+        if (dp[i][j] != -1)
+            return dp[i][j];
+        return dp[i][j] = solve(i + 1, j, m, n) + solve(i, j + 1, m, n);
+    }
+
+
+    // convert into 1d dp method...
+    static int numberOfPaths(int m, int n) {
+        // Create a 1D array to store results of subproblems
+        int[] dp = new int[n];
+        dp[0] = 1;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp[j] += dp[j - 1];
+            }
+        }
+
+        return dp[n - 1];
+    }
+
+    // using combinatorics..
+    static int numberOfPaths2(int m, int n) {
+        // We have to calculate m+n-2 C n-1 here
+        // which will be (m+n-2)! / (n-1)! (m-1)!
+        int path = 1;
+        for (int i = n; i < (m + n - 1); i++) {
+            path *= i;
+            path /= (i - n + 1);
+        }
+        return path;
+    }
 
     public static void main(String[] args) {
 
-        int arr[][]={{0,0,0},{0,1,0},{0,0,0}};
-      
-       
+        int arr[][] = {{0, 0, 0}, {0, 1, 0}, {0, 0, 0}};
+
+
 
         System.out.println();