feat: add solutions to lc problem: No.0778

No.0778.Swim in Rising Water

Author: yanglbme

solution/0700-0799/0778.Swim in Rising Water/README.md

@@ -6,56 +6,57 @@
 
 <!-- 这里写题目描述 -->
 
-<p>在一个 N x N 的坐标方格 <code>grid</code> 中，每一个方格的值 <code>grid[i][j]</code> 表示在位置 <code>(i,j)</code> 的平台高度。</p>
+<p>在一个 <code>n x n</code>&nbsp;的整数矩阵&nbsp;<code>grid</code> 中，每一个方格的值 <code>grid[i][j]</code> 表示位置 <code>(i, j)</code> 的平台高度。</p>
 
-<p>现在开始下雨了。当时间为 <code>t</code> 时，此时雨水导致水池中任意位置的水位为 <code>t</code> 。你可以从一个平台游向四周相邻的任意一个平台，但是前提是此时水位必须同时淹没这两个平台。假定你可以瞬间移动无限距离，也就是默认在方格内部游动是不耗时的。当然，在你游泳的时候你必须待在坐标方格里面。</p>
+<p>当开始下雨时，在时间为&nbsp;<code>t</code>&nbsp;时，水池中的水位为&nbsp;<code>t</code>&nbsp;。你可以从一个平台游向四周相邻的任意一个平台，但是前提是此时水位必须同时淹没这两个平台。假定你可以瞬间移动无限距离，也就是默认在方格内部游动是不耗时的。当然，在你游泳的时候你必须待在坐标方格里面。</p>
 
-<p>你从坐标方格的左上平台 (0，0) 出发。最少耗时多久你才能到达坐标方格的右下平台 <code>(N-1, N-1)</code>？</p>
+<p>你从坐标方格的左上平台&nbsp;<code>(0，0)</code> 出发。返回 <em>你到达坐标方格的右下平台&nbsp;<code>(n-1, n-1)</code>&nbsp;所需的最少时间 。</em></p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1:</strong></p>
 
+<p><img src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0700-0799/0778.Swim%20in%20Rising%20Water/images/swim1-grid.jpg" /></p>
+
 <pre>
-<strong>输入:</strong> [[0,2],[1,3]]
+<strong>输入:</strong> grid = [[0,2],[1,3]]
 <strong>输出:</strong> 3
 <strong>解释:</strong>
 时间为0时，你位于坐标方格的位置为 <code>(0, 0)。</code>
 此时你不能游向任意方向，因为四个相邻方向平台的高度都大于当前时间为 0 时的水位。
-
 等时间到达 3 时，你才可以游向平台 (1, 1). 因为此时的水位是 3，坐标方格中的平台没有比水位 3 更高的，所以你可以游向坐标方格中的任意位置
 </pre>
 
-<p><strong>示例2:</strong></p>
+<p><strong>示例 2:</strong></p>
+
+<p><img src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0700-0799/0778.Swim%20in%20Rising%20Water/images/swim2-grid-1.jpg" /></p>
 
 <pre>
