feat: add solutions to lc problems: No.1188,1196

* No.1188.Design Bounded Blocking Queue
* No.1196.How Many Apples Can You Put into the Basket

Author: yanglbme

solution/0100-0199/0167.Two Sum II - Input Array Is Sorted/README_EN.md

@@ -4,7 +4,7 @@
 
 ## Description
 
-<p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt;= numbers.length</code>.</p>
+<p>Given a <strong>1-indexed</strong> array of integers <code>numbers</code> that is already <strong><em>sorted in non-decreasing order</em></strong>, find two numbers such that they add up to a specific <code>target</code> number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 &lt;= index<sub>1</sub> &lt; index<sub>2</sub> &lt;&nbsp;numbers.length</code>.</p>
 
 <p>Return<em> the indices of the two numbers, </em><code>index<sub>1</sub></code><em> and </em><code>index<sub>2</sub></code><em>, <strong>added by one</strong> as an integer array </em><code>[index<sub>1</sub>, index<sub>2</sub>]</code><em> of length 2.</em></p>
 

solution/0500-0599/0594.Longest Harmonious Subsequence/README_EN.md

@@ -11,49 +11,34 @@
 <p>A <strong>subsequence</strong> of array is a sequence that can be derived from the array by deleting some or no elements without changing the order of the remaining elements.</p>
 
 <p>&nbsp;</p>
-
 <p><strong class="example">Example 1:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> nums = [1,3,2,2,5,2,3,7]
-
 <strong>Output:</strong> 5
-
 <strong>Explanation:</strong> The longest harmonious subsequence is [3,2,2,2,3].
-
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> nums = [1,2,3,4]
-
 <strong>Output:</strong> 2
-
 </pre>
 
 <p><strong class="example">Example 3:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> nums = [1,1,1,1]
-
 <strong>Output:</strong> 0
-
 </pre>
 
 <p>&nbsp;</p>
-
 <p><strong>Constraints:</strong></p>
 
 <ul>
-
-    <li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
-
-    <li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
-
+	<li><code>1 &lt;= nums.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>-10<sup>9</sup> &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
 </ul>
 
 ## Solutions

solution/0600-0699/0684.Redundant Connection/README.md

@@ -6,13 +6,13 @@
 
 <!-- 这里写题目描述 -->
 
-<p>树可以看成是一个连通且 <strong>无环 </strong>的 <strong>无向 </strong>图。</p>
+<p>树可以看成是一个连通且 <strong>无环&nbsp;</strong>的&nbsp;<strong>无向&nbsp;</strong>图。</p>
 
-<p>给定往一棵 <code>n</code> 个节点 (节点值 <code>1～n</code>) 的树中添加一条边后的图。添加的边的两个顶点包含在 <code>1</code> 到 <code>n</code> 中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 <code>n</code> 的二维数组 <code>edges</code> ，<code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> 表示图中在 <code>ai</code> 和 <code>bi</code> 之间存在一条边。</p>
+<p>给定往一棵&nbsp;<code>n</code> 个节点 (节点值&nbsp;<code>1～n</code>) 的树中添加一条边后的图。添加的边的两个顶点包含在 <code>1</code> 到 <code>n</code>&nbsp;中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为 <code>n</code> 的二维数组 <code>edges</code>&nbsp;，<code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code>&nbsp;表示图中在 <code>ai</code> 和 <code>bi</code> 之间存在一条边。</p>
 
-<p>请找出一条可以删去的边，删除后可使得剩余部分是一个有着 <code>n</code> 个节点的树。如果有多个答案，则返回数组 <code>edges</code> 中最后出现的边。</p>
+<p>请找出一条可以删去的边，删除后可使得剩余部分是一个有着 <code>n</code> 个节点的树。如果有多个答案，则返回数组&nbsp;<code>edges</code>&nbsp;中最后出现的那个。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
@@ -32,18 +32,18 @@
 <strong>输出:</strong> [1,4]
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示:</strong></p>
 
 <ul>
 	<li><code>n == edges.length</code></li>
-	<li><code>3 <= n <= 1000</code></li>
+	<li><code>3 &lt;= n &lt;= 1000</code></li>
 	<li><code>edges[i].length == 2</code></li>
-	<li><code>1 <= ai < bi <= edges.length</code></li>
+	<li><code>1 &lt;= ai&nbsp;&lt; bi&nbsp;&lt;= edges.length</code></li>
 	<li><code>ai != bi</code></li>
 	<li><code>edges</code> 中无重复元素</li>
-	<li>给定的图是连通的 </li>
+	<li>给定的图是连通的&nbsp;</li>
 </ul>
 
 ## 解法

solution/0800-0899/0827.Making A Large Island/README_EN.md

@@ -11,55 +11,37 @@
 <p>An <strong>island</strong> is a 4-directionally connected group of <code>1</code>s.</p>
 
 <p>&nbsp;</p>
-
 <p><strong class="example">Example 1:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> grid = [[1,0],[0,1]]
-
 <strong>Output:</strong> 3
-
 <strong>Explanation:</strong> Change one 0 to 1 and connect two 1s, then we get an island with area = 3.
-
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> grid = [[1,1],[1,0]]
-
 <strong>Output:</strong> 4
-
 <strong>Explanation: </strong>Change the 0 to 1 and make the island bigger, only one island with area = 4.</pre>
 
 <p><strong class="example">Example 3:</strong></p>
 
 <pre>
