598.zombie-in-matrix

Author: geemaple

README.md

@@ -416,6 +416,7 @@ This is a **continually updated, open source** project.
 | 589.connecting-graph | [cpp](./lintcode/589.connecting-graph.cpp), [python](./lintcode/589.connecting-graph.py) | O(1) | O(N) | Medium | union-find
 | 590.connecting-graph-ii | [cpp](./lintcode/590.connecting-graph-ii.cpp), [python](./lintcode/590.connecting-graph-ii.py) | O(1) | O(N) | Medium | union-find
 | 591.connecting-graph-iii | [cpp](./lintcode/591.connecting-graph-iii.cpp), [python](./lintcode/591.connecting-graph-iii.py) | O(1) | O(N) | Medium | union-find
+| 598.zombie-in-matrix | [cpp](./lintcode/598.zombie-in-matrix.cpp), [python](./lintcode/598.zombie-in-matrix.py) | O(M * N) | O(M * N) | Medium | graph-traversal
 | 618.search-graph-nodes | [cpp](./lintcode/618.search-graph-nodes.cpp), [python](./lintcode/618.search-graph-nodes.py) | O(V + E) | O(V) | Medium | tree-traversal
 | 629.minimum-spanning-tree | [cpp](./lintcode/629.minimum-spanning-tree.cpp), [python](./lintcode/629.minimum-spanning-tree.py) | O(N * logN) | O(N) | Hard | union-find | Prim, Kruskal
 | 652.factorization | [cpp](./lintcode/652.factorization.cpp), [python](./lintcode/652.factorization.py) | O(N) | O(LogN) | Medium/S++ | N = input number

lintcode/598.zombie-in-matrix.cpp

@@ -0,0 +1,76 @@
+class Solution {
+    
+private:
+    vector<vector<int>> directions = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};
+    
+    bool in_bound(vector<vector<int>> &grid, int x, int y)
+    {
+        return x >= 0 && x < grid.size() && y >= 0 && y < grid[x].size();
+    }
+    
+    int convert(vector<vector<int>> &grid, int x, int y)
+    {
+        return x * grid[x].size() + y;
+    }
+    
+public:
+    /**
+     * @param grid: a 2D integer grid
+     * @return: an integer
+     */
+    int zombie(vector<vector<int>> &grid) {
+        // write your code here
+        
+        int peopel_count = 0;
+        queue<pair<int, int>> q;
+        unordered_set<int> visited;
+        
+        for (auto i = 0; i < grid.size(); ++i)
+        {
+            for (auto j = 0; j < grid[i].size(); ++j)
+            {
+                if (grid[i][j] == 0)
+                {
+                    peopel_count++;
+                    continue;
+                }
+                
+                if (grid[i][j] == 1)
+                {
+                    q.push(make_pair(i, j));
+                    visited.insert(convert(grid, i, j));
+                }
+            }
+        }
+        
+        int days = 0;
+        while(!q.empty() && peopel_count > 0)
+        {
+            int size = q.size();
+            for (auto i = 0; i < size; ++i)
+            {
+                pair<int, int>tmp = q.front();
+                q.pop();
+                
+                for (auto i = 0; i < 4; ++i)
+                {
+                    int new_x = tmp.first + directions[i][0];
+                    int new_y = tmp.second + directions[i][1];
+                    int point = convert(grid, new_x, new_y);
+                    
+                    if (in_bound(grid, new_x, new_y) && grid[new_x][new_y] == 0 && visited.count(point) == 0)
+                    {
+                        visited.insert(point);
+                        q.push(make_pair(new_x, new_y));
+                        grid[new_x][new_y] = 1;
+                        peopel_count--;
+                    }
+                }
+            }
+        
+            days++;
+        }
+        
+        return peopel_count == 0 ? days : -1;
+    }
+};

lintcode/598.zombie-in-matrix.py

@@ -0,0 +1,45 @@
+class Solution:
+    """
+    @param grid: a 2D integer grid
+    @return: an integer
+    """
+    def zombie(self, grid):
+        # write your code here
+        people = 0
+        visited = set()
+        q = []
+        
+        for i in range(len(grid)):
+            for j in range(len(grid[i])):
+                if grid[i][j] == 0:
+                    people += 1
+        
+                if grid[i][j] == 1:
+                    q.append((i, j))
+                    visited.add((i, j))
+                    
+        
+        directions = [[0, -1], [-1, 0], [0, 1], [1, 0]]
+
+        days = 0
+        while people > 0 and len(q) > 0:
+            size = len(q)
+            
+            for _ in range(size):
+                tmp = q.pop(0)
+                
+                for j in range(4):
+                    new_x = tmp[0] + directions[j][0]
+                    new_y = tmp[1] + directions[j][1]
+                    
+                    if self.in_bounds(grid, new_x, new_y) and grid[new_x][new_y] == 0 and (new_x, new_y) not in visited:
+                        visited.add((new_x, new_y))
+                        q.append((new_x, new_y))
+                        grid[new_x][new_y] = 1
+                        people -= 1
+        
+            days += 1
+        return days if people == 0 else -1
+        
+    def in_bounds(self, grid, x, y):
+        return 0 <= x < len(grid) and 0 <= y < len(grid[x])