feat: add solutions to lc problem: No.0489 (doocs#1582)

No.0489.Robot Room Cleaner

Author: yanglbme

solution/0400-0499/0489.Robot Room Cleaner/README.md

@@ -61,16 +61,11 @@ col = 3
 
 <!-- 这里可写通用的实现逻辑 -->
 
-DFS。
+**方法一：DFS**
 
-我们设定机器人起始位置 `(0, 0)`，朝向 d = 0。
+我们不妨假设机器人的初始位置为 $(0, 0)$，方向为 $d=0$。我们将初始位置进行打扫，并标记为已访问。然后，我们依次选择上、右、下、左四个方向进行探索，每次探索前都先判断是否已经访问过，如果没有访问过，我们就朝着该方向前进一步，然后递归探索。如果已经访问过，我们就顺时针旋转 $90^\circ$，然后继续探索下一个方向。当我们探索完所有的方向后，我们需要回到上一个位置，这时我们只需要顺时针旋转 $180^\circ$，然后前进一步，再顺时针旋转 $180^\circ$ 即可。
 
-将起始位置进行清扫，并进行标记（即清扫过的格子也算作障碍）；然后依次选择四个朝向 up，right，down 和 left 进行深度优先搜索，相邻的两个朝向仅差一次向右旋转的操作；
-
--   对于选择的朝向，检查下一个格子是否有障碍，如果没有，则向对应朝向移动一格，并开始新的搜索；
--   如果有，则向右旋转。
-
-如果四个朝向都搜索完毕，则回溯到上一次搜索。
+时间复杂度 $O(4^{n-m})$，空间复杂度 $O(n-m)$。其中 $n$ 和 $m$ 分别是房间的数量以及障碍物的数量。
 
 <!-- tabs:start -->
 
@@ -119,26 +114,23 @@ class Solution:
         :rtype: None
         """
 
-        def back():
-            robot.turnRight()
-            robot.turnRight()
-            robot.move()
-            robot.turnRight()
-            robot.turnRight()
-
         def dfs(i, j, d):
             vis.add((i, j))
             robot.clean()
             for k in range(4):
                 nd = (d + k) % 4
-                x, y = i + dirs[nd][0], j + dirs[nd][1]
+                x, y = i + dirs[nd], j + dirs[nd + 1]
                 if (x, y) not in vis and robot.move():
                     dfs(x, y, nd)
-                    back()
+                    robot.turnRight()
+                    robot.turnRight()
+                    robot.move()
+                    robot.turnRight()
+                    robot.turnRight()
                 robot.turnRight()
 
+        dirs = (-1, 0, 1, 0, -1)
         vis = set()
-        dirs = [(-1, 0), (0, 1), (1, 0), (0, -1)]
         dfs(0, 0, 0)
 ```
 
@@ -166,36 +158,32 @@ class Solution:
  */
 
 class Solution {
-    private Set<String> vis;
-    private int[][] dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
+    private int[] dirs = {-1, 0, 1, 0, -1};
+    private Set<List<Integer>> vis = new HashSet<>();
+    private Robot robot;
 
     public void cleanRoom(Robot robot) {
-        vis = new HashSet<>();
-        dfs(0, 0, 0, robot);
+        this.robot = robot;
+        dfs(0, 0, 0);
     }
 
-    private void dfs(int i, int j, int d, Robot robot) {
-        vis.add(i + "," + j);
+    private void dfs(int i, int j, int d) {
         robot.clean();
+        vis.add(List.of(i, j));
         for (int k = 0; k < 4; ++k) {
             int nd = (d + k) % 4;
-            int x = i + dirs[nd][0];
-            int y = j + dirs[nd][1];
-            if (!vis.contains(x + "," + y) && robot.move()) {
-                dfs(x, y, nd, robot);
-                back(robot);
+            int x = i + dirs[nd], y = j + dirs[nd + 1];
+            if (!vis.contains(List.of(x, y)) && robot.move()) {
+                dfs(x, y, nd);
+                robot.turnRight();
+                robot.turnRight();
+                robot.move();
+                robot.turnRight();
+                robot.turnRight();
             }
             robot.turnRight();
         }
     }
-
-    private void back(Robot robot) {
-        robot.turnRight();
-        robot.turnRight();
-        robot.move();
-        robot.turnRight();
-        robot.turnRight();
-    }
 }
 ```
 
@@ -223,34 +211,27 @@ class Solution {
 
 class Solution {
 public:
-    vector<vector<int>> dirs = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
-
     void cleanRoom(Robot& robot) {
-        unordered_set<string> vis;
-        dfs(0, 0, 0, vis, robot);
-    }
-
-    void dfs(int i, int j, int d, unordered_set<string>& vis, Robot& robot) {
-        vis.insert(to_string(i) + "," + to_string(j));
-        robot.clean();
-        for (int k = 0; k < 4; ++k) {
-            int nd = (d + k) % 4;
-            int x = i + dirs[nd][0];
-            int y = j + dirs[nd][1];
-            if (!vis.count(to_string(x) + "," + to_string(y)) && robot.move()) {
-                dfs(x, y, nd, vis, robot);
-                back(robot);
+        int dirs[5] = {-1, 0, 1, 0, -1};
+        set<pair<int, int>> vis;
+        function<void(int, int, int)> dfs = [&](int i, int j, int d) {
+            robot.clean();
+            vis.insert({i, j});
+            for (int k = 0; k < 4; ++k) {
+                int nd = (d + k) % 4;
+                int x = i + dirs[nd], y = j + dirs[nd + 1];
+                if (!vis.count({x, y}) && robot.move()) {
+                    dfs(x, y, nd);
+                    robot.turnRight();
+                    robot.turnRight();
+                    robot.move();
+                    robot.turnRight();
+                    robot.turnRight();
+                }
+                robot.turnRight();
             }
-            robot.turnRight();
-        }
-    }
-
-    void back(Robot& robot) {
-        robot.turnRight();
-        robot.turnRight();
-        robot.move();
-        robot.turnRight();
-        robot.turnRight();
+        };
+        dfs(0, 0, 0);
     }
 };
 ```
@@ -278,25 +259,22 @@ public:
  */
 
 func cleanRoom(robot *Robot) {
-	vis := make(map[string]bool)
-	dirs := [][]int{{-1, 0}, {0, 1}, {1, 0}, {0, -1}}
-	back := func() {
-		robot.TurnRight()
-		robot.TurnRight()
-		robot.Move()
-		robot.TurnRight()
-		robot.TurnRight()
-	}
-	var dfs func(i, j, d int)
+	vis := map[[2]int]bool{}
+	dirs := [5]int{-1, 0, 1, 0, -1}
+	var dfs func(int, int, int)
 	dfs = func(i, j, d int) {
-		vis[strconv.Itoa(i)+","+strconv.Itoa(j)] = true
+		vis[[2]int{i, j}] = true
 		robot.Clean()
 		for k := 0; k < 4; k++ {
 			nd := (d + k) % 4
-			x, y := i+dirs[nd][0], j+dirs[nd][1]
-			if !vis[strconv.Itoa(x)+","+strconv.Itoa(y)] && robot.Move() {
+			x, y := i+dirs[nd], j+dirs[nd+1]
+			if !vis[[2]int{x, y}] && robot.Move() {
 				dfs(x, y, nd)
-				back()
+				robot.TurnRight()
+				robot.TurnRight()
+				robot.Move()
+				robot.TurnRight()
+				robot.TurnRight()
 			}
 			robot.TurnRight()
 		}
@@ -305,6 +283,52 @@ func cleanRoom(robot *Robot) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ * class Robot {
+ *      // Returns true if the cell in front is open and robot moves into the cell.
+ *      // Returns false if the cell in front is blocked and robot stays in the current cell.
+ * 		move(): boolean {}
+ *
+ *      // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *      // Each turn will be 90 degrees.
+ * 		turnRight() {}
+ *
+ *      // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *      // Each turn will be 90 degrees.
+ * 		turnLeft() {}
+ *
+ * 		// Clean the current cell.
+ * 		clean(): {}
+ * }
+ */
+
+function cleanRoom(robot: Robot) {
+    const dirs = [-1, 0, 1, 0, -1];
+    const vis = new Set<string>();
+    const dfs = (i: number, j: number, d: number) => {
+        vis.add(`${i}-${j}`);
+        robot.clean();
+        for (let k = 0; k < 4; ++k) {
+            const nd = (d + k) % 4;
+            const [x, y] = [i + dirs[nd], j + dirs[nd + 1]];
+            if (!vis.has(`${x}-${y}`) && robot.move()) {
+                dfs(x, y, nd);
+                robot.turnRight();
+                robot.turnRight();
+                robot.move();
+                robot.turnRight();
+                robot.turnRight();
+            }
+            robot.turnRight();
+        }
+    };
+    dfs(0, 0, 0);
+}
+```
+
 ### **...**
 
 ```