@@ -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/SubArraysWitundedMaximum.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)
 - [ing the Safe](problems/src/depth_first_search/ingTheSafe.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)
 

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

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

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