Accepted solutions

Author: gouthampradhan

README.md

@@ -156,6 +156,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Largest Plus Sign](problems/src/dynamic_programming/LargestPlusSign.java) (Medium)
 - [Palindrome Pairs](problems/src/dynamic_programming/PalindromePairs.java) (Hard)
 - [Cherry Pickup](problems/src/dynamic_programming/CherryPickup.java) (Hard)
+- [Knight Probability in Chessboard](problems/src/dynamic_programming/KnightProbabilityInChessboard.java) (Medium)
 
 #### [Greedy](problems/src/greedy)
 
@@ -280,6 +281,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Average of Levels in Binary Tree](problems/src/tree/AverageOfLevelsInBinaryTree.java) (Easy)
 - [Convert Binary Search Tree to Sorted Doubly Linked List](problems/src/tree/BSTtoDoublyLinkedList.java) (Easy)
 - [Same Tree](problems/src/tree/SameTree.java) (Easy)
+- [Binary Tree Longest Consecutive Sequence II](problems/src/tree/BinaryTreeLongestConsecutiveSequenceII.java) (Medium)
 
 #### [Two Pointers](problems/src/two_pointers)
 

problems/src/dynamic_programming/KnightProbabilityInChessboard.java

@@ -0,0 +1,77 @@
+package dynamic_programming;
+
+import java.util.Arrays;
+
+/**
+ * Created by gouthamvidyapradhan on 13/02/2018.
+ * On an NxN chessboard, a knight starts at the r-th row and c-th column and attempts to make exactly K moves.
+ * The rows and columns are 0 indexed, so the top-left square is (0, 0), and the bottom-right square is (N-1, N-1).
+
+ A chess knight has 8 possible moves it can make, as illustrated below. Each move is two squares in a cardinal
+ direction, then one square in an orthogonal direction.
+
+
+ Each time the knight is to move, it chooses one of eight possible moves uniformly at random
+ (even if the piece would go off the chessboard) and moves there.
+
+ The knight continues moving until it has made exactly K moves or has moved off the chessboard.
+ Return the probability that the knight remains on the board after it has stopped moving.
+
+ Example:
+ Input: 3, 2, 0, 0
+ Output: 0.0625
+ Explanation: There are two moves (to (1,2), (2,1)) that will keep the knight on the board.
+ From each of those positions, there are also two moves that will keep the knight on the board.
+ The total probability the knight stays on the board is 0.0625.
+ Note:
+ N will be between 1 and 25.
+ K will be between 0 and 100.
+ The knight always initially starts on the board.
+
+ Solution: Solution O(N ^ 2 x K) DP top down memoization for each different states.
+ */
+public class KnightProbabilityInChessboard {
+
+    int[] R = {1, -1, 2, -2, -1, -2, 2, 1};
+    int[] C = {2,  2, 1, 1, -2, -1, -1, -2};
+
+    double[][][] dp;
+    /**
+     * Main method
+     * @param args
+     * @throws Exception
+     */
+    public static void main(String[] args) throws Exception{
+        System.out.println(new KnightProbabilityInChessboard().knightProbability(3, 2, 0, 0));
+    }
+
+    public double knightProbability(int N, int K, int r, int c) {
+        dp = new double[N][N][K + 1];
+        for(int i = 0; i < N; i ++){
+            for(int j = 0; j < N; j ++){
+                Arrays.fill(dp[i][j], -1.0D);
+            }
+        }
+        for(int i = 0; i < N; i ++){
+            for(int j = 0; j < N; j ++){
+                dp[i][j][0] = 1.0D;
+            }
+        }
+        return dp(dp, r, c, K, N);
+    }
+
+    private double dp(double[][][] dp, int r, int c, int K, int N){
+        if(r < 0 || r >= N || c < 0 || c >= N) return 0.0D;
+        if(dp[r][c][K] != -1.0D) return dp[r][c][K];
+        double sum = 0.0D;
+        for(int i = 0; i < 8; i ++){
+            int newR = r + R[i];
+            int newC = c + C[i];
+            if(newR >= 0 && newR < N && newC >= 0 && newC < N){
+                sum += dp(dp, newR, newC, K - 1, N);
+            }
+        }
+        dp[r][c][K] = (sum / 8.0);
+        return dp[r][c][K];
+    }
+}

problems/src/tree/BinaryTreeLongestConsecutiveSequenceII.java

@@ -0,0 +1,104 @@
+package tree;
+
+/**
+ * Created by gouthamvidyapradhan on 11/02/2018.
+ * Given a binary tree, you need to find the length of Longest Consecutive Path in Binary Tree.
+
+ Especially, this path can be either increasing or decreasing. For example, [1,2,3,4] and [4,3,2,1] are both
+ considered valid, but the path [1,2,4,3] is not valid. On the other hand, the path can be in the child-Parent-child
+ order, where not necessarily be parent-child order.
+
+ Example 1:
+ Input:
+ 1
+ / \
+ 2   3
+ Output: 2
+ Explanation: The longest consecutive path is [1, 2] or [2, 1].
+ Example 2:
+ Input:
+ 2
+ / \
+ 1   3
+ Output: 3
+ Explanation: The longest consecutive path is [1, 2, 3] or [3, 2, 1].
+ Note: All the values of tree nodes are in the range of [-1e7, 1e7].
+ */
+public class BinaryTreeLongestConsecutiveSequenceII {
+
+    public static class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) { val = x; }
+    }
+
+    private class Node{
+        int i, d;
+        int val;
+        Node(int i, int d, int val){
+            this.i = i;
+            this.d = d;
+            this.val = val;
+        }
+    }
+    private int max = Integer.MIN_VALUE;
+    public static void main(String[] args) throws Exception{
+        TreeNode root = new TreeNode(2);
+        root.left = new TreeNode(1);
+        //root.left.left = new TreeNode(4);
+        root.right = new TreeNode(3);
+        System.out.println(new BinaryTreeLongestConsecutiveSequenceII().longestConsecutive(root));
+    }
+
+
+    public int longestConsecutive(TreeNode root) {
+        Node n = preorder(root);
+        if(n != null){
+            max = Math.max(max, n.d);
+            max = Math.max(max, n.i);
+            if(n.i > 1 && n.d > 1){
+                max = Math.max(max, n.d + n.i - 1);
+            }
+        }
+        if(max == Integer.MIN_VALUE) return 0;
+        return max;
+    }
+
+
+    private Node preorder(TreeNode node){
+        if(node == null) return null;
+        Node left = preorder(node.left);
+        Node curr = new Node(1, 1, node.val);
+        if(left != null){
+            max = Math.max(max, left.d);
+            max = Math.max(max, left.i);
+            if(left.val == node.val + 1){
+                curr.d = left.d + 1;
+                curr.i = 1;
+            } else if(left.val == node.val - 1){
+                curr.i = left.i + 1;
+                curr.d = 1;
+            }
+        }
+        Node right = preorder(node.right);
+        if(right != null){
+            max = Math.max(max, right.d);
+            max = Math.max(max, right.i);
+            if(right.val == node.val + 1){
+                if(right.d + 1 > curr.d){
+                    curr.d = right.d + 1;
+                }
+            } else if(right.val == node.val - 1){
+                if(right.i + 1 > curr.i){
+                    curr.i = right.i + 1;
+                }
+            }
+        }
+        if(curr.i > 1 && curr.d > 1){
+            max = Math.max(max, curr.d + curr.i - 1);
+        }
+        return curr;
+    }
+
+}