-
 <strong>Input:</strong> grid = [[1,1],[1,1]]
-
 <strong>Output:</strong> 4
-
 <strong>Explanation:</strong> Can&#39;t change any 0 to 1, only one island with area = 4.
-
 </pre>
 
 <p>&nbsp;</p>
-
 <p><strong>Constraints:</strong></p>
 
 <ul>
-
-    <li><code>n == grid.length</code></li>
-
-    <li><code>n == grid[i].length</code></li>
-
-    <li><code>1 &lt;= n &lt;= 500</code></li>
-
-    <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
-
+	<li><code>n == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= n &lt;= 500</code></li>
+	<li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li>
 </ul>
 
 ## Solutions

solution/1100-1199/1188.Design Bounded Blocking Queue/README.md

@@ -100,10 +100,102 @@ queue.size();       // 队列中还有 1 个元素。
 
 <!-- tabs:start -->
 
-### **SQL**
+### **Python3**
 
-```sql
+```python
+from threading import Semaphore
 
+
+class BoundedBlockingQueue(object):
+
+    def __init__(self, capacity: int):
+        self.s1 = Semaphore(capacity)
+        self.s2 = Semaphore(0)
+        self.q = deque()
+
+    def enqueue(self, element: int) -> None:
+        self.s1.acquire()
+        self.q.append(element)
+        self.s2.release()
+
+    def dequeue(self) -> int:
+        self.s2.acquire()
+        ans = self.q.popleft()
+        self.s1.release()
+        return ans
+
+    def size(self) -> int:
+        return len(self.q)
 ```
 
+### **Java**
+
+```java
+class BoundedBlockingQueue {
+    private Semaphore s1;
+    private Semaphore s2;
+    private Deque<Integer> q = new ArrayDeque<>();
+
+    public BoundedBlockingQueue(int capacity) {
+        s1 = new Semaphore(capacity);
+        s2 = new Semaphore(0);
+    }
+
+    public void enqueue(int element) throws InterruptedException {
+        s1.acquire();
+        q.offer(element);
+        s2.release();
+    }
+
+    public int dequeue() throws InterruptedException {
+        s2.acquire();;
+        int ans = q.poll();
+        s1.release();
+        return ans;
+    }
+
+    public int size() {
+        return q.size();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+#include <semaphore.h>
+
+class BoundedBlockingQueue {
+public:
+    BoundedBlockingQueue(int capacity) {
+        sem_init(&s1, 0, capacity);
+        sem_init(&s2, 0, 0);
+    }
+
+    void enqueue(int element) {
+        sem_wait(&s1);
+        q.push(element);
+        sem_post(&s2);
+    }
+
+    int dequeue() {
+        sem_wait(&s2);
+        int ans = q.front();
+        q.pop();
+        sem_post(&s1);
+        return ans;
+    }
+
+    int size() {
+        return q.size();
+    }
+
+private:
+    queue<int> q;
+    sem_t s1, s2;
+};
+```
+
+### \*\*
+
 <!-- tabs:end -->

solution/1100-1199/1188.Design Bounded Blocking Queue/README_EN.md

@@ -92,10 +92,100 @@ Since the number of threads for producer/consumer is greater than 1, we do not k
 
 <!-- tabs:start -->
 
-### **SQL**
+### **Python3**
 
-```sql
+```python
+from threading import Semaphore
 
+
+class BoundedBlockingQueue(object):
+
+    def __init__(self, capacity: int):
+        self.s1 = Semaphore(capacity)
+        self.s2 = Semaphore(0)
+        self.q = deque()
+
+    def enqueue(self, element: int) -> None:
+        self.s1.acquire()
+        self.q.append(element)
+        self.s2.release()
+
+    def dequeue(self) -> int:
+        self.s2.acquire()
+        ans = self.q.popleft()
+        self.s1.release()
+        return ans
+
+    def size(self) -> int:
+        return len(self.q)
+```
+
+### **Java**
+
+```java
+class BoundedBlockingQueue {
+    private Semaphore s1;
+    private Semaphore s2;
+    private Deque<Integer> q = new ArrayDeque<>();
+
+    public BoundedBlockingQueue(int capacity) {
+        s1 = new Semaphore(capacity);
+        s2 = new Semaphore(0);
+    }
+
+    public void enqueue(int element) throws InterruptedException {
+        s1.acquire();
+        q.offer(element);
+        s2.release();
+    }
+
+    public int dequeue() throws InterruptedException {
+        s2.acquire();;
+        int ans = q.poll();
+        s1.release();
+        return ans;
+    }
+
+    public int size() {
+        return q.size();
+    }
+}
+```
+
+### **C++**
+
+```cpp
+#include <semaphore.h>
+
+class BoundedBlockingQueue {
+public:
+    BoundedBlockingQueue(int capacity) {
+        sem_init(&s1, 0, capacity);
+        sem_init(&s2, 0, 0);
+    }
+
+    void enqueue(int element) {
+        sem_wait(&s1);
+        q.push(element);
+        sem_post(&s2);
+    }
+
+    int dequeue() {
+        sem_wait(&s2);
+        int ans = q.front();
+        q.pop();
+        sem_post(&s1);
+        return ans;
+    }
+
+    int size() {
+        return q.size();
+    }
+
+private:
+    queue<int> q;
+    sem_t s1, s2;
+};
 ```
 
 <!-- tabs:end -->