Solved problems

Author: gouthampradhan

README.md

@@ -47,6 +47,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Valid Tic-Tac-Toe State](problems/src/array/ValidTicTacToeState.java) (Medium)
 - [Number of Subarrays with Bounded Maximum](problems/src/array/SubArraysWithBoundedMaximum.java) (Medium)
 - [Surface Area of 3D Shapes](problems/src/array/SurfaceAreaOfThreeDShapes.java) (Easy)
+- [Max Consecutive Ones](problems/src/array/MaxConsecutiveOnes.java) (Easy)
+- [Max Consecutive Ones II](problems/src/array/MaxConsecutiveOnesII.java) (Medium)
 
 #### [Backtracking](problems/src/backtracking)
 
@@ -67,7 +69,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Expression Add Operators](problems/src/backtracking/ExpressionAddOperators.java) (Hard)
 - [Wildcard Matching](problems/src/backtracking/WildcardMatching.java) (Hard)
 - [Letter Case Permutation](problems/src/backtracking/LetterCasePermutation.java) (Easy)
-
+- [Zuma Game](problems/src/backtracking/ZumaGame.java) (Hard)
+- [Matchsticks to Square](problems/src/backtracking/MatchsticksToSquare.java) (Medium)
 
 #### [Binary Search](problems/src/binary_search)
 
@@ -82,13 +85,15 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Target Sum](problems/src/binary_search/TargetSum.java) (Medium)
 - [H-Index II](problems/src/binary_search/HIndexII.java) (Medium)
 - [Swim in Rising Water](problems/src/binary_search/SwimInRisingWater.java) (Hard)
+- [Time Based Key-Value Store](problems/src/binary_search/TimeBasedKeyValuePair.java) (Medium)
 
 #### [Bit Manipulation](problems/src/bit_manipulation)
 
 - [Gray Code](problems/src/bit_manipulation/GrayCode.java) (Medium)
 - [Hamming Distance](problems/src/bit_manipulation/HammingDistance.java) (Easy)
 - [Total Hamming Distance](problems/src/bit_manipulation/TotalHammingDistance.java) (Medium)
 - [Divide Two Integers](problems/src/bit_manipulation/DivideTwoIntegers.java) (Medium)
+- [Binary Number with Alternating Bits](problems/src/bit_manipulation/BinaryNumberWithAlternatingBits.java) (Easy)
 
 #### [Breadth First Search](problems/src/breadth_first_search)
 
@@ -123,6 +128,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [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)
+- [Max Area of Island](problems/src/depth_first_search/MaxAreaOfIsland.java) (Medium)
 
 #### [Design](problems/src/design)
 
@@ -148,6 +154,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Kth Largest Element In a Array](problems/src/divide_and_conquer/KthLargestElementInAnArray.java) (Medium)
 - [Reverse Pairs](problems/src/divide_and_conquer/ReversePairs.java) (Hard)
 - [Search in a 2D Matrix](problems/src/divide_and_conquer/SearchA2DMatrix.java) (Medium)
+- [24 Game](problems/src/divide_and_conquer/TwentyFourGame.java) (Hard)
 
 #### [Dynamic Programming](problems/src/dynamic_programming)
 
@@ -197,6 +204,9 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Odd Even Jump](problems/src/dynamic_programming/OddEvenJump.java) (Hard)
 - [Profitable Schemes](problems/src/dynamic_programming/ProfitableSchemes.java) (Hard)
 - [Maximum Vacation Days](problems/src/dynamic_programming/MaximumVacationDays.java) (Hard)
+- [Russian Doll Envelopes](problems/src/dynamic_programming/RussianDollEnvelopes.java) (Hard)
+- [Student Attendance Record II](problems/src/dynamic_programming/StudentAttendanceRecordII.java) (Hard)
+- [Out of Boundary Paths](problems/src/dynamic_programming/OutOfBoundaryPaths.java) (Medium)
 
 #### [Greedy](problems/src/greedy)
 
@@ -212,6 +222,8 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Lemonade Change](problems/src/greedy/LemonadeChange.java) (Easy)
 - [Score After Flipping Matrix](problems/src/greedy/ScoreAfterFlippingMatrix.java) (Medium)
 - [IPO](problems/src/greedy/IPO.java) (Hard)
+- [String Without AAA or BBB](problems/src/greedy/StringWithout3A3B.java) (Medium)
+- [Boats to Save People](problems/src/greedy/BoatsToSavePeople.java) (Medium)
 
 #### [Hashing](problems/src/hashing)
 
