feat: add solutions to lc problems

- No.0300.Longest Increasing Subsequence
- No.0343.Integer Break
- No.0384.Shuffle an Array
- No.0583.Delete Operation for Two Strings
- No.0658.Find K Closest Elements
- No.1143.Longest Common Subsequence

Author: YangFong

solution/0300-0399/0300.Longest Increasing Subsequence/README.md

@@ -58,28 +58,28 @@
 
 定义 `dp[i]` 为以 `nums[i]` 结尾的最长子序列的长度，`dp[i]` 初始化为 1(`i∈[0, n)`)。即题目求的是 `dp[i]` （`i ∈[0, n-1]`）的最大值。
 
-状态转移方程为：`dp[i] = max(dp[j]) + 1`，其中 `0≤j<i` 且 `nums[j]<nums[i]`。
+状态转移方程为：`dp[i] = max(dp[j]) + 1`，其中 `0≤j<i` 且 `nums[j] < nums[i]`。
 
-时间复杂度 O(n²)。
+时间复杂度：$O(n^{2})$。
 
 **方法二：贪心 + 二分查找**
 
-维护一个数组 `d[i]`，表示长度为 i 的最长上升子序列末尾元素的最小值，初始值 `d[1]=nums[0]`。
+维护一个数组 `d[i]`，表示长度为 i 的最长上升子序列末尾元素的最小值，初始值 `d[1] = nums[0]`。
 
 直观上，`d[i]` 是单调递增数组。
 
 证明：假设存在 `d[j] ≥ d[i]`，且 `j < i`，我们考虑从长度为 i 的最长上升子序列的末尾删除 `i - j` 个元素，那么这个序列长度变为 j，且第 j 个元素 `d[j]` 必然小于 `d[i]`，由于前面假设 `d[j] ≥ d[i]`，产生了矛盾，因此数组 d 是单调递增数组。
 
 算法思路：
 
-设当前求出的最长上升子序列的长度为 size，初始 `size=1`，从前往后遍历数组 nums，在遍历到 `nums[i]` 时：
+设当前求出的最长上升子序列的长度为 size，初始 `size = 1`，从前往后遍历数组 nums，在遍历到 `nums[i]` 时：
 
 -   若 `nums[i] > d[size]`，则直接将 `nums[i]` 加入到数组 d 的末尾，并且更新 size 自增；
 -   否则，在数组 d 中二分查找（前面证明 d 是一个单调递增数组），找到第一个大于等于 nums[i] 的位置 idx，更新 `d[idx] = nums[i]`。
 
 最终返回 size。
 
-时间复杂度 O(nlogn)。
+时间复杂度：$O(nlogn)$。
 
 **方法三：树状数组**
 
@@ -92,7 +92,7 @@
 
 本题我们使用树状数组 `tree[x]` 来维护以 x 结尾的最长上升子序列的长度。
 
-时间复杂度 O(nlogn)。
+时间复杂度：$O(nlogn)$。
 
 ```python
 def update(x, val):
@@ -573,6 +573,25 @@ func lengthOfLIS(nums []int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut dp = vec![1; n];
+        for i in 1..n {
+            for j in 0..i {
+                if nums[i] > nums[j] {
+                    dp[i] = dp[i].max(dp[j] + 1);
+                }
+            }
+        }
+        *dp.iter().max().unwrap()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0300-0399/0300.Longest Increasing Subsequence/README_EN.md

@@ -506,6 +506,25 @@ func lengthOfLIS(nums []int) int {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut dp = vec![1; n];
+        for i in 1..n {
+            for j in 0..i {
+                if nums[i] > nums[j] {
+                    dp[i] = dp[i].max(dp[j] + 1);
+                }
+            }
+        }
+        *dp.iter().max().unwrap()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0300-0399/0300.Longest Increasing Subsequence/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut dp = vec![1; n];
+        for i in 1..n {
+            for j in 0..i {
+                if nums[i] > nums[j] {
+                    dp[i] = dp[i].max(dp[j] + 1);
+                }
+            }
+        }
+        *dp.iter().max().unwrap()
+    }
+}

solution/0300-0399/0343.Integer Break/README.md

@@ -38,7 +38,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-动态规划。
+**方法一：动态规划**
 
 设 dp[i] 表示正整数 n 能获得的最大乘积，初始化 `dp[1] = 1`。
 
@@ -119,6 +119,32 @@ func max(a, b int) int {
 }
 ```
 
