@@ -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)
 

@@ -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;
+}
+}

@@ -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;
+}
+}