@@ -240,6 +252,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Candy](problems/src/heap/Candy.java) (Hard)
 - [Smallest Rotation with Highest Score](problems/src/heap/SmallestRotationWithHighestScore.java) (Hard)
 - [Maximum Frequency Stack](problems/src/heap/FreqStack.java) (Hard)
+- [Reachable Nodes In Subdivided Graph](problems/src/heap/ReachableNodesInSubdividedGraph.java) (Hard)
 
 #### [Linked List](problems/src/linked_list)
 
@@ -270,6 +283,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Reaching Points](problems/src/math/ReachingPoints.java) (Hard)
 - [Nth Magical Number](problems/src/math/NthMagicalNumber.java) (Hard)
 - [Squirrel Simulation](problems/src/math/SquirrelSimulation.java) (Medium)
+- [Projection Area of 3D Shapes](problems/src/math/ProjectionAreaOf3DShapes.java) (Easy)
 
 #### [Reservoir Sampling](problems/src/reservoir_sampling)
 
@@ -320,6 +334,10 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Replace Words](problems/src/string/ReplaceWords.java) (Medium)
 - [Rotate String](problems/src/string/RotateString.java) (Easy)
 - [Keyboard Row](problems/src/string/KeyboardRow.java) (Easy)
+- [Student Attendance Record I](problems/src/string/StudentAttendanceRecordI.java) (Easy)
+- [Split Concatenated Strings](problems/src/string/SplitConcatenatedStrings.java) (Medium)
+- [Valid Word Square](problems/src/string/ValidWordSquare.java) (Easy)
+- [Reconstruct Original Digits from English](problems/src/string/ReconstructOriginalDigitsFromEnglish.java) (Medium)
 
 #### [Tree](problems/src/tree)
 

problems/src/array/MaxConsecutiveOnes.java

@@ -0,0 +1,37 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 08/05/2019 Given a binary array, find the maximum number of
+ * consecutive 1s in this array.
+ *
+ * <p>Example 1: Input: [1,1,0,1,1,1] Output: 3 Explanation: The first two digits or the last three
+ * digits are consecutive 1s. The maximum number of consecutive 1s is 3. Note:
+ *
+ * <p>The input array will only contain 0 and 1. The length of input array is a positive integer and
+ * will not exceed 10,000
+ */
+public class MaxConsecutiveOnes {
+  public static void main(String[] args) {
+    //
+  }
+
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int max = 0;
+        boolean flag = false;
+        int count = 0;
+        for(int i = 0; i < nums.length; i ++){
+            if(nums[i] == 1){
+                if(!flag){
+                    flag = true;
+                }
+                count++;
+                max = Math.max(max, count);
+            } else{
+                count = 0;
+                flag = false;
+            }
+        }
+        return max;
+    }
+
+}

problems/src/array/MaxConsecutiveOnesII.java

@@ -0,0 +1,72 @@
+package array;
+
+/**
+ * Created by gouthamvidyapradhan on 08/05/2019 Given a binary array, find the maximum number of
+ * consecutive 1s in this array if you can flip at most one 0.
+ *
+ * <p>Example 1: Input: [1,0,1,1,0] Output: 4 Explanation: Flip the first zero will get the the
+ * maximum number of consecutive 1s. After flipping, the maximum number of consecutive 1s is 4.
+ * Note:
+ *
+ * <p>The input array will only contain 0 and 1. The length of input array is a positive integer and
+ * will not exceed 10,000 Follow up: What if the input numbers come in one by one as an infinite
+ * stream? In other words, you can't store all numbers coming from the stream as it's too large to
+ * hold in memory. Could you solve it efficiently?
+ *
+ * Solution: O(N)
+ * Maintain a left and right auxiliary array with counts of contagious 1's from both directions.
+ * Now, iterate through the array and flip a 0 to 1 and sum up left and right contagious sum of 1's and return the
+ * max sum as the answer
+ */
+public class MaxConsecutiveOnesII {
+  public static void main(String[] args) {
+    //
+  }
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int[] L = new int[nums.length];
+        int[] R = new int[nums.length];
+        boolean flag = false;
+        int count = 0;
+        int max = 0;
+        for(int j = 0; j < nums.length; j ++){
+            if(nums[j] == 1){
+                if(!flag){
+                    flag = true;
+                }
+                count++;
+                L[j] = count;
+            } else{
+                count = 0;
+                flag = false;
+                L[j] = count;
+            }
+            max = Math.max(max, count);
+        }
+
+        flag = false;
+        count = 0;
+        for(int j = nums.length - 1; j >= 0; j --){
+            if(nums[j] == 1){
+                if(!flag){
+                    flag = true;
+                }
+                count++;
+                R[j] = count;
+            } else{
+                count = 0;
+                flag = false;
+                R[j] = count;
+            }
+        }
+
+        for(int i = 0; i < nums.length; i ++){
+            if(nums[i] == 0){
+                int l = i == 0 ? 0 : L[i - 1];
+                int r = i == nums.length - 1 ? 0 : R[i + 1];
+                max = Math.max(max, l + r + 1);
+            }
+        }
+        return max;
+    }
+
+}

