Accepted

Author: gouthampradhan

problems/src/BinaryTreeMaximumPathSum.java

@@ -0,0 +1,51 @@
+/**
+ * Created by gouthamvidyapradhan on 03/04/2017.
+ * Accepted
+ */
+public class BinaryTreeMaximumPathSum
+{
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+
+    private int max = Integer.MIN_VALUE;
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        TreeNode root = new TreeNode(5);
+        root.left = new TreeNode(4);
+        root.left.left = new TreeNode(3);
+        root.left.left.left = new TreeNode(-1);
+        root.right = new TreeNode(7);
+        root.right.left = new TreeNode(2);
+        root.right.left.left = new TreeNode(9);
+        System.out.println(new BinaryTreeMaximumPathSum().maxPathSum(root));
+    }
+    public int maxPathSum(TreeNode root)
+    {
+        if(root == null) return 0;
+        dfs(root);
+        return max;
+    }
+
+    private int dfs(TreeNode root)
+    {
+        if(root == null) return 0;
+        int left = dfs(root.left);
+        int right = dfs(root.right);
+        max = Math.max(max, root.val);
+        max = Math.max(max, root.val + left);
+        max = Math.max(max, root.val + right);
+        max = Math.max(max, root.val + left + right);
+        int leftVal = Math.max(root.val, root.val + left);
+        int rightVal = Math.max(root.val, root.val + right);
+        return Math.max(leftVal, rightVal);
+    }
+}

problems/src/JumpGameII.java

@@ -0,0 +1,32 @@
+/**
+ * Created by gouthamvidyapradhan on 02/04/2017.
+ * Accepted
+ */
+public class JumpGameII
+{
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+
+    }
+
+    public int jump(int[] nums)
+    {
+        int step = 0;
+        int e = 0, max = 0;
+        for(int i = 0; i < nums.length - 1; i++)
+        {
+            max = Math.max(max, i + nums[i]);
+            if(i == e)
+            {
+                step++;
+                e = max;
+            }
+        }
+        return step;
+    }
+}

problems/src/LongestIncreasingSubsequence.java

@@ -0,0 +1,36 @@
+/**
+ * Created by gouthamvidyapradhan on 02/04/2017.
+ * Accepted
+ */
+public class LongestIncreasingSubsequence
+{
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        int[] nums = {9, 8, 7, 6};
+        System.out.println(new LongestIncreasingSubsequence().lengthOfLIS(nums));
+    }
+
+    public int lengthOfLIS(int[] nums)
+    {
+        if(nums.length == 0) return 0;
+        int[] A = new int[nums.length];
+        int max = Integer.MIN_VALUE;
+        for(int i = 0, l = nums.length; i < l; i ++)
+        {
+            int lis = 1;
+            for(int j = 0; j < i; j ++)
+            {
+                if(nums[i] > nums[j])
+                    lis = Math.max(lis, A[j] + 1);
+            }
+            A[i] = lis;
+            max = Math.max(max, A[i]);
+        }
+        return max;
+    }
+}

problems/src/MaximumProductSubarray.java

@@ -0,0 +1,33 @@
+/**
+ * Created by gouthamvidyapradhan on 02/04/2017.
+ * Accepted
+ */
+public class MaximumProductSubarray
+{
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception
+    {
+        int[] A = {2,3,-2,4};
+        System.out.println(new MaximumProductSubarray().maxProduct(A));
+    }
+
+    public int maxProduct(int[] nums)
+    {
+        if(nums.length == 1) return nums[0];
+        int min = nums[0];
+        int max = nums[0];
+        int result = max;
+        for(int i = 1; i < nums.length; i ++)
+        {
+            int prevMin = min, prevMax = max;
+            min = Math.min(nums[i], Math.min(nums[i] * prevMin, nums[i] * prevMax));
+            max = Math.max(nums[i], Math.max(nums[i] * prevMin, nums[i] * prevMax));
+            result = Math.max(result, max);
+        }
+        return result;
+    }
+}