Solved problems

Author: gouthampradhan

README.md

@@ -43,6 +43,9 @@ My accepted leetcode solutions to some of the common interview problems.
 - [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)
+- [Champagne Tower](problems/src/array/ChampagneTower.java) (Medium)
+- [Valid Tic-Tac-Toe State](problems/src/array/ValidTicTacToeState.java) (Medium)
+- [Number of Subarrays with Bounded Maximum](problems/src/array/SubArraysWithBoundedMaximum.java) (Medium)
 
 #### [Backtracking](problems/src/backtracking)
 
@@ -116,6 +119,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Bricks Falling When Hit](problems/src/depth_first_search/BricksFallingWhenHit.java) (Hard)
 - [Robot Room Cleaner](problems/src/depth_first_search/RobotRoomCleaner.java) (Hard)
 - [Cracking the Safe](problems/src/depth_first_search/CrackingTheSafe.java) (Hard)
+- [All Paths From Source to Target](problems/src/depth_first_search/AllPathsFromSourceToTarget.java) (Medium)
 
 #### [Design](problems/src/design)
 
@@ -188,6 +192,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [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)
+- [Profitable Schemes](problems/src/dynamic_programming/ProfitableSchemes.java) (Hard)
 
 
 #### [Greedy](problems/src/greedy)
@@ -225,6 +230,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Meeting Rooms II](problems/src/heap/MeetingRoomsII.java) (Medium)
 - [Top K Frequent Words](problems/src/heap/TopKFrequentWords.java) (Medium)
 - [Candy](problems/src/heap/Candy.java) (Hard)
+- [Smallest Rotation with Highest Score](problems/src/heap/SmallestRotationWithHighestScore.java) (Hard)
 
 #### [Linked List](problems/src/linked_list)
 
@@ -301,6 +307,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [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)
+- [Replace Words](problems/src/string/ReplaceWords.java) (Medium)
+- [Rotate String](problems/src/string/RotateString.java) (Easy)
 
 #### [Tree](problems/src/tree)
 
@@ -361,4 +369,5 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Minimum Window Substring](problems/src/two_pointers/MinimumWindowSubstring.java) (Hard)
 - [Smallest Range](problems/src/two_pointers/SmallestRange.java) (Hard)
 - [Subarray Product Less Than K](problems/src/two_pointers/SubarrayProductLessThanK.java) (Medium)
+- [Number of Matching Subsequences](problems/src/two_pointers/NumberOfMatchingSubsequences.java) (Medium)
 

problems/src/array/ChampagneTower.java

@@ -0,0 +1,74 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 28/03/2019
+ * We stack glasses in a pyramid, where the first row has 1 glass, the second row has 2 glasses, and so on until the
+ * 100th row.  Each glass holds one cup (250ml) of champagne.
+ *
+ * Then, some champagne is poured in the first glass at the top.  When the top most glass is full, any excess liquid
+ * poured will fall equally to the glass immediately to the left and right of it.  When those glasses become full,
+ * any excess champagne will fall equally to the left and right of those glasses, and so on.  (A glass at the bottom
+ * row has it's excess champagne fall on the floor.)
+ *
+ * For example, after one cup of champagne is poured, the top most glass is full.  After two cups of champagne are
+ * poured, the two glasses on the second row are half full.  After three cups of champagne are poured, those two
+ * cups become full - there are 3 full glasses total now.  After four cups of champagne are poured, the third row
+ * has the middle glass half full, and the two outside glasses are a quarter full, as pictured below.
+ *
+ *
+ *
+ * Now after pouring some non-negative integer cups of champagne, return how full the j-th glass in the i-th row is
+ * (both i and j are 0 indexed.)
+ *
+ *
+ *
+ * Example 1:
+ * Input: poured = 1, query_glass = 1, query_row = 1
+ * Output: 0.0
+ * Explanation: We poured 1 cup of champange to the top glass of the tower (which is indexed as (0, 0)). There will
+ * be no excess liquid so all the glasses under the top glass will remain empty.
+ *
+ * Example 2:
+ * Input: poured = 2, query_glass = 1, query_row = 1
+ * Output: 0.5
+ * Explanation: We poured 2 cups of champange to the top glass of the tower (which is indexed as (0, 0)). There is
+ * one cup of excess liquid. The glass indexed as (1, 0) and the glass indexed as (1, 1) will share the excess liquid
+ * equally, and each will get half cup of champange.
+ *
+ *
+ * Note:
+ *
+ * poured will be in the range of [0, 10 ^ 9].
+ * query_glass and query_row will be in the range of [0, 99].
+ *
+ * Solution: Calculate for every glass and for each row at a time. Use the value from the previous row to calculate the
+ * current value.
+ * @see PascalsTriangle
+ */
+public class ChampagneTower {
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        System.out.println(new ChampagneTower().champagneTower(4, 2, 1));
+    }
+
+    public double champagneTower(int poured, int query_row, int query_glass) {
+        double[][] A = new double[query_row + 1][query_row + 1];
+        A[0][0] = poured;
+        for(int i = 1; i <= query_row; i ++){
+            for(int j = 0; j <= query_row; j ++){
+                if(A[i - 1][j] > 1.0){
+                    A[i][j] += (A[i - 1][j] - 1.0) / 2;
+                }
+                if(j == 0) continue;
+                if(A[i - 1][j - 1] > 1.0){
+                    A[i][j] += (A[i - 1][j - 1] - 1.0) / 2;
+                }
+            }
+        }
+        if(A[query_row][query_glass] > 1.0) return 1;
+        else return A[query_row][query_glass];
+    }
+}

