feat: add solutions to lc problem: No.0417 (#4764)

Author: yanglbme

solution/0400-0499/0417.Pacific Atlantic Water Flow/README.md

@@ -1,60 +1,48 @@
-typedef pair<int, int> pii;
-
 class Solution {
 public:
-    vector<vector<int>> heights;
-    int m;
-    int n;
-
     vector<vector<int>> pacificAtlantic(vector<vector<int>>& heights) {
-        m = heights.size();
-        n = heights[0].size();
-        this->heights = heights;
-        queue<pii> q1;
-        queue<pii> q2;
-        unordered_set<int> vis1;
-        unordered_set<int> vis2;
+        int m = heights.size(), n = heights[0].size();
+        vector<vector<bool>> vis1(m, vector<bool>(n, false)), vis2(m, vector<bool>(n, false));
+        queue<pair<int, int>> q1, q2;
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+
         for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                if (i == 0 || j == 0) {
-                    vis1.insert(i * n + j);
-                    q1.emplace(i, j);
-                }
-                if (i == m - 1 || j == n - 1) {
-                    vis2.insert(i * n + j);
-                    q2.emplace(i, j);
-                }
-            }
+            q1.emplace(i, 0);
+            vis1[i][0] = true;
+            q2.emplace(i, n - 1);
+            vis2[i][n - 1] = true;
         }
-        bfs(q1, vis1);
-        bfs(q2, vis2);
-        vector<vector<int>> ans;
-        for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = i * n + j;
-                if (vis1.count(x) && vis2.count(x)) {
-                    ans.push_back({i, j});
-                }
-            }
+        for (int j = 0; j < n; ++j) {
+            q1.emplace(0, j);
+            vis1[0][j] = true;
+            q2.emplace(m - 1, j);
+            vis2[m - 1][j] = true;
         }
-        return ans;
-    }
 
