feat: add solutions to lc problem: No.2059

No.2059.Minimum Operations to Convert Number

Author: yanglbme

solution/2000-2099/2059.Minimum Operations to Convert Number/README.md

@@ -89,7 +89,37 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-BFS 最小步数模型。
+BFS 最小步数模型。本题搜索空间不大，可以直接使用朴素 BFS，以下题解中还提供了双向 BFS 的题解代码，仅供参考。
+
+双向 BFS 是 BFS 常见的一个优化方法，主要实现思路如下：
+
+1. 创建两个队列 q1, q2 分别用于“起点 -> 终点”、“终点 -> 起点”两个方向的搜索；
+2. 创建两个哈希表 m1, m2 分别记录访问过的节点以及对应的扩展次数（步数）；
+3. 每次搜索时，优先选择元素数量较少的队列进行搜索扩展，如果在扩展过程中，搜索到另一个方向已经访问过的节点，说明找到了最短路径；
+4. 只要其中一个队列为空，说明当前方向的搜索已经进行不下去了，说明起点到终点不连通，无需继续搜索。
+
+```python
+while q1 and q2:
+    if len(q1) <= len(q2):
+        # 优先选择较少元素的队列进行扩展
+        extend(m1, m2, q1)
+    else:
+        extend(m2, m1, q2)
+def extend(m1, m2, q):
+    # 新一轮扩展
+    for _ in range(len(q), 0, -1):
+        p = q.popleft()
+        step = m1[p]
+        for t in next(p):
+            if t in m1:
+                # 此前已经访问过
+                continue
+            if t in m2:
+                # 另一个方向已经搜索过，说明找到了一条最短的连通路径
+                return step + 1 + m2[t]
+            q.append(t)
+            m1[t] = step + 1
+```
 
 <!-- tabs:start -->
 
@@ -146,6 +176,42 @@ class Solution:
         return -1
 ```
 
+双向 BFS：
+
+```python
+class Solution:
+    def minimumOperations(self, nums: List[int], start: int, goal: int) -> int:
+        def next(x):
+            res = []
+            for num in nums:
+                res.append(x + num)
+                res.append(x - num)
+                res.append(x ^ num)
+            return res
+        
+        def extend(m1, m2, q):
+            for _ in range(len(q), 0, -1):
+                x = q.popleft()
+                step = m1[x]
+                for y in next(x):
+                    if y in m1:
+                        continue
+                    if y in m2:
+                        return step + 1 + m2[y]
+                    if 0 <= y <= 1000:
+                        m1[y] = step + 1
+                        q.append(y)
+            return -1
+        
+        m1, m2 = {start: 0}, {goal: 0}
+        q1, q2 = deque([start]), deque([goal])
+        while q1 and q2:
+            t = extend(m1, m2, q1) if len(q1) <= len(q2) else extend(m2, m1, q2)
+            if t != -1:
+                return t
+        return -1
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -218,6 +284,63 @@ class Solution {
 }
 ```
 
+双向 BFS：
+
+```java
+class Solution {
+    private int[] nums;
+
+    public int minimumOperations(int[] nums, int start, int goal) {
+        this.nums = nums;
+        Map<Integer, Integer> m1 = new HashMap<>();
+        Map<Integer, Integer> m2 = new HashMap<>();
+        Deque<Integer> q1 = new ArrayDeque<>();
+        Deque<Integer> q2 = new ArrayDeque<>();
+        m1.put(start, 0);
+        m2.put(goal, 0);
+        q1.offer(start);
+        q2.offer(goal);
+        while (!q1.isEmpty() && !q2.isEmpty()) {
+            int t = q1.size() <= q2.size() ? extend(m1, m2, q1) : extend(m2, m1, q2);
+            if (t != -1) {
+                return t;
+            }
+        }
+        return -1;
+    }
+
+    private int extend(Map<Integer, Integer> m1, Map<Integer, Integer> m2, Deque<Integer> q) {
+        for (int i = q.size(); i > 0; --i) {
+            int x = q.poll();
+            int step = m1.get(x);
+            for (int y : next(x)) {
+                if (m1.containsKey(y)) {
+                    continue;
+                }
+                if (m2.containsKey(y)) {
+                    return step + 1 + m2.get(y);
+                }
+                if (y >= 0 && y <= 1000) {
+                    m1.put(y, step + 1);
+                    q.offer(y);
+                }
+            }
+        }
+        return -1;
+    }
+
+    private List<Integer> next(int x) {
+        List<Integer> res = new ArrayList<>();
+        for (int num : nums) {
+            res.add(x + num);
+            res.add(x - num);
+            res.add(x ^ num);
+        }
+        return res;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -295,6 +418,59 @@ public:
 };
 ```
 
+双向 BFS：
+
+```cpp
+class Solution {
+public:
+    int minimumOperations(vector<int>& nums, int start, int goal) {
+        unordered_map<int, int> m1;
+        unordered_map<int, int> m2;
+        m1[start] = 0;
+        m2[goal] = 0;
+        queue<int> q1{{start}};
+        queue<int> q2{{goal}};
+        while (!q1.empty() && !q2.empty())
+        {
+            int t = q1.size() <= q2.size() ? extend(m1, m2, q1, nums) : extend(m2, m1, q2, nums);
+            if (t != -1) return t;
+        }
+        return -1;
+    }
+
+    int extend(unordered_map<int, int>& m1, unordered_map<int, int>& m2, queue<int>& q, vector<int>& nums) {
+        for (int i = q.size(); i > 0; --i)
+        {
+            int x = q.front();
+            int step = m1[x];
+            q.pop();
+            for (int y : next(nums, x))
+            {
+                if (m1.count(y)) continue;
+                if (m2.count(y)) return step + 1 + m2[y];
+                if (y >= 0 && y <= 1000)
+                {
+                    m1[y] = step + 1;
+                    q.push(y);
+                }
+            }
+        }
+        return -1;
+    }
+
+    vector<int> next(vector<int>& nums, int x) {
+        vector<int> res;
+        for (int num : nums)
+        {
+            res.push_back(x + num);
+            res.push_back(x - num);
+            res.push_back(x ^ num);
+        }
+        return res;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -364,6 +540,53 @@ func minimumOperations(nums []int, start int, goal int) int {
 }
 ```
 
+双向 BFS：
+
+```go
+func minimumOperations(nums []int, start int, goal int) int {
+	next := func(x int) []int {
+		var res []int
+		for _, num := range nums {
+			res = append(res, []int{x + num, x - num, x ^ num}...)
+		}
+		return res
+	}
+	m1, m2 := map[int]int{start: 0}, map[int]int{goal: 0}
+	q1, q2 := []int{start}, []int{goal}
+	extend := func() int {
+		for i := len(q1); i > 0; i-- {
+			x := q1[0]
+			q1 = q1[1:]
+			step, _ := m1[x]
+			for _, y := range next(x) {
+				if _, ok := m1[y]; ok {
+					continue
+				}
+				if v, ok := m2[y]; ok {
+					return step + 1 + v
+				}
+				if y >= 0 && y <= 1000 {
+					m1[y] = step + 1
+					q1 = append(q1, y)
+				}
+			}
+		}
+		return -1
+	}
+	for len(q1) > 0 && len(q2) > 0 {
+		if len(q1) > len(q2) {
+			m1, m2 = m2, m1
+			q1, q2 = q2, q1
+		}
+		t := extend()
+		if t != -1 {
+			return t
+		}
+	}
+	return -1
+}
+```
+
 ### **TypeScript**
 
 ```ts