problems/src/array/SubArraysWithBoundedMaximum.java

@@ -0,0 +1,63 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 29/03/2019
+ * We are given an array A of positive integers, and two positive integers L and R (L <= R).
+ *
+ * Return the number of (contiguous, non-empty) subarrays such that the value of the maximum array element in that
+ * subarray is at least L and at most R.
+ *
+ * Example :
+ * Input:
+ * A = [2, 1, 4, 3]
+ * L = 2
+ * R = 3
+ * Output: 3
+ * Explanation: There are three subarrays that meet the requirements: [2], [2, 1], [3].
+ * Note:
+ *
+ * L, R  and A[i] will be an integer in the range [0, 10^9].
+ * The length of A will be in the range of [1, 50000].
+ */
+public class SubArraysWithBoundedMaximum {
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        int[] A = {2, 1, 4, 3};
+        System.out.println(new SubArraysWithBoundedMaximum().numSubarrayBoundedMax(A, 2, 3));
+    }
+
+    public int numSubarrayBoundedMax(int[] A, int L, int R) {
+        int[] DP = new int[A.length];
+        int v = -1;
+        for(int i = A.length - 1; i >= 0; i --){
+            if(A[i] >= L && A[i] <= R){
+                if(v != -1){
+                    DP[i] = v - i + 1;
+                } else {
+                    DP[i] = 1;
+                    v = i;
+                }
+            } else if(A[i] < L){
+                if(v == -1){
+                    v = i;
+                } if(i + 1 < A.length){
+                    if(A[i + 1] < L || (A[i + 1] >= L && A[i + 1] <= R)){
+                        DP[i] = DP[i + 1];
+                    } else {
+                        DP[i] = 0;
+                    }
+                }
+            } else {
+                v = -1;
+            }
+        }
+        int sum = 0;
+        for(int i = 0; i < DP.length; i ++){
+            sum += DP[i];
+        }
+        return sum;
+    }
+}

problems/src/array/ValidTicTacToeState.java

