Some solved problems

Author: gouthampradhan

README.md

@@ -42,6 +42,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Card Flipping Game](problems/src/array/CardFilipGame.java) (Medium)
 - [Employee Free Time](problems/src/array/EmployeeFreeTime.java) (Hard)
 - [Best Meeting Point](problems/src/array/BestMeetingPoint.java) (Hard)
+- [My Calendar III](problems/src/array/MyCalendarThree.java) (Hard)
 
 #### [Backtracking](problems/src/backtracking)
 
@@ -93,6 +94,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Cut Off Trees for Golf Event](problems/src/breadth_first_search/CutOffTreesForGolfEvent.java) (Hard)
 - [Race Car](problems/src/breadth_first_search/RaceCar.java) (Hard)
 - [Bus Routes](problems/src/breadth_first_search/BusRoutes.java) (Hard)
+- [Sliding Puzzle](problems/src/breadth_first_search/SlidingPuzzle.java) (Hard)
+- [Matrix](problems/src/breadth_first_search/Matrix.java) (Medium)
 
 #### [Depth First Search](problems/src/depth_first_search)
 
@@ -183,6 +186,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Largest Sum of Averages](problems/src/dynamic_programming/LargestSumOfAverages.java) (Medium)
 - [Minimum Number of Refueling Stops](problems/src/dynamic_programming/MinimumNumberOfRefuelingStops.java) (Hard)
 - [Cat and Mouse](problems/src/dynamic_programming/CatAndMouse.java) (Hard)
+- [Stone Game](problems/src/dynamic_programming/StoneGame.java) (Medium)
+- [Odd Even Jump](problems/src/dynamic_programming/OddEvenJump.java) (Hard)
 
 
 #### [Greedy](problems/src/greedy)
@@ -232,6 +237,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Delete Node in a Linked List](problems/src/linked_list/DeleteNode.java) (Easy)
 - [Reverse Nodes in k-Group](problems/src/linked_list/ReverseNodesKGroup.java) (Hard)
 - [Swap Nodes in Pairs](problems/src/linked_list/SwapNodesInPairs.java) (Medium)
+- [Middle of Linked List](problems/src/linked_list/MiddleOfLinkedList.java) (Easy)
 
 #### [Math](problems/src/math)
 
@@ -247,6 +253,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Solve the Equation](problems/src/math/SolveTheEquation.java) (Medium)
 - [Couples Holding Hands](problems/src/math/CouplesHoldingHands.java) (Hard)
 - [Reaching Points](problems/src/math/ReachingPoints.java) (Hard)
+- [Nth Magical Number](problems/src/math/NthMagicalNumber.java) (Hard)
 
 #### [Reservoir Sampling](problems/src/reservoir_sampling)
 
@@ -292,6 +299,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Find the Closest Palindrome](problems/src/string/FindTheClosestPalindrome.java) (Hard)
 - [Monotone Increasing Digits](problems/src/string/MonotoneIncreasingDigits.java) (Medium)
 - [Shortest Palindrome](problems/src/string/ShortestPalindrome.java) (Hard)
+- [Valid Word Abbreviation](problems/src/string/ValidWordAbbreviation.java) (Easy)
+- [Longest Palindrome](problems/src/string/LongestPalindrome.java) (Easy)
 
 #### [Tree](problems/src/tree)
 
@@ -335,6 +344,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Maximum Width of Binary Tree](problems/src/tree/MaximumWidthOfBinaryTree.java) (Medium)
 - [Recover Binary Search Tree](problems/src/tree/RecoverBinarySearchTree.java) (Hard)
 - [Binary Tree Postorder Traversal](problems/src/tree/BinaryTreePostorderTraversal.java) (Hard)
+- [Serialize and Deserialize N-ary Tree](problems/src/tree/SerializeAndDeserializeNAryTree.java) (Hard)
+- [Convert BST to Greater Tree](problems/src/tree/ConvertBSTToGreaterTree.java) (Easy)
 
 #### [Two Pointers](problems/src/two_pointers)
 

problems/src/array/MyCalendarThree.java

