feat: add solutions to lc problem: No.3661 (#4664)

No.3661.Maximum Walls Destroyed by Robots

Author: yanglbme

solution/3600-3699/3661.Maximum Walls Destroyed by Robots/README.md

@@ -101,32 +101,275 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3661.Ma
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：记忆化搜索
 
-<!-- tabs:start -->
+我们首先将每个机器人与其射程一起存储在一个数组中，并按照机器人的位置进行排序。同时，我们对墙壁的位置进行排序。接下来，我们使用深度优先搜索（DFS）来计算每个机器人可以摧毁的墙壁数量，并使用记忆化搜索来避免重复计算。
+
+我们设计一个函数 $\text{dfs}(i, j)$，其中 $i$ 表示当前考虑的机器人索引，而 $j$ 表示下一个机器人的发射方向（0 表示左，1 表示右）的时候，所能摧毁的墙壁数量。答案为 $\text{dfs}(n - 1, 1)$，边界状态下的 $j$ 可以取 0 或 1。
+
+函数 $\text{dfs}(i, j)$ 的执行逻辑如下：
+
+如果 $i \lt 0$，表示所有机器人都已经考虑过，返回 0。
+
+否则，对于当前机器人，有两种发射方向可供选择。
+
+如果选择**向左**发射，我们需要计算左侧的射程范围 $[\text{left}, \text{robot}[i][0]]$，并通过二分查找，计算此范围内可以摧毁的墙壁数量。这种情况下一共可以摧毁 $\text{dfs}(i - 1, 0) + \text{count}$ 墙壁，其中 $\text{count}$ 是当前机器人向左发射时摧毁的墙壁数量。
+
+如果选择**向右**发射，我们需要计算右侧的射程范围 $[\text{robot}[i][0], \text{right}]$，并通过二分查找，计算此范围内可以摧毁的墙壁数量。这种情况下一共可以摧毁 $\text{dfs}(i - 1, 1) + \text{count}$ 墙壁，其中 $\text{count}$ 是当前机器人向右发射时摧毁的墙壁数量。
+
+函数的返回值为两种发射方向所能摧毁墙壁数量的最大值。
+
+时间复杂度 $O(n \times \log n + m \times \log m)$，空间复杂度 $O(n)$。其中 $n$ 和 $m$ 分别是机器人和墙壁的数量。
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maxWalls(self, robots: List[int], distance: List[int], walls: List[int]) -> int:
+        n = len(robots)
+        arr = sorted(zip(robots, distance), key=lambda x: x[0])
+        walls.sort()
+
+        @cache
+        def dfs(i: int, j: int) -> int:
+            if i < 0:
+                return 0
+            left = arr[i][0] - arr[i][1]
+            if i > 0:
+                left = max(left, arr[i - 1][0] + 1)
+            l = bisect_left(walls, left)
+            r = bisect_left(walls, arr[i][0] + 1)
+            ans = dfs(i - 1, 0) + r - l
+            right = arr[i][0] + arr[i][1]
+            if i + 1 < n:
+                if j == 0:
+                    right = min(right, arr[i + 1][0] - arr[i + 1][1] - 1)
+                else:
+                    right = min(right, arr[i + 1][0] - 1)
+            l = bisect_left(walls, arr[i][0])
+            r = bisect_left(walls, right + 1)
+            ans = max(ans, dfs(i - 1, 1) + r - l)
+            return ans
+
+        return dfs(n - 1, 1)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private Integer[][] f;
+    private int[][] arr;
+    private int[] walls;
+    private int n;
+
+    public int maxWalls(int[] robots, int[] distance, int[] walls) {
+        n = robots.length;
+        arr = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            arr[i][0] = robots[i];
+            arr[i][1] = distance[i];
+        }
+        Arrays.sort(arr, Comparator.comparingInt(a -> a[0]));
+        Arrays.sort(walls);
+        this.walls = walls;
+        f = new Integer[n][2];
+        return dfs(n - 1, 1);
+    }
+
+    private int dfs(int i, int j) {
+        if (i < 0) {
+            return 0;
+        }
+        if (f[i][j] != null) {
+            return f[i][j];
+        }
+
+        int left = arr[i][0] - arr[i][1];
+        if (i > 0) {
+            left = Math.max(left, arr[i - 1][0] + 1);
+        }
+        int l = lowerBound(walls, left);
+        int r = lowerBound(walls, arr[i][0] + 1);
+        int ans = dfs(i - 1, 0) + (r - l);
+
+        int right = arr[i][0] + arr[i][1];
+        if (i + 1 < n) {
+            if (j == 0) {
+                right = Math.min(right, arr[i + 1][0] - arr[i + 1][1] - 1);
+            } else {
+                right = Math.min(right, arr[i + 1][0] - 1);
+            }
+        }
+        l = lowerBound(walls, arr[i][0]);
+        r = lowerBound(walls, right + 1);
+        ans = Math.max(ans, dfs(i - 1, 1) + (r - l));
+        return f[i][j] = ans;
+    }
+
+    private int lowerBound(int[] arr, int target) {
+        int idx = Arrays.binarySearch(arr, target);
+        if (idx < 0) {
+            return -idx - 1;
+        }
+        return idx;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int maxWalls(vector<int>& robots, vector<int>& distance, vector<int>& walls) {
+        int n = robots.size();
+        vector<pair<int, int>> arr(n);
+        for (int i = 0; i < n; i++) {
+            arr[i] = {robots[i], distance[i]};
+        }
+        ranges::sort(arr, {}, &pair<int, int>::first);
+        ranges::sort(walls);
+
+        vector f(n, vector<int>(2, -1));
+
+        auto dfs = [&](this auto&& dfs, int i, int j) -> int {
+            if (i < 0) {
+                return 0;
+            }
+            if (f[i][j] != -1) {
+                return f[i][j];
+            }
+
+            int left = arr[i].first - arr[i].second;
+            if (i > 0) {
+                left = max(left, arr[i - 1].first + 1);
+            }
+            int l = ranges::lower_bound(walls, left) - walls.begin();
+            int r = ranges::lower_bound(walls, arr[i].first + 1) - walls.begin();
+            int ans = dfs(i - 1, 0) + (r - l);
+
+            int right = arr[i].first + arr[i].second;
+            if (i + 1 < n) {
+                if (j == 0) {
+                    right = min(right, arr[i + 1].first - arr[i + 1].second - 1);
+                } else {
+                    right = min(right, arr[i + 1].first - 1);
+                }
+            }
+            l = ranges::lower_bound(walls, arr[i].first) - walls.begin();
+            r = ranges::lower_bound(walls, right + 1) - walls.begin();
+            ans = max(ans, dfs(i - 1, 1) + (r - l));
+
+            return f[i][j] = ans;
+        };
+
+        return dfs(n - 1, 1);
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maxWalls(robots []int, distance []int, walls []int) int {
+	type pair struct {
+		x, d int
+	}
+	n := len(robots)
+	arr := make([]pair, n)
+	for i := 0; i < n; i++ {
+		arr[i] = pair{robots[i], distance[i]}
+	}
+	sort.Slice(arr, func(i, j int) bool {
+		return arr[i].x < arr[j].x
+	})
+	sort.Ints(walls)
+
+	f := make(map[[2]int]int)
+
+	var dfs func(int, int) int
+	dfs = func(i, j int) int {
+		if i < 0 {
+			return 0
+		}
+		key := [2]int{i, j}
+		if v, ok := f[key]; ok {
+			return v
+		}
+
+		left := arr[i].x - arr[i].d
+		if i > 0 {
+			left = max(left, arr[i-1].x+1)
+		}
+		l := sort.SearchInts(walls, left)
+		r := sort.SearchInts(walls, arr[i].x+1)
+		ans := dfs(i-1, 0) + (r - l)
+
+		right := arr[i].x + arr[i].d
+		if i+1 < n {
+			if j == 0 {
+				right = min(right, arr[i+1].x-arr[i+1].d-1)
+			} else {
+				right = min(right, arr[i+1].x-1)
+			}
+		}
+		l = sort.SearchInts(walls, arr[i].x)
+		r = sort.SearchInts(walls, right+1)
+		ans = max(ans, dfs(i-1, 1)+(r-l))
+
+		f[key] = ans
+		return ans
+	}
+
+	return dfs(n-1, 1)
+}
+```
 
+#### TypeScript
+
+```ts
+function maxWalls(robots: number[], distance: number[], walls: number[]): number {
+    type Pair = [number, number];
+    const n = robots.length;
+    const arr: Pair[] = robots.map((r, i) => [r, distance[i]]);
+
+    _.sortBy(arr, p => p[0]).forEach((p, i) => (arr[i] = p));
+    walls.sort((a, b) => a - b);
+    const f: number[][] = Array.from({ length: n }, () => Array(2).fill(-1));
+
+    function dfs(i: number, j: number): number {
+        if (i < 0) {
+            return 0;
+        }
+        if (f[i][j] !== -1) {
+            return f[i][j];
+        }
+
+        let left = arr[i][0] - arr[i][1];
+        if (i > 0) left = Math.max(left, arr[i - 1][0] + 1);
+        let l = _.sortedIndex(walls, left);
+        let r = _.sortedIndex(walls, arr[i][0] + 1);
+        let ans = dfs(i - 1, 0) + (r - l);
+
+        let right = arr[i][0] + arr[i][1];
+        if (i + 1 < n) {
+            if (j === 0) {
+                right = Math.min(right, arr[i + 1][0] - arr[i + 1][1] - 1);
+            } else {
+                right = Math.min(right, arr[i + 1][0] - 1);
+            }
+        }
+        l = _.sortedIndex(walls, arr[i][0]);
+        r = _.sortedIndex(walls, right + 1);
+        ans = Math.max(ans, dfs(i - 1, 1) + (r - l));
+
+        f[i][j] = ans;
+        return ans;
+    }
+
+    return dfs(n - 1, 1);
+}
 ```
 
 <!-- tabs:end -->