problems/src/backtracking/MatchsticksToSquare.java

@@ -0,0 +1,112 @@
+package backtracking;
+import java.util.*;
+/**
+ * Created by gouthamvidyapradhan on 25/05/2019 Remember the story of Little Match Girl? By now, you
+ * know exactly what matchsticks the little match girl has, please find out a way you can make one
+ * square by using up all those matchsticks. You should not break any stick, but you can link them
+ * up, and each matchstick must be used exactly one time.
+ *
+ * <p>Your input will be several matchsticks the girl has, represented with their stick length. Your
+ * output will either be true or false, to represent whether you could make one square using all the
+ * matchsticks the little match girl has.
+ *
+ * <p>Example 1: Input: [1,1,2,2,2] Output: true
+ *
+ * <p>Explanation: You can form a square with length 2, one side of the square came two sticks with
+ * length 1. Example 2: Input: [3,3,3,3,4] Output: false
+ *
+ * <p>Explanation: You cannot find a way to form a square with all the matchsticks. Note: The length
+ * sum of the given matchsticks is in the range of 0 to 10^9. The length of the given matchstick
+ * array will not exceed 15.
+ *
+ * Solution: O(2 ^ N): Generate a power set of all combination of numbers for the given array which sum up to the
+ * length of a side of square.
+ * Now, to check if a square can be made using all the sides sticks of different length, generate a hash for for each of
+ * the combination which was generated in the previous step. The hash function should be such that it uses unique
+ * indexes of each match stick. If 4 different hash values are formed using unique and all indices then a square is
+ * possible.
+ */
+public class MatchsticksToSquare {
+    /**
+     * Main method
+     * @param args
+     */
+  public static void main(String[] args) {
+      int[] A = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 6, 10, 10};
+    System.out.println(new MatchsticksToSquare().makesquare(A));
+  }
+
+    class Pair {
+        int value, i;
+        Pair(int value, int i){
+            this.value = value;
+            this.i = i;
+        }
+    }
+
+    public boolean makesquare(int[] nums) {
+      if(nums.length == 0) return false;
+        int sum = 0;
+        for(int n : nums){
+            sum += n;
+        }
+        int side = sum / 4;
+        if((sum % 4) != 0) return false;
+        List<List<Pair>> list = powerSet(nums, side);
+        Set<Integer> hashIndex = new HashSet<>();
+        int cons = 0;
+        for(int i = 0; i < nums.length; i ++){
+            cons |= (1 << i);
+        }
+        for(int i = 0; i < list.size(); i ++){
+          for(int j = i + 1; j < list.size(); j ++){
+            Set<Integer> indexList = new HashSet<>();
+            List<Pair> list1 =  list.get(i);
+            List<Pair> list2 =  list.get(j);
+            int hash = 0;
+            for(Pair l1 : list1){
+                indexList.add(l1.i);
+                hash |= (1 << l1.i);
+            }
+            boolean allUnique = true;
+            for(Pair l2 : list2){
+                if(indexList.contains(l2.i)) {
+                    allUnique = false;
+                    break;
+                }
+                indexList.add(l2.i);
+                hash |= (1 << l2.i);
+            }
+            if(allUnique){
+                hashIndex.add(hash);
+                int complement = ((~ hash) & cons);
+                if(hashIndex.contains(complement)) return true;
+            }
+          }
+      }
+      return false;
+    }
+
+    private List<List<Pair>> powerSet(int[] nums, int expectedSum){
+      List<List<Pair>> result = new ArrayList<>();
+      generate(0, nums, new ArrayList<>(), result, 0, expectedSum);
+      return result;
+    }
+
+    private void generate(int i, int[] nums, List<Pair> subList, List<List<Pair>> result, int sum,
+                          int expected){
+      if(i >= nums.length){
+          if(sum == expected){
+              List<Pair> pairs = new ArrayList<>(subList);
+              result.add(pairs);
+          }
+      } else{
+          if(sum + nums[i] <= expected){
+              subList.add(new Pair(nums[i], i));
+              generate(i + 1, nums, subList, result, sum + nums[i], expected);
+              subList.remove(subList.size() - 1);
+          }
+          generate(i + 1, nums, subList, result, sum, expected);
+      }
+    }
+}