@@ -0,0 +1,92 @@
+package array;
+
+import java.util.*;
+
+/**
+ * Created by gouthamvidyapradhan on 12/03/2019
+ * Implement a MyCalendarThree class to store your events. A new event can always be added.
+ *
+ * Your class will have one method, book(int start, int end). Formally, this represents a booking on the half open
+ * interval [start, end), the range of real numbers x such that start <= x < end.
+ *
+ * A K-booking happens when K events have some non-empty intersection (ie., there is some time that is common to all
+ * K events.)
+ *
+ * For each call to the method MyCalendar.book, return an integer K representing the largest integer such that there
+ * exists a K-booking in the calendar.
+ *
+ * Your class will be called like this: MyCalendarThree cal = new MyCalendarThree(); MyCalendarThree.book(start, end)
+ * Example 1:
+ *
+ * MyCalendarThree();
+ * MyCalendarThree.book(10, 20); // returns 1
+ * MyCalendarThree.book(50, 60); // returns 1
+ * MyCalendarThree.book(10, 40); // returns 2
+ * MyCalendarThree.book(5, 15); // returns 3
+ * MyCalendarThree.book(5, 10); // returns 3
+ * MyCalendarThree.book(25, 55); // returns 3
+ * Explanation:
+ * The first two events can be booked and are disjoint, so the maximum K-booking is a 1-booking.
+ * The third event [10, 40) intersects the first event, and the maximum K-booking is a 2-booking.
+ * The remaining events cause the maximum K-booking to be only a 3-booking.
+ * Note that the last event locally causes a 2-booking, but the answer is still 3 because
+ * eg. [10, 20), [10, 40), and [5, 15) are still triple booked.
+ */
+public class MyCalendarThree{
+
+    private List<Node> events;
+    private int max;
+
+    private class Node{
+        int n, index;
+        Node(int n, int index){
+            this.n = n;
+            this.index = index;
+        }
+
+        public int getN() {
+            return n;
+        }
+
+        public int getIndex() {
+            return index;
+        }
+    }
+
+    public MyCalendarThree() {
+        events = new ArrayList<>();
+        max = 0;
+    }
+
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        MyCalendarThree calendar = new MyCalendarThree();
+        System.out.println(calendar.book(10, 20));
+        System.out.println(calendar.book(50, 60));
+        System.out.println(calendar.book(10, 40));
+        System.out.println(calendar.book(5, 15));
+        System.out.println(calendar.book(5, 10));
+        System.out.println(calendar.book(25, 55));
+    }
+
+
+    public int book(int start, int end) {
+        events.add(new Node(start, 1));
+        events.add(new Node(end, 0));
+        events.sort((Comparator.comparing(Node::getN).thenComparing(Node::getIndex)));
+        int count = 0;
+        for(Node node : events){
+            if(node.index == 1 && node.n >= end){
+                break;
+            }
+            count += node.index == 1 ? 1 : -1;
+            if(node.getN() >= start){
+                max = Math.max(max, count);
+            }
+        }
+        return max;
+    }
+}

problems/src/breadth_first_search/Matrix.java

@@ -0,0 +1,104 @@
+package breadth_first_search;
+
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 14/03/2019
+ * Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.
+ *
+ * The distance between two adjacent cells is 1.
+ * Example 1:
+ * Input:
+ *
+ * 0 0 0
+ * 0 1 0
+ * 0 0 0
+ * Output:
+ * 0 0 0
+ * 0 1 0
+ * 0 0 0
+ * Example 2:
+ * Input:
+ *
+ * 0 0 0
+ * 0 1 0
+ * 1 1 1
+ * Output:
+ * 0 0 0
+ * 0 1 0
+ * 1 2 1
+ * Note:
+ * The number of elements of the given matrix will not exceed 10,000.
+ * There are at least one 0 in the given matrix.
+ * The cells are adjacent in only four directions: up, down, left and right.
+ *
+ * Solution: Add all the 0th cell to the queue and do a multi-source bfs to count the minimum distance
+ */
+public class Matrix {
+    private static class Node{
+        int r, c;
+        int d;
+        Node(int r, int c){
+            this.r = r;
+            this.c = c;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof Node)) return false;
+            Node node = (Node) o;
+            return r == node.r &&
+                    c == node.c;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(r, c);
+        }
+    }
+    private final int[] R = {0, 0, 1, -1};
+    private final int[] C = {1, -1, 0, 0};
+    private Set<Node> done;
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        int[][] temp = {{0, 0, 0}, {0, 1, 0}, {1, 1, 1}};
+        int[][] result = new Matrix().updateMatrix(temp);
+        System.out.println();
+    }
+
+    public int[][] updateMatrix(int[][] matrix) {
+        int[][] temp = new int[matrix.length][matrix[0].length];
+        done = new HashSet<>();
+        Queue<Node> queue = new ArrayDeque<>();
+        for(int i = 0; i < matrix.length; i ++){
+            for(int j = 0; j < matrix[0].length; j ++){
+                temp[i][j] = matrix[i][j];
+                if(matrix[i][j] == 0){
+                    Node node = new Node(i, j);
+                    queue.offer(node);
+                    done.add(node);
+                }
+            }
+        }
+        while(!queue.isEmpty()){
+            Node curr = queue.poll();
+            for(int i = 0; i < 4; i ++){
+                int newR = curr.r + R[i];
+                int newC = curr.c + C[i];
+                if(newR >= 0 && newR < matrix.length && newC >= 0 && newC < matrix[0].length){
+                    Node child = new Node(newR, newC);
+                    if(!done.contains(child)){
+                        done.add(child);
+                        child.d = curr.d + 1;
+                        temp[newR][newC] = child.d;
+                        queue.offer(child);
+                     }
+                }
+            }
+        }
+        return temp;
+    }
+}