feat: add solutions to lc problem: No.1472

No.1472.Design Browser History

Author: yanglbme

solution/1400-1499/1470.Shuffle the Array/README.md

@@ -61,6 +61,13 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def shuffle(self, nums: List[int], n: int) -> List[int]:
+        nums[::2], nums[1::2] = nums[:n], nums[n:]
+        return nums
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->

solution/1400-1499/1470.Shuffle the Array/README_EN.md

@@ -47,13 +47,9 @@
 <p><strong>Constraints:</strong></p>
 
 <ul>
-
     <li><code>1 &lt;= n &lt;= 500</code></li>
-
     <li><code>nums.length == 2n</code></li>
-
     <li><code>1 &lt;= nums[i] &lt;= 10^3</code></li>
-
 </ul>
 
 ## Solutions
@@ -72,6 +68,13 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def shuffle(self, nums: List[int], n: int) -> List[int]:
+        nums[::2], nums[1::2] = nums[:n], nums[n:]
+        return nums
+```
+
 ### **Java**
 
 ```java

solution/1400-1499/1471.The k Strongest Values in an Array/README.md

@@ -76,7 +76,7 @@
 
 **方法一：自定义排序**
 
-时间复杂度 O(2nlogn)。
+时间复杂度 $O(2nlogn)$。
 
 <!-- tabs:start -->
 

solution/1400-1499/1472.Design Browser History/README.md

@@ -57,74 +57,39 @@ browserHistory.back(7);                   // 你原本在浏览 "google.com
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：栈**
+
+使用两个栈模拟前进与后退操作。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-列表实现。
-
-```python
-class BrowserHistory:
-    def __init__(self, homepage: str):
-        self.urls = []
-        self.cur = -1
-        self.tail = -1
-        self.visit(homepage)
-
-    def visit(self, url: str) -> None:
-        self.cur += 1
-        if self.cur < len(self.urls):
-            self.urls[self.cur] = url
-        else:
-            self.urls.append(url)
-        self.tail = self.cur
-
-    def back(self, steps: int) -> str:
-        self.cur = max(0, self.cur - steps)
-        return self.urls[self.cur]
-
-    def forward(self, steps: int) -> str:
-        self.cur = min(self.tail, self.cur + steps)
-        return self.urls[self.cur]
-
-
-# Your BrowserHistory object will be instantiated and called as such:
-# obj = BrowserHistory(homepage)
-# obj.visit(url)
-# param_2 = obj.back(steps)
-# param_3 = obj.forward(steps)
-```
-
-栈实现。
-
 ```python
 class BrowserHistory:
 
     def __init__(self, homepage: str):
-        self.s1 = []
-        self.s2 = []
-        self.cur = homepage
+        self.stk1 = []
+        self.stk2 = []
+        self.visit(homepage)
 
     def visit(self, url: str) -> None:
-        self.s2.clear()
-        self.s1.append(self.cur)
-        self.cur = url
+        self.stk1.append(url)
+        self.stk2.clear()
 
     def back(self, steps: int) -> str:
-        while steps > 0 and self.s1:
-            self.s2.append(self.cur)
-            self.cur = self.s1.pop()
+        while steps and len(self.stk1) > 1:
+            self.stk2.append(self.stk1.pop())
             steps -= 1
-        return self.cur
+        return self.stk1[-1]
 
     def forward(self, steps: int) -> str:
-        while steps > 0 and self.s2:
-            self.s1.append(self.cur)
-            self.cur = self.s2.pop()
+        while steps and self.stk2:
+            self.stk1.append(self.stk2.pop())
             steps -= 1
-        return self.cur
+        return self.stk1[-1]
 
 
 # Your BrowserHistory object will be instantiated and called as such:
@@ -138,37 +103,32 @@ class BrowserHistory:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-列表实现。
-
 ```java
 class BrowserHistory {
-    private List<String> urls;
-    private int cur = -1;
-    private int tail = -1;
+    private Deque<String> stk1 = new ArrayDeque<>();
+    private Deque<String> stk2 = new ArrayDeque<>();
 
     public BrowserHistory(String homepage) {
-        urls = new ArrayList<>();
         visit(homepage);
     }
-
+    
     public void visit(String url) {
-        ++cur;
-        if (cur < urls.size()) {
-            urls.set(cur, url);
-        } else {
-            urls.add(url);
-        }
-        tail = cur;
+        stk1.push(url);
+        stk2.clear();
     }
-
+    
     public String back(int steps) {
-        cur = Math.max(0, cur - steps);
-        return urls.get(cur);
+        for (; steps > 0 && stk1.size() > 1; --steps) {
+            stk2.push(stk1.pop());
+        }
+        return stk1.peek();
     }
-
+    
     public String forward(int steps) {
-        cur = Math.min(tail, cur + steps);
-        return urls.get(cur);
+        for (; steps > 0 && !stk2.isEmpty(); --steps) {
+            stk1.push(stk2.pop());
+        }
+        return stk1.peek();
     }
 }
 