-<strong>输入:</strong> [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
+<strong>输入:</strong> grid = [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]
 <strong>输出:</strong> 16
-<strong>解释:</strong>
-<strong> 0  1  2  3  4</strong>
-24 23 22 21  <strong>5</strong>
-<strong>12 13 14 15 16</strong>
-<strong>11</strong> 17 18 19 20
-<strong>10  9  8  7  6</strong>
-
-最终的路线用加粗进行了标记。
+<strong>解释: </strong>最终的路线用加粗进行了标记。
 我们必须等到时间为 16，此时才能保证平台 (0, 0) 和 (4, 4) 是连通的
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示:</strong></p>
 
-<ol>
-	<li><code>2 <= N <= 50</code>.</li>
-	<li><code>grid[i][j]</code> 是 <code>[0, ..., N*N - 1]</code> 的排列。</li>
-</ol>
+<ul>
+	<li><code>n == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 50</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;&nbsp;n<sup>2</sup></code></li>
+	<li><code>grid[i][j]</code>&nbsp;中每个值&nbsp;<strong>均无重复</strong></li>
+</ul>
 
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
-并查集。
+并查集。每经过一个时刻 t，找到此时和雨水高度相等的单元格 `(i, j)`，如果与 `(i, j)` 相邻的单元格 `(x, y)` 满足高度不超过 t，则将这两个单元格进行合并。如果在某个时刻合并之后，单元格 `(0, 0)` 与单元格 `(n - 1, n - 1)` 连通，则返回该时刻。
+
+以下是并查集的几个常用模板。
 
 模板 1——朴素并查集：
 
@@ -123,32 +124,25 @@ d[find(a)] = distance
 ```python
 class Solution:
     def swimInWater(self, grid: List[List[int]]) -> int:
-        n = len(grid)
-        p = list(range(n * n))
-
         def find(x):
             if p[x] != x:
                 p[x] = find(p[x])
             return p[x]
 
-        def index(i, j):
-            return i * n + j
-
-        def check(i, j):
-            return 0 <= i < n and 0 <= j < n
-
+        n = len(grid)
+        p = list(range(n * n))
         hi = [0] * (n * n)
-        for i in range(n):
-            for j in range(n):
-                hi[grid[i][j]] = index(i, j)
-        for h in range(n * n):
-            x, y = hi[h] // n, hi[h] % n
+        for i, row in enumerate(grid):
+            for j, h in enumerate(row):
+                hi[h] = i * n + j
+        for t in range(n * n):
+            i, j = hi[t] // n, hi[t] % n
             for a, b in [(0, -1), (0, 1), (1, 0), (-1, 0)]:
-                x1, y1 = x + a, y + b
-                if check(x1, y1) and grid[x1][y1] <= h:
-                    p[find(index(x1, y1))] = find(hi[h])
+                x, y = i + a, j + b
+                if 0 <= x < n and 0 <= y < n and grid[x][y] <= t:
+                    p[find(x * n + y)] = find(hi[t])
                 if find(0) == find(n * n - 1):
-                    return h
+                    return t
         return -1
 ```
 
@@ -159,30 +153,31 @@ class Solution:
 ```java
 class Solution {
     private int[] p;
-    private int n;
-    private int[][] dirs = new int[][]{{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
 
     public int swimInWater(int[][] grid) {
-        n = grid.length;
+        int n = grid.length;
         p = new int[n * n];
         for (int i = 0; i < p.length; ++i) {
             p[i] = i;
         }
         int[] hi = new int[n * n];
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < n; ++j) {
-                hi[grid[i][j]] = index(i, j);
+                hi[grid[i][j]] = i * n + j;
             }
         }
-        for (int h = 0; h < n * n; ++h) {
-            int x = hi[h] / n, y = hi[h] % n;
-            for (int[] dir : dirs) {
-                int x1 = x + dir[0], y1 = y + dir[1];
-                if (check(x1, y1) && grid[x1][y1] <= h) {
-                    p[find(index(x1, y1))] = find(hi[h]);
+        int[] dirs = {-1, 0, 1, 0, -1};
+        for (int t = 0; t < n * n; ++t) {
+            int i = hi[t] / n;
+            int j = hi[t] % n;
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k];
+                int y = j + dirs[k + 1];
+                if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] <= t) {
+                    p[find(x * n + y)] = find(i * n + j);
                 }
                 if (find(0) == find(n * n - 1)) {
-                    return h;
+                    return t;
                 }
             }
         }
@@ -195,14 +190,6 @@ class Solution {
         }
         return p[x];
     }
-
-    private int index(int i, int j) {
-        return i * n + j;
-    }
-
-    private boolean check(int i, int j) {
-        return i >= 0 && i < n && j >= 0 && j < n;
-    }
 }
 ```
 
@@ -246,96 +233,74 @@ function swimInWater(grid: number[][]): number {
 class Solution {
 public:
     vector<int> p;
-    int n;
-    int dirs[4][2] = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
-
-    int swimInWater(vector<vector<int>> &grid) {
-        n = grid.size();
-        for (int i = 0; i < n * n; ++i)
-            p.push_back(i);
-        vector<int> hi(n * n, 0);
+
+    int swimInWater(vector<vector<int>>& grid) {
+        int n = grid.size();
+        p.resize(n * n);
+        for (int i = 0; i < p.size(); ++i) p[i] = i;
+        vector<int> hi(n * n);
         for (int i = 0; i < n; ++i)
             for (int j = 0; j < n; ++j)
-                hi[grid[i][j]] = index(i, j);
-        for (int h = 0; h < n * n; ++h)
+                hi[grid[i][j]] = i * n + j;
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        for (int t = 0; t < n * n; ++t)
         {
-            int x = hi[h] / n, y = hi[h] % n;
-            for (auto dir : dirs)
+            int i = hi[t] / n, j = hi[t] % n;
+            for (int k = 0; k < 4; ++k)
             {
-                int x1 = x + dir[0], y1 = y + dir[1];
-                if (check(x1, y1) && grid[x1][y1] <= h)
-                    p[find(index(x1, y1))] = find(hi[h]);
-                if (find(0) == find(n * n - 1))
-                    return h;
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x >= 0 && x < n && y >= 0 && y < n && grid[x][y] <= t)
+                    p[find(x * n + y)] = find(hi[t]);
+                if (find(0) == find(n * n - 1)) return t;
             }
         }
         return -1;
     }
 
     int find(int x) {
-        if (p[x] != x)
-            p[x] = find(p[x]);
+        if (p[x] != x) p[x] = find(p[x]);
         return p[x];
     }
-
-    int index(int i, int j) {
-        return i * n + j;
-    }
-
-    bool check(int i, int j) {
-        return i >= 0 && i < n && j >= 0 && j < n;
-    }
 };
 ```
 
 ### **Go**
 
 ```go
-var p []int
-var n int
-
 func swimInWater(grid [][]int) int {
-	n = len(grid)
-	p = make([]int, n*n)
-	hi := make([]int, n*n)
-	for i := 0; i < len(p); i++ {
+	n := len(grid)
+	p := make([]int, n*n)
+	for i := range p {
 		p[i] = i
 	}
-	for i := 0; i < n; i++ {
-		for j := 0; j < n; j++ {
-			hi[grid[i][j]] = index(i, j)
+	hi := make([]int, n*n)
+	for i, row := range grid {
+		for j, h := range row {
+			hi[h] = i*n + j
 		}
 	}
-	dirs := [4][2]int{{0, -1}, {0, 1}, {1, 0}, {-1, 0}}
-	for h := 0; h < n*n; h++ {
-		x, y := hi[h]/n, hi[h]%n
-		for _, dir := range dirs {
-			x1, y1 := x+dir[0], y+dir[1]
-			if check(x1, y1) && grid[x1][y1] <= h {
-				p[find(index(x1, y1))] = find(hi[h])
+	var find func(x int) int
+	find = func(x int) int {
+		if p[x] != x {
+			p[x] = find(p[x])
+		}
+		return p[x]
+	}
+	dirs := []int{-1, 0, 1, 0, -1}
+	for t := 0; t < n*n; t++ {
+		i, j := hi[t]/n, hi[t]%n
+		for k := 0; k < 4; k++ {
+			x, y := i+dirs[k], j+dirs[k+1]
+			if x >= 0 && x < n && y >= 0 && y < n && grid[x][y] <= t {
+				p[find(x*n+y)] = find(hi[t])
 			}
 			if find(0) == find(n*n-1) {
-				return h
+				return t
 			}
 		}
 	}
 	return -1
 }
-
-func find(x int) int {
-	if p[x] != x {
-		p[x] = find(p[x])
-	}
-	return p[x]
-}
-
-func index(i, j int) int {
-	return i*n + j
-}
-
-func check(i, j int) bool {
-	return i >= 0 && i < n && j >= 0 && j < n
-}
 ```
 
 ### **...**