feat: add solutions to lc problems: No.0934,2271

* No.0934.Shortest Bridge
* No.2271.Maximum White Tiles Covered by a Carpet

Author: yanglbme

lcci/03.03.Stack of Plates/Solution.py

@@ -1,5 +1,4 @@
 class StackOfPlates:
-
     def __init__(self, cap: int):
         self.cap = cap
         self.stk = []

solution/0900-0999/0934.Shortest Bridge/README.md

@@ -56,9 +56,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-DFS & BFS。
+**方法一：DFS + BFS**
 
-先通过 DFS 将其中一个岛屿的所有 1 置为 2，并将这个岛屿所有坐标点放入队列中；然后通过 BFS 一层层向外扩散，直至碰到另一个岛屿。
+题目求解的是最小翻转次数，使得两个岛屿相连，实际上等价于求解两个岛屿之间的最短距离。
+
+因此，我们可以先通过 DFS 将其中一个岛屿的所有点找出来，放到一个队列 $q$ 中。然后通过 BFS 一层层向外扩展，直至碰到另一个岛屿，此时将当前扩展的层数作为答案返回即可。
+
+在 DFS 和 BFS 搜索的过程中，我们直接将已经访问过的点标记为 $2$，这样就不会重复访问。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 为矩阵的行数或列数。
 
 <!-- tabs:start -->
 
@@ -69,39 +75,32 @@ DFS & BFS。
 ```python
 class Solution:
     def shortestBridge(self, grid: List[List[int]]) -> int:
-        def find():
-            for i in range(m):
-                for j in range(n):
-                    if grid[i][j] == 1:
-                        return i, j
-
         def dfs(i, j):
             q.append((i, j))
             grid[i][j] = 2
             for a, b in dirs:
                 x, y = i + a, j + b
-                if 0 <= x < m and 0 <= y < n and grid[x][y] == 1:
+                if 0 <= x < n and 0 <= y < n and grid[x][y] == 1:
                     dfs(x, y)
 
-        m, n = len(grid), len(grid[0])
+        n = len(grid)
+        dirs = ((0, 1), (0, -1), (1, 0), (-1, 0))
         q = deque()
-        dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]]
-        i, j = find()
+        i, j = next((i, j) for i in range(n) for j in range(n) if grid[i][j])
         dfs(i, j)
-        ans = -1
-        while q:
-            ans += 1
+        ans = 0
+        while 1:
             for _ in range(len(q)):
                 i, j = q.popleft()
                 for a, b in dirs:
                     x, y = i + a, j + b
-                    if 0 <= x < m and 0 <= y < n:
+                    if 0 <= x < n and 0 <= y < n:
                         if grid[x][y] == 1:
                             return ans
                         if grid[x][y] == 0:
                             grid[x][y] = 2
                             q.append((x, y))
-        return 0
+            ans += 1
 ```
 
 ### **Java**