+### **C**
+
+```c
+int integerBreak(int n) {
+    if (n < 4) {
+        return n - 1;
+    }
+    int count = (n - 2) / 3;
+    return pow(3, count) * (n - count * 3);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn integer_break(n: i32) -> i32 {
+        if n < 4 {
+            return n - 1;
+        }
+        let count = (n - 2) / 3;
+        3i32.pow(count as u32) * (n - count * 3)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0300-0399/0343.Integer Break/README_EN.md

@@ -107,6 +107,32 @@ func max(a, b int) int {
 }
 ```
 
+### **C**
+
+```c
+int integerBreak(int n) {
+    if (n < 4) {
+        return n - 1;
+    }
+    int count = (n - 2) / 3;
+    return pow(3, count) * (n - count * 3);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn integer_break(n: i32) -> i32 {
+        if n < 4 {
+            return n - 1;
+        }
+        let count = (n - 2) / 3;
+        3i32.pow(count as u32) * (n - count * 3)
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0300-0399/0343.Integer Break/Solution.c

@@ -0,0 +1,7 @@
+int integerBreak(int n) {
+    if (n < 4) {
+        return n - 1;
+    }
+    int count = (n - 2) / 3;
+    return pow(3, count) * (n - count * 3);
+}

solution/0300-0399/0343.Integer Break/Solution.rs

@@ -0,0 +1,9 @@
+impl Solution {
+    pub fn integer_break(n: i32) -> i32 {
+        if n < 4 {
+            return n - 1;
+        }
+        let count = (n - 2) / 3;
+        3i32.pow(count as u32) * (n - count * 3)
+    }
+}

solution/0300-0399/0384.Shuffle an Array/README.md

@@ -192,6 +192,120 @@ func (this *Solution) Shuffle() []int {
  */
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} nums
+ */
+const Solution = function (nums) {
+    this.nums = nums || [];
+};
+
+/**
+ * Resets the array to its original configuration and return it.
+ * @return {number[]}
+ */
+Solution.prototype.reset = function () {
+    return this.nums;
+};
+
+/**
+ * Returns a random shuffling of the array.
+ * @return {number[]}
+ */
+Solution.prototype.shuffle = function () {
+    let a = this.nums.slice();
+    for (let i = 0; i < a.length; i++) {
+        let rand = Math.floor(Math.random() * (a.length - i)) + i;
+        let tmp = a[i];
+        a[i] = a[rand];
+        a[rand] = tmp;
+    }
+    return a;
+};
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Object.create(Solution).createNew(nums)
+ * var param_1 = obj.reset()
+ * var param_2 = obj.shuffle()
+ */
+```
+
+### **TypeScript**
+
+```ts
+class Solution {
+    private nums: number[];
+
+    constructor(nums: number[]) {
+        this.nums = nums;
+    }
+
+    reset(): number[] {
+        return this.nums;
+    }
+
+    shuffle(): number[] {
+        const n = this.nums.length;
+        const res = [...this.nums];
+        for (let i = 0; i < n; i++) {
+            const j = Math.floor(Math.random() * n);
+            [res[i], res[j]] = [res[j], res[i]];
+        }
+        return res;
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(nums)
+ * var param_1 = obj.reset()
+ * var param_2 = obj.shuffle()
+ */
+```
+
+### **Rust**
+
+```rust
+use rand::Rng;
+struct Solution {
+    nums: Vec<i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl Solution {
+    fn new(nums: Vec<i32>) -> Self {
+        Self { nums }
+    }
+
+    fn reset(&self) -> Vec<i32> {
+        self.nums.clone()
+    }
+
+    fn shuffle(&mut self) -> Vec<i32> {
+        let n = self.nums.len();
+        let mut res = self.nums.clone();
+        for i in 0..n {
+            let j = rand::thread_rng().gen_range(0, n);
+            res.swap(i, j);
+        }
+        res
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * let obj = Solution::new(nums);
+ * let ret_1: Vec<i32> = obj.reset();
+ * let ret_2: Vec<i32> = obj.shuffle();
+ */
+```
+
 ### **...**
 
 ```