Merge pull request #195 from bky373/bky373-week-12

[bky373] Add Week 12 Solutions

Author: DaleSeo

jump-game/bky373.java

@@ -0,0 +1,15 @@
+// time: O(N)
+// space: O(1)
+class Solution {
+
+    public boolean canJump(int[] nums) {
+        int lastPosition = nums.length - 1;
+
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (i + nums[i] >= lastPosition) {
+                lastPosition = i;
+            }
+        }
+        return lastPosition == 0;
+    }
+}

longest-common-subsequence/bky373.java

@@ -0,0 +1,20 @@
+// time: O(m*n)
+// space: O(m*n)
+class Solution {
+
+    public int longestCommonSubsequence(String text1, String text2) {
+        int[][] dp = new int[text1.length() + 1][text2.length() + 1];
+
+        for (int col = text2.length() - 1; col >= 0; col--) {
+            for (int row = text1.length() - 1; row >= 0; row--) {
+                if (text1.charAt(row) == text2.charAt(col)) {
+                    dp[row][col] = 1 + dp[row + 1][col + 1];
+                } else {
+                    dp[row][col] = Math.max(dp[row + 1][col], dp[row][col + 1]);
+                }
+            }
+        }
+
+        return dp[0][0];
+    }
+}

longest-increasing-subsequence/bky373.java

@@ -0,0 +1,24 @@
+// time: O(N^2)
+// space: O(N)
+class Solution {
+
+    public int lengthOfLIS(int[] nums) {
+        int[] dp = new int[nums.length];
+        Arrays.fill(dp, 1);
+
+        for (int i = 1; i < nums.length; i++) {
+            for (int j = 0; j < i; j++) {
+                if (nums[i] > nums[j]) {
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                }
+            }
+        }
+
+        int longest = 0;
+        for (int count : dp) {
+            longest = Math.max(longest, count);
+        }
+
+        return longest;
+    }
+}

maximum-subarray/bky373.java

@@ -0,0 +1,17 @@
+// time: O(N)
+// space: O(1)
+class Solution {
+
+    public int maxSubArray(int[] nums) {
+        int currentSum = nums[0];
+        int maxSum = nums[0];
+
+        for (int i = 1; i < nums.length; i++) {
+            int k = nums[i];
+            currentSum = Math.max(k, currentSum + k);
+            maxSum = Math.max(maxSum, currentSum);
+        }
+
+        return maxSum;
+    }
+}

unique-paths/bky373.java

@@ -0,0 +1,47 @@
+/*
+   [Approch 1]
+   - time: O(m*n)
+   - space: O(m*n)
+ */
+class Solution {
+
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m][n];
+
+        for (int[] row : dp) {
+            Arrays.fill(row, 1);
+        }
+
+        for (int row = 1; row < m; row++) {
+            for (int col = 1; col < n; col++) {
+                dp[row][col] = dp[row - 1][col] + dp[row][col - 1];
+            }
+        }
+
+        return dp[m - 1][n - 1];
+    }
+}
+
+/*
+   [Approch 2]
+   - time: O(m*n)
+   - space: O(n)
+ */
+class Solution {
+
+    public int uniquePaths(int m, int n) {
+        int[] upper = new int[n];
+
+        Arrays.fill(upper, 1);
+
+        for (int i = 1; i < m; i++) {
+            int left = 1;
+            for (int j = 1; j < n; j++) {
+                left += upper[j];
+                upper[j] = left;
+            }
+        }
+
+        return upper[n - 1];
+    }
+}