@@ -0,0 +1,88 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 29/03/2019
+ * A Tic-Tac-Toe board is given as a string array board. Return True if and only if it is possible to reach this
+ * board position during the course of a valid tic-tac-toe game.
+ *
+ * The board is a 3 x 3 array, and consists of characters " ", "X", and "O".  The " " character represents an empty
+ * square.
+ *
+ * Here are the rules of Tic-Tac-Toe:
+ *
+ * Players take turns placing characters into empty squares (" ").
+ * The first player always places "X" characters, while the second player always places "O" characters.
+ * "X" and "O" characters are always placed into empty squares, never filled ones.
+ * The game ends when there are 3 of the same (non-empty) character filling any row, column, or diagonal.
+ * The game also ends if all squares are non-empty.
+ * No more moves can be played if the game is over.
+ * Example 1:
+ * Input: board = ["O  ", "   ", "   "]
+ * Output: false
+ * Explanation: The first player always plays "X".
+ *
+ * Example 2:
+ * Input: board = ["XOX", " X ", "   "]
+ * Output: false
+ * Explanation: Players take turns making moves.
+ *
+ * Example 3:
+ * Input: board = ["XXX", "   ", "OOO"]
+ * Output: false
+ *
+ * Example 4:
+ * Input: board = ["XOX", "O O", "XOX"]
+ * Output: true
+ * Note:
+ *
+ * board is a length-3 array of strings, where each string board[i] has length 3.
+ * Each board[i][j] is a character in the set {" ", "X", "O"}.
+ *
+ * Solution: Do a brute-force check for each row, column and diagonals and keep track of count of 'X' and 'O'
+ */
+public class ValidTicTacToeState {
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        String[] board = {"XXX", "XOO", "OO "};
+        System.out.println(new ValidTicTacToeState().validTicTacToe(board));
+    }
+
+    public boolean validTicTacToe(String[] board) {
+        boolean xWon = hasWon(board, 'X');
+        boolean oWon = hasWon(board, 'O');
+        int xcount = 0, ocount = 0;
+        for(int i = 0; i < 3; i ++){
+            for(int j = 0; j < 3; j ++){
+                if(board[i].charAt(j) == 'X'){
+                    xcount++;
+                }else if(board[i].charAt(j) == 'O'){
+                    ocount++;
+                }
+            }
+        }
+        if(xWon && oWon) return false;
+        if(xWon){
+            return ((xcount - 1 == ocount));
+        } else if(oWon){
+            return ((xcount == ocount));
+        } else {
+            return (xcount == ocount || xcount - 1 == ocount);
+        }
+    }
+
+    private boolean hasWon(String[] board, char c){
+        boolean diagnol = ((board[0].charAt(0) == c && board[1].charAt(1) == c && board[2].charAt(2) == c) ||
+        (board[0].charAt(2) == c && board[1].charAt(1) == c && board[2].charAt(0) == c));
+        if(diagnol) return true;
+        for(int i = 0; i < 3; i ++){
+            if(board[i].charAt(0) == c && board[i].charAt(1) == c && board[i].charAt(2) == c) return true;
+        }
+        for(int i = 0; i < 3; i ++){
+            if(board[0].charAt(i) == c && board[1].charAt(i) == c && board[2].charAt(i) == c) return true;
+        }
+        return false;
+    }
+}

problems/src/depth_first_search/AllPathsFromSourceToTarget.java

@@ -0,0 +1,63 @@
+package depth_first_search;
+
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 28/03/2019
+ * Given a directed, acyclic graph of N nodes.  Find all possible paths from node 0 to node N-1, and return them in
+ * any order.
+ *
+ * The graph is given as follows:  the nodes are 0, 1, ..., graph.length - 1.  graph[i] is a list of all nodes j for
+ * which the edge (i, j) exists.
+ *
+ * Example:
+ * Input: [[1,2], [3], [3], []]
+ * Output: [[0,1,3],[0,2,3]]
+ * Explanation: The graph looks like this:
+ * 0--->1
+ * |    |
+ * v    v
+ * 2--->3
+ * There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.
+ * Note:
+ *
+ * The number of nodes in the graph will be in the range [2, 15].
+ * You can print different paths in any order, but you should keep the order of nodes inside one path.
+ *
+ * Solution: Do a dfs to reach every path. Since its a DAG there can be no cycles and safe to proceed without
+ * checking if the node has already been visited. Maintain a stack to keep track of the path and when a leaf node
+ * has been reached add the elements in the stack to the result array
+ */
+public class AllPathsFromSourceToTarget {
+    /**
+     * Main method
+     * @param args
+     */
+    public static void main(String[] args) {
+        int[][] graph = {{1, 2}, {3}, {3}, {}};
+        System.out.println(new AllPathsFromSourceToTarget().allPathsSourceTarget(graph));
+    }
+
+    public List<List<Integer>> allPathsSourceTarget(int[][] graph) {
+        Set<Integer> done = new HashSet<>();
+        Stack<Integer> stack = new Stack<>();
+        List<List<Integer>> result = new ArrayList<>();
+        dfs(result, done, 0, stack, graph);
+        return result;
+    }
+
+    private void dfs(List<List<Integer>> result, Set<Integer> done, int i, Stack<Integer> stack, int[][] graph){
+        done.add(i);
+        stack.push(i);
+        int[] children = graph[i];
+        if(children.length == 0){
+            List<Integer> childList = new ArrayList<>(stack);
+            result.add(childList);
+        } else{
+           for(int c : children){
+               dfs(result, done, c, stack, graph);
+           }
+        }
+        stack.pop();
+        done.remove(i);
+    }
+}