@@ -181,51 +141,90 @@ class BrowserHistory {
  */
 ```
 
-栈实现。
+### **C++**
 
-```java
+```cpp
 class BrowserHistory {
-    private Deque<String> s1;
-    private Deque<String> s2;
-    private String cur;
+public:
+    stack<string> stk1;
+    stack<string> stk2;
 
-    public BrowserHistory(String homepage) {
-        s1 = new ArrayDeque<>();
-        s2 = new ArrayDeque<>();
-        cur = homepage;
+    BrowserHistory(string homepage) {
+        visit(homepage);
     }
-
-    public void visit(String url) {
-        s2.clear();
-        s1.push(cur);
-        cur = url;
+    
+    void visit(string url) {
+        stk1.push(url);
+        stk2 = stack<string>();
     }
-
-    public String back(int steps) {
-        while (steps > 0 && !s1.isEmpty()) {
-            s2.push(cur);
-            cur = s1.pop();
-            --steps;
+    
+    string back(int steps) {
+        for (; steps && stk1.size() > 1; --steps) {
+            stk2.push(stk1.top());
+            stk1.pop();
         }
-        return cur;
+        return stk1.top();
     }
-
-    public String forward(int steps) {
-        while (steps > 0 && !s2.isEmpty()) {
-            s1.push(cur);
-            cur = s2.pop();
-            --steps;
+    
+    string forward(int steps) {
+        for (; steps && !stk2.empty(); --steps) {
+            stk1.push(stk2.top());
+            stk2.pop();
         }
-        return cur;
+        return stk1.top();
     }
+};
+
+/**
+ * Your BrowserHistory object will be instantiated and called as such:
+ * BrowserHistory* obj = new BrowserHistory(homepage);
+ * obj->visit(url);
+ * string param_2 = obj->back(steps);
+ * string param_3 = obj->forward(steps);
+ */
+```
+
+### **Go**
+
+```go
+type BrowserHistory struct {
+	stk1 []string
+	stk2 []string
+}
+
+func Constructor(homepage string) BrowserHistory {
+	t := BrowserHistory{[]string{}, []string{}}
+	t.Visit(homepage)
+	return t
+}
+
+func (this *BrowserHistory) Visit(url string) {
+	this.stk1 = append(this.stk1, url)
+	this.stk2 = []string{}
+}
+
+func (this *BrowserHistory) Back(steps int) string {
+	for i := 0; i < steps && len(this.stk1) > 1; i++ {
+		this.stk2 = append(this.stk2, this.stk1[len(this.stk1)-1])
+		this.stk1 = this.stk1[:len(this.stk1)-1]
+	}
+	return this.stk1[len(this.stk1)-1]
+}
+
+func (this *BrowserHistory) Forward(steps int) string {
+	for i := 0; i < steps && len(this.stk2) > 0; i++ {
+		this.stk1 = append(this.stk1, this.stk2[len(this.stk2)-1])
+		this.stk2 = this.stk2[:len(this.stk2)-1]
+	}
+	return this.stk1[len(this.stk1)-1]
 }
 
 /**
  * Your BrowserHistory object will be instantiated and called as such:
- * BrowserHistory obj = new BrowserHistory(homepage);
- * obj.visit(url);
- * String param_2 = obj.back(steps);
- * String param_3 = obj.forward(steps);
+ * obj := Constructor(homepage);
+ * obj.Visit(url);
+ * param_2 := obj.Back(steps);
+ * param_3 := obj.Forward(steps);
  */
 ```