733_Flood_Fill

Author: qiyuangong

README.md

@@ -161,6 +161,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 716 | [Max Stack](https://leetcode.com/problems/max-stack/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/716_Max_Stack.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/716_Max_Stack.java) | 1. Two stacks<br> 2. Double linked list and Hash |
 | 720 | [Longest Word in Dictionary](https://leetcode.com/problems/longest-word-in-dictionary/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/720_Longest_Word_in_Dictionary.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/720_Longest_Word_in_Dictionary.java) | 1. Brute Force, O(sum(w^2)) and O(w)<br>2. Tire Tree, O(sum(w) and O(w))<br>3. Sort and word without last char, O(nlogn + sum(w)) and O(w) |
 | 724 | [Find Pivot Index](https://leetcode.com/problems/find-pivot-index/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/724_Find_Pivot_Index.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/724_Find_Pivot_Index.java) | Seach the array to find a place where left sum is equal to right sum, O(n) and O(1) |
+| 733 | [Flood Fill](https://leetcode.com/problems/flood-fill/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/733_Flood_Fill.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/733_Flood_Fill.java) | 1. DFS with stack or recursive, O(n) and O(n)<br>2. BFS with queue, O(n) and O(n) |
 | 743 | [Network Delay Time](https://leetcode.com/problems/network-delay-time/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/743_Network_Delay_Time.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/743_Network_Delay_Time.java) | Let V == N, then: 1. DFS, O(V^V+ElgE), O(V+E)<br>2. Dijkstra, O(V^2+E), O(V+E)|
 | 771 | [Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/771_Jewels_and_Stones.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/771_Jewels_and_Stones.java) | Count given char in string. Hash or table. [Oneline](https://leetcode.com/problems/jewels-and-stones/discuss/113574/1-liners-PythonJavaRuby) |
 | 804 | [Unique Morse Code Words](https://leetcode.com/problems/unique-morse-code-words/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/804_Unique_Morse_Code_Words.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/804_Unique_Morse_Code_Words.java) | String, Hash and Set. Set is recommended. |

java/733_Flood_Fill.java

@@ -0,0 +1,48 @@
+class Solution {
+    /*public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        if (image[sr][sc] == newColor) return image;
+        dfs(image, sr, sc, image[sr][sc], newColor);
+        return image;
+    }
+
+    private void dfs(int[][] image, int r, int c, int color, int newColor) {
+        // Recursively DFS
+        if (image[r][c] == color) {
+            image[r][c] = newColor;
+            if (r - 1 >= 0) dfs(image, r - 1, c, color, newColor);
+            if (r + 1 < image.length) dfs(image, r + 1, c, color, newColor);
+            if (c - 1 >= 0) dfs(image, r, c - 1, color, newColor);
+            if (c + 1 < image[0].length) dfs(image, r, c + 1, color, newColor);
+        }
+    }*/
+
+    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        Queue<Node> queue = new LinkedList<Node>();
+        int color = image[sr][sc];
+        if (color == newColor) return image;
+        queue.add(new Node(sr, sc));
+        // BFS with queue
+        while (!queue.isEmpty()) {
+            Node curr = queue.remove();
+            int r = curr.r, c = curr.c;
+            if (image[r][c] == color) {
+                image[r][c] = newColor;
+                if (r - 1 >= 0) queue.add(new Node(r - 1, c));
+                if (r + 1 < image.length) queue.add(new Node(r + 1, c));
+                if (c - 1 >= 0) queue.add(new Node(r, c - 1));
+                if (c + 1 < image[0].length) queue.add(new Node(r, c + 1));
+            }
+        }
+        return image;
+    }
+
+    class Node {
+        int r;
+        int c;
+
+        public Node(int r, int c) {
+            this.r = r;
+            this.c = c;
+        }
+    }
+}

python/733_Flood_Fill.py

@@ -0,0 +1,41 @@
+class Solution(object):
+    # def floodFill(self, image, sr, sc, newColor):
+    #     """
+    #     :type image: List[List[int]]
+    #     :type sr: int
+    #     :type sc: int
+    #     :type newColor: int
+    #     :rtype: List[List[int]]
+    #     """
+    #     r_ls, c_ls = len(image), len(image[0])
+    #     color = image[sr][sc]
+    #     if color == newColor:
+    #         return image
+
+    #     def dfs(r, c):
+    #         if image[r][c] == color:
+    #             image[r][c] = newColor
+    #             if r - 1 >= 0: dfs(r - 1, c)
+    #             if r + 1 < r_ls: dfs(r + 1, c)
+    #             if c - 1 >= 0: dfs(r, c - 1)
+    #             if c + 1 < c_ls: dfs(r, c + 1)
+
+    #     dfs(sr, sc)
+    #     return image
+
+    def floodFill(self, image, sr, sc, newColor):
+        # BFS with queue
+        r_ls, c_ls = len(image), len(image[0])
+        color = image[sr][sc]
+        if color == newColor:
+            return image
+        queue = [(sr, sc)]
+        while len(queue) > 0:
+            r, c = queue.pop(0)
+            if image[r][c] == color:
+                image[r][c] = newColor
+                if r - 1 >= 0: queue.append((r - 1, c))
+                if r + 1 < r_ls: queue.append((r + 1, c))
+                if c - 1 >= 0: queue.append((r, c - 1))
+                if c + 1 < c_ls: queue.append((r, c + 1))
+        return image