diff --git a/problems/0300.最长上升子序列.md b/problems/0300.最长上升子序列.md
index 42efe31d..f4fe1c31 100644
--- a/problems/0300.最长上升子序列.md
+++ b/problems/0300.最长上升子序列.md
@@ -36,9 +36,9 @@
 首先通过本题大家要明确什么是子序列，“子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序”。 
 
 本题也是代码随想录中子序列问题的第一题，如果没接触过这种题目的话，本题还是很难的，甚至想暴力去搜索也不知道怎么搜。 
-子序列问题是动态规划解决的经典问题，当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系，那那又是什么样的关系呢。
+子序列问题是动态规划解决的经典问题，当前下标i的递增子序列长度，其实和i之前的下表j的子序列长度有关系，那又是什么样的关系呢。
 
-接下来，我们依然用动规五部曲来分析详细一波：
+接下来，我们依然用动规五部曲来详细分析一波：
 
 1. dp[i]的定义
 
@@ -46,7 +46,7 @@
 
 **dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度** 
 
-为什么一定表示  “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如果算递增呢。 
+为什么一定表示  “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如何算递增呢。 
 
 
 2. 状态转移方程
@@ -155,31 +155,6 @@ class Solution:
 ```
 
 Go：
-```go
-func lengthOfLIS(nums []int ) int {
-  dp := []int{}
-  for _, num := range nums {
-      if len(dp) ==0 || dp[len(dp) - 1] < num {
-      dp = append(dp, num)
-    } else {
-          l, r := 0, len(dp) - 1
-          pos := r
-          for l <= r {
-              mid := (l + r) >> 1
-              if dp[mid] >= num {
-                  pos = mid;
-                  r = mid - 1
-              } else {
-                  l = mid + 1
-              }
-          }
-          dp[pos] = num
-      }//二分查找
-  }
-    return len(dp)
-}
-```
-
 ```go
 // 动态规划求解
 func lengthOfLIS(nums []int) int {
@@ -212,21 +187,29 @@ func max(x, y int) int {
     return y
 }
 ```
-
-Rust:
-```rust
-pub fn length_of_lis(nums: Vec<i32>) -> i32 {
-    let mut dp = vec![1; nums.len() + 1];
-    let mut result = 1;
-    for i in 1..nums.len() {
-        for j in 0..i {
-            if nums[j] < nums[i] {
-                dp[i] = dp[i].max(dp[j] + 1);
-            }
-            result = result.max(dp[i]);
-        }
-    }
-    result
+贪心+二分 优化
+```go
+func lengthOfLIS(nums []int ) int {
+  dp := []int{}
+  for _, num := range nums {
+      if len(dp) == 0 || dp[len(dp) - 1] < num {
+      dp = append(dp, num)
+    } else {
+          l, r := 0, len(dp) - 1
+          pos := r
+          for l <= r {
+              mid := (l + r) >> 1
+              if dp[mid] >= num {
+                  pos = mid;
+                  r = mid - 1
+              } else {
+                  l = mid + 1
+              }
+          }
+          dp[pos] = num
+      }//二分查找
+  }
+    return len(dp)
 }
 ```
 
@@ -270,6 +253,22 @@ function lengthOfLIS(nums: number[]): number {
 };
 ```
 
+Rust:
+```rust
+pub fn length_of_lis(nums: Vec<i32>) -> i32 {
+    let mut dp = vec![1; nums.len() + 1];
+    let mut result = 1;
+    for i in 1..nums.len() {
+        for j in 0..i {
+            if nums[j] < nums[i] {
+                dp[i] = dp[i].max(dp[j] + 1);
+            }
+            result = result.max(dp[i]);
+        }
+    }
+    result
+}
+```