-    void bfs(queue<pii>& q, unordered_set<int>& vis) {
-        vector<int> dirs = {-1, 0, 1, 0, -1};
-        while (!q.empty()) {
-            for (int k = q.size(); k > 0; --k) {
-                auto p = q.front();
+        auto bfs = [&](queue<pair<int, int>>& q, vector<vector<bool>>& vis) {
+            while (!q.empty()) {
+                auto [x, y] = q.front();
                 q.pop();
-                for (int i = 0; i < 4; ++i) {
-                    int x = p.first + dirs[i];
-                    int y = p.second + dirs[i + 1];
-                    if (x >= 0 && x < m && y >= 0 && y < n && !vis.count(x * n + y) && heights[x][y] >= heights[p.first][p.second]) {
-                        vis.insert(x * n + y);
-                        q.emplace(x, y);
+                for (int k = 0; k < 4; ++k) {
+                    int nx = x + dirs[k], ny = y + dirs[k + 1];
+                    if (nx >= 0 && nx < m && ny >= 0 && ny < n
+                        && !vis[nx][ny]
+                        && heights[nx][ny] >= heights[x][y]) {
+                        vis[nx][ny] = true;
+                        q.emplace(nx, ny);
                     }
                 }
             }
-        }
+        };
+
+        bfs(q1, vis1);
+        bfs(q2, vis2);
+
+        vector<vector<int>> ans;
+        for (int i = 0; i < m; ++i)
+            for (int j = 0; j < n; ++j)
+                if (vis1[i][j] && vis2[i][j])
+                    ans.push_back({i, j});
+        return ans;
     }
-};
+};

solution/0400-0499/0417.Pacific Atlantic Water Flow/README_EN.md

@@ -1,47 +1,52 @@
 func pacificAtlantic(heights [][]int) [][]int {
 	m, n := len(heights), len(heights[0])
-	vis1 := make(map[int]bool)
-	vis2 := make(map[int]bool)
-	var q1 [][]int
-	var q2 [][]int
+	vis1 := make([][]bool, m)
+	vis2 := make([][]bool, m)
+	for i := range vis1 {
+		vis1[i] = make([]bool, n)
+		vis2[i] = make([]bool, n)
+	}
+	q1, q2 := [][2]int{}, [][2]int{}
+	dirs := [5]int{-1, 0, 1, 0, -1}
+
 	for i := 0; i < m; i++ {
-		for j := 0; j < n; j++ {
-			if i == 0 || j == 0 {
-				vis1[i*n+j] = true
-				q1 = append(q1, []int{i, j})
-			}
-			if i == m-1 || j == n-1 {
-				vis2[i*n+j] = true
-				q2 = append(q2, []int{i, j})
-			}
-		}
+		q1 = append(q1, [2]int{i, 0})
+		vis1[i][0] = true
+		q2 = append(q2, [2]int{i, n - 1})
+		vis2[i][n-1] = true
+	}
+	for j := 0; j < n; j++ {
+		q1 = append(q1, [2]int{0, j})
+		vis1[0][j] = true
+		q2 = append(q2, [2]int{m - 1, j})
+		vis2[m-1][j] = true
 	}
-	dirs := []int{-1, 0, 1, 0, -1}
-	bfs := func(q [][]int, vis map[int]bool) {
+
+	bfs := func(q [][2]int, vis [][]bool) {
 		for len(q) > 0 {
-			for k := len(q); k > 0; k-- {
-				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 && !vis[x*n+y] && heights[x][y] >= heights[p[0]][p[1]] {
-						vis[x*n+y] = true
-						q = append(q, []int{x, y})
-					}
+			x, y := q[0][0], q[0][1]
+			q = q[1:]
+			for k := 0; k < 4; k++ {
+				nx, ny := x+dirs[k], y+dirs[k+1]
+				if nx >= 0 && nx < m && ny >= 0 && ny < n &&
+					!vis[nx][ny] && heights[nx][ny] >= heights[x][y] {
+					vis[nx][ny] = true
+					q = append(q, [2]int{nx, ny})
 				}
 			}
 		}
 	}
+
 	bfs(q1, vis1)
 	bfs(q2, vis2)
+
 	var ans [][]int
 	for i := 0; i < m; i++ {
 		for j := 0; j < n; j++ {
-			x := i*n + j
-			if vis1[x] && vis2[x] {
+			if vis1[i][j] && vis2[i][j] {
 				ans = append(ans, []int{i, j})
 			}
 		}
 	}
 	return ans
-}
+}

solution/0400-0499/0417.Pacific Atlantic Water Flow/Solution.cpp

@@ -1,57 +1,51 @@
 class Solution {
-    private int[][] heights;
-    private int m;
-    private int n;
-
     public List<List<Integer>> pacificAtlantic(int[][] heights) {
-        m = heights.length;
-        n = heights[0].length;
-        this.heights = heights;
-        Deque<int[]> q1 = new LinkedList<>();
-        Deque<int[]> q2 = new LinkedList<>();
-        Set<Integer> vis1 = new HashSet<>();
-        Set<Integer> vis2 = new HashSet<>();
+        int m = heights.length, n = heights[0].length;
+        boolean[][] vis1 = new boolean[m][n];
+        boolean[][] vis2 = new boolean[m][n];
+        Deque<int[]> q1 = new ArrayDeque<>();
+        Deque<int[]> q2 = new ArrayDeque<>();
+        int[] dirs = {-1, 0, 1, 0, -1};
+
         for (int i = 0; i < m; ++i) {
-            for (int j = 0; j < n; ++j) {
-                if (i == 0 || j == 0) {
-                    vis1.add(i * n + j);
-                    q1.offer(new int[] {i, j});
-                }
-                if (i == m - 1 || j == n - 1) {
-                    vis2.add(i * n + j);
-                    q2.offer(new int[] {i, j});
+            q1.offer(new int[] {i, 0});
+            vis1[i][0] = true;
+            q2.offer(new int[] {i, n - 1});
+            vis2[i][n - 1] = true;
+        }
+        for (int j = 0; j < n; ++j) {
+            q1.offer(new int[] {0, j});
+            vis1[0][j] = true;
+            q2.offer(new int[] {m - 1, j});
+            vis2[m - 1][j] = true;
+        }
+
+        BiConsumer<Deque<int[]>, boolean[][]> bfs = (q, vis) -> {
+            while (!q.isEmpty()) {
+                var cell = q.poll();
+                int x = cell[0], y = cell[1];
+                for (int k = 0; k < 4; ++k) {
+                    int nx = x + dirs[k], ny = y + dirs[k + 1];
+                    if (nx >= 0 && nx < m && ny >= 0 && ny < n && !vis[nx][ny]
+                        && heights[nx][ny] >= heights[x][y]) {
+                        vis[nx][ny] = true;
+                        q.offer(new int[] {nx, ny});
+                    }
                 }
             }
-        }
-        bfs(q1, vis1);
-        bfs(q2, vis2);
+        };
+
+        bfs.accept(q1, vis1);
+        bfs.accept(q2, vis2);
+
         List<List<Integer>> ans = new ArrayList<>();
         for (int i = 0; i < m; ++i) {
             for (int j = 0; j < n; ++j) {
-                int x = i * n + j;
-                if (vis1.contains(x) && vis2.contains(x)) {
-                    ans.add(Arrays.asList(i, j));
+                if (vis1[i][j] && vis2[i][j]) {
+                    ans.add(List.of(i, j));
                 }
             }
         }
         return ans;
     }
-
-    private void bfs(Deque<int[]> q, Set<Integer> vis) {
-        int[] dirs = {-1, 0, 1, 0, -1};
-        while (!q.isEmpty()) {
-            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 && !vis.contains(x * n + y)
-                        && heights[x][y] >= heights[p[0]][p[1]]) {
-                        vis.add(x * n + y);
-                        q.offer(new int[] {x, y});
-                    }
-                }
-            }
-        }
-    }
-}
+}

solution/0400-0499/0417.Pacific Atlantic Water Flow/Solution.go

@@ -1,37 +1,39 @@
 class Solution:
     def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
-        def bfs(q, vis):
+        def bfs(q: Deque[Tuple[int, int]], vis: List[List[bool]]) -> None:
             while q:
-                for _ in range(len(q)):
-                    i, j = q.popleft()
-                    for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
-                        x, y = i + a, j + b
-                        if (
-                            0 <= x < m
-                            and 0 <= y < n
-                            and (x, y) not in vis
-                            and heights[x][y] >= heights[i][j]
-                        ):
-                            vis.add((x, y))
-                            q.append((x, y))
+                x, y = q.popleft()
+                for dx, dy in pairwise(dirs):
+                    nx, ny = x + dx, y + dy
+                    if (
+                        0 <= nx < m
+                        and 0 <= ny < n
+                        and not vis[nx][ny]
+                        and heights[nx][ny] >= heights[x][y]
+                    ):
+                        vis[nx][ny] = True
+                        q.append((nx, ny))
 
         m, n = len(heights), len(heights[0])
-        vis1, vis2 = set(), set()
-        q1 = deque()
-        q2 = deque()
+        vis1 = [[False] * n for _ in range(m)]
+        vis2 = [[False] * n for _ in range(m)]
+        q1: Deque[Tuple[int, int]] = deque()
+        q2: Deque[Tuple[int, int]] = deque()
+        dirs = (-1, 0, 1, 0, -1)
+
         for i in range(m):
-            for j in range(n):
-                if i == 0 or j == 0:
-                    vis1.add((i, j))
-                    q1.append((i, j))
-                if i == m - 1 or j == n - 1:
-                    vis2.add((i, j))
-                    q2.append((i, j))
+            q1.append((i, 0))
+            vis1[i][0] = True
+            q2.append((i, n - 1))
+            vis2[i][n - 1] = True
+
+        for j in range(n):
+            q1.append((0, j))
+            vis1[0][j] = True
+            q2.append((m - 1, j))
+            vis2[m - 1][j] = True
+
         bfs(q1, vis1)
         bfs(q2, vis2)
-        return [
-            (i, j)
-            for i in range(m)
-            for j in range(n)
-            if (i, j) in vis1 and (i, j) in vis2
-        ]
+
+        return [(i, j) for i in range(m) for j in range(n) if vis1[i][j] and vis2[i][j]]