@@ -110,27 +109,30 @@ class Solution:
 
 ```java
 class Solution {
-    private int[][] grid;
     private int[] dirs = {-1, 0, 1, 0, -1};
-    private int m;
+    private Deque<int[]> q = new ArrayDeque<>();
+    private int[][] grid;
     private int n;
 
     public int shortestBridge(int[][] grid) {
-        m = grid.length;
-        n = grid[0].length;
         this.grid = grid;
-        int[] start = find();
-        Queue<int[]> q = new LinkedList<>();
-        dfs(start[0], start[1], q);
-        int ans = -1;
-        while (!q.isEmpty()) {
-            ++ans;
-            for (int k = q.size(); k > 0; --k) {
-                int[] p = q.poll();
-                for (int i = 0; i < 4; ++i) {
-                    int x = p[0] + dirs[i];
-                    int y = p[1] + dirs[i + 1];
-                    if (x >= 0 && x < m && y >= 0 && y < n) {
+        n = grid.length;
+        for (int i = 0, x = 1; i < n && x == 1; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    dfs(i, j);
+                    x = 0;
+                    break;
+                }
+            }
+        }
+        int ans = 0;
+        while (true) {
+            for (int i = q.size(); i > 0; --i) {
+                var p = q.pollFirst();
+                for (int k = 0; k < 4; ++k) {
+                    int x = p[0] + dirs[k], y = p[1] + dirs[k + 1];
+                    if (x >= 0 && x < n && y >= 0 && y < n) {
                         if (grid[x][y] == 1) {
                             return ans;
                         }
@@ -141,140 +143,124 @@ class Solution {
                     }
                 }
             }
+            ++ans;
         }
-        return 0;
     }
 
-    private void dfs(int i, int j, Queue<int[]> q) {
+    private void dfs(int i, int j) {
         grid[i][j] = 2;
         q.offer(new int[] {i, j});
         for (int k = 0; k < 4; ++k) {
-            int x = i + dirs[k];
-            int y = j + dirs[k + 1];
-            if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1) {
-                dfs(x, y, q);
-            }
-        }
-    }
-
-    private int[] find() {
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                if (grid[i][j] == 1) {
-                    return new int[] {i, j};
-                }
+            int x = i + dirs[k], y = j + dirs[k + 1];
+            if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 1) {
+                dfs(x, y);
             }
         }
-        return new int[] {0, 0};
     }
 }
 ```
 
 ### **C++**
 
 ```cpp
+using pii = pair<int, int>;
+
 class Solution {
 public:
-    vector<int> dirs = {-1, 0, 1, 0, -1};
+    const static inline vector<int> dirs = {-1, 0, 1, 0, -1};
 
     int shortestBridge(vector<vector<int>>& grid) {
-        vector<int> start = find(grid);
-        queue<vector<int>> q;
-        dfs(start[0], start[1], q, grid);
-        int ans = -1;
-        while (!q.empty()) {
-            ++ans;
-            for (int k = q.size(); k > 0; --k) {
-                auto p = q.front();
+        int n = grid.size();
+        queue<pii> q;
+        function<void(int, int)> dfs = [&](int i, int j) {
+            grid[i][j] = 2;
+            q.emplace(i, j);
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 1) {
+                    dfs(x, y);
+                }
+            }
+        };
+        for (int i = 0, x = 1; i < n && x; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j]) {
+                    dfs(i, j);
+                    x = 0;
+                    break;
+                }
+            }
+        }
+        int ans = 0;
+        while (1) {
+            for (int k = q.size(); k; --k) {
+                auto [i, j] = q.front();
                 q.pop();
-                for (int i = 0; i < 4; ++i) {
-                    int x = p[0] + dirs[i];
-                    int y = p[1] + dirs[i + 1];
-                    if (x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size()) {
+                for (int h = 0; h < 4; ++h) {
+                    int x = i + dirs[h], y = j + dirs[h + 1];
+                    if (x >= 0 && x < n && y >= 0 && y < n) {
                         if (grid[x][y] == 1) return ans;
                         if (grid[x][y] == 0) {
                             grid[x][y] = 2;
-                            q.push({x, y});
+                            q.emplace(x, y);
                         }
                     }
                 }
             }
-        }
-        return 0;
-    }
-
-    void dfs(int i, int j, queue<vector<int>>& q, vector<vector<int>>& grid) {
-        grid[i][j] = 2;
-        q.push({i, j});
-        for (int k = 0; k < 4; ++k) {
-            int x = i + dirs[k];
-            int y = j + dirs[k + 1];
-            if (x >= 0 && x < grid.size() && y >= 0 && y < grid[0].size() && grid[x][y] == 1)
-                dfs(x, y, q, grid);
+            ++ans;
         }
     }
-
-    vector<int> find(vector<vector<int>>& grid) {
-        for (int i = 0; i < grid.size(); ++i)
-            for (int j = 0; j < grid[0].size(); ++j)
-                if (grid[i][j] == 1)
-                    return {i, j};
-        return {0, 0};
-    }
 };
 ```
 
 ### **Go**
 
 ```go
 func shortestBridge(grid [][]int) int {
-	m, n := len(grid), len(grid[0])
-	find := func() []int {
-		for i := 0; i < m; i++ {
-			for j := 0; j < n; j++ {
-				if grid[i][j] == 1 {
-					return []int{i, j}
-				}
-			}
-		}
-		return []int{0, 0}
-	}
-	start := find()
-	var q [][]int
+	n := len(grid)
 	dirs := []int{-1, 0, 1, 0, -1}
-	var dfs func(i, j int)
+	type pair struct{ i, j int }
+	q := []pair{}
+	var dfs func(int, int)
 	dfs = func(i, j int) {
 		grid[i][j] = 2
-		q = append(q, []int{i, j})
+		q = append(q, pair{i, j})
 		for k := 0; k < 4; k++ {
 			x, y := i+dirs[k], j+dirs[k+1]
-			if x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 {
+			if x >= 0 && x < n && y >= 0 && y < n && grid[x][y] == 1 {
 				dfs(x, y)
 			}
 		}
 	}
-	dfs(start[0], start[1])
-	ans := -1
-	for len(q) > 0 {
-		ans++
-		for k := len(q); k > 0; k-- {
+	for i, x := 0, 1; i < n && x == 1; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				dfs(i, j)
+				x = 0
+				break
+			}
+		}
+	}
+	ans := 0
+	for {
+		for i := len(q); i > 0; i-- {
 			p := q[0]
 			q = q[1:]
-			for i := 0; i < 4; i++ {
-				x, y := p[0]+dirs[i], p[1]+dirs[i+1]
-				if x >= 0 && x < m && y >= 0 && y < n {
+			for k := 0; k < 4; k++ {
+				x, y := p.i+dirs[k], p.j+dirs[k+1]
+				if x >= 0 && x < n && y >= 0 && y < n {
 					if grid[x][y] == 1 {
 						return ans
 					}
 					if grid[x][y] == 0 {
 						grid[x][y] = 2
-						q = append(q, []int{x, y})
+						q = append(q, pair{x, y})
 					}
 				}
 			}
 		}
+		ans++
 	}
-	return 0
 }
 ```