605_Can_Place_Flowers

qiyuangong · qiyuangong · commit fea38e6a6c54 · 2018-12-08T12:10:03.000+08:00
diff --git a/README.md b/README.md
@@ -153,6 +153,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 557 | [Reverse Words in a String III](https://leetcode.com/problems/reverse-words-in-a-string-iii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/557_Reverse_Words_in_a_String_III.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/557_Reverse_Words_in_a_String_III.java) | String handle: Split with space than reverse word, O(n) and O(n). Better solution is that reverse can be O(1) space in array. |
 | 572 | [Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/572_Subtree_of_Another_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/572_Subtree_of_Another_Tree.java) | 1. Tree traverse and compare<br>2. Tree to string and compare |
 | 581 | [Shortest Unsorted Continuous Subarray](https://leetcode.com/problems/subtree-of-another-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/581_Shortest_Unsorted_Continuous_Subarray.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/581_Shortest_Unsorted_Continuous_Subarray.java) | 1. Sort and find the difference (min and max), O(nlgn)<br>2. Using stack to find boundaries (push when correct order, pop when not correct), O(n) and O(n)<br>3. Find min and max of unordered array, O(n) and O(1)|
+| 605 | [Can Place Flowers](https://leetcode.com/problems/can-place-flowers/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/605_Can_Place_Flowers.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/605_Can_Place_Flowers.java) | One time scan, check [i-1] [i] and [i+1], O(n) and O(1) |
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 628 | [Maximum Product of Three Numbers](https://leetcode.com/problems/maximum-product-of-three-numbers/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/628_Maximum_Product_of_Three_Numbers.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/628_Maximum_Product_of_Three_Numbers.java) | Actually, we should only care about min1, min2 and max1-max3, to find these five elements, we can use 1. Brute force, O(n^3) and O(1)<br>2. Sort, O(nlogn) and O(1)<br>3. Single scan with 5 elements keep, O(n) and O(1) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
diff --git a/java/605_Can_Place_Flowers.java b/java/605_Can_Place_Flowers.java
@@ -0,0 +1,29 @@
+public class Solution {
+    /*public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        int i = 0, count = 0;
+        while (i < flowerbed.length) {
+            if (flowerbed[i] == 0 && (i == 0 || flowerbed[i - 1] == 0) && (i == flowerbed.length - 1 || flowerbed[i + 1] == 0)) {
+                flowerbed[i++] = 1;
+                count++;
+            }
+             if(count >= n)
+                return true;
+            i++;
+        }
+        return false;
+    }*/
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        int count = 0, curr;
+        for (int i = 0; i < flowerbed.length; i++) {
+            curr = flowerbed[i];
+            if (i - 1 >= 0) curr += flowerbed[i - 1];
+            if (i + 1 < flowerbed.length) curr += flowerbed[i + 1];
+            if (curr == 0) {
+                count++;
+                flowerbed[i] = 1;
+            }
+            if (count >= n) return true;
+        }
+        return false;
+    }
+}
diff --git a/python/605_Can_Place_Flowers.py b/python/605_Can_Place_Flowers.py
@@ -0,0 +1,20 @@
+class Solution(object):
+    def canPlaceFlowers(self, flowerbed, n):
+        """
+        :type flowerbed: List[int]
+        :type n: int
+        :rtype: bool
+        """
+        count = 0
+        for i in range(len(flowerbed)):
+            curr = flowerbed[i]
+            if i - 1 >= 0:
+                curr += flowerbed[i - 1]
+            if i + 1 < len(flowerbed):
+                curr += flowerbed[i + 1]
+            if curr == 0:
+                count += 1
+                flowerbed[i] = 1
+                if count >= n:
+                    return True
+        return False
