Merge branch 'master' of github.com:youngyangyang04/leetcode-master

2025-07-06 23:28:29 +08:00 · 2022-09-29 11:04:20 +08:00
parent 882defc255 fd820f6f4f
commit 84dec64f49
10 changed files with 256 additions and 25 deletions
--- a/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
+++ b/problems/0034.在排序数组中查找元素的第一个和最后一个位置.md
@ -389,6 +389,57 @@ class Solution:
        return [leftBorder, rightBorder]
 ```

+### Rust
+
+```rust
+
+impl  Solution {
+    pub fn search_range(nums: Vec<i32>, target: i32) -> Vec<i32> {
+        let right_border = Solution::get_right_border(&nums, target);
+        let left_border = Solution::get_left_border(&nums, target);
+        if right_border == -2 || left_border == -2 {
+            return vec![-1, -1];
+        }
+        if right_border - left_border > 0 {
+            return vec![left_border, right_border - 1];
+        }
+        vec![-1, -1]
+    }
+
+    pub fn get_right_border(nums: &Vec<i32>, target: i32) -> i32 {
+        let mut left = 0;
+        let mut right = nums.len();
+        let mut right_border: i32 = -2;
+        while left < right {
+            let mid = (left + right) / 2;
+            if nums[mid] > target {
+                right = mid;
+            } else {
+                left = mid + 1;
+                right_border = left as i32;
+            }
+        }
+        right_border as i32
+    }
+
+    pub fn get_left_border(nums: &Vec<i32>, target: i32) -> i32 {
+        let mut left = 0;
+        let mut right = nums.len();
+        let mut left_border: i32 = -2;
+        while left < right {
+            let mid = (left + right) / 2;
+            if nums[mid] >= target {
+                right = mid;
+                left_border = right as i32;
+            } else {
+                left = mid + 1;
+            }
+        }
+        left_border as i32
+    }
+}
+```
+
 ### Go

 ```go
--- a/problems/0062.不同路径.md
+++ b/problems/0062.不同路径.md
@ -452,5 +452,25 @@ object Solution {
 }
 ```

+### c#
+
+```c#
+public class Solution
+{
+    public int UniquePaths(int m, int n)
+    {
+        int[] dp = new int[n];
+        for (int i = 0; i < n; i++)
+            dp[i] = 1;
+        for (int i = 1; i < m; i++)
+            for (int j = 1; j < n; j++)
+                dp[j] += dp[j - 1];
+        return dp[n - 1];
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
--- a/problems/0063.不同路径II.md
+++ b/problems/0063.不同路径II.md
@ -382,8 +382,37 @@ var uniquePathsWithObstacles = function(obstacleGrid) {
        
    return dp[m - 1][n - 1]
 };
+
+// 版本二：内存优化，直接以原数组为dp数组
+var uniquePathsWithObstacles = function(obstacleGrid) {
+    const m = obstacleGrid.length;
+    const n = obstacleGrid[0].length;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (obstacleGrid[i][j] === 0) {
+                // 不是障碍物
+                if (i === 0) {
+                    // 取左边的值
+                    obstacleGrid[i][j] = obstacleGrid[i][j - 1] ?? 1;
+                } else if (j === 0) {
+                    // 取上边的值
+                    obstacleGrid[i][j] = obstacleGrid[i - 1]?.[j] ?? 1;
+                } else {
+                    // 取左边和上边的和
+                    obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1];
+                }
+            } else {
+                // 如果是障碍物，则路径为0
+                obstacleGrid[i][j] = 0;
+            }
+        }
+    }
+    return obstacleGrid[m - 1][n - 1];
+};
 ```

+
+
 ### TypeScript

 ```typescript
--- a/problems/0070.爬楼梯.md
+++ b/problems/0070.爬楼梯.md
@ -425,5 +425,25 @@ object Solution {
 }
 ```

+### C#
+
+```c#
+public class Solution {
+    public int ClimbStairs(int n) {
+        if(n<=2) return n;
+        int[] dp = new int[2] { 1, 2 };
+        for (int i = 3; i <= n; i++)
+        {
+            int temp = dp[0] + dp[1];
+            dp[0] = dp[1];
+            dp[1] = temp;
+        }
+        return dp[1];
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
--- a/problems/0496.下一个更大元素I.md
+++ b/problems/0496.下一个更大元素I.md
@ -221,6 +221,32 @@ class Solution {
        return res;
    }
 }
+
+// 版本2
+class Solution {
+    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums1.length; i++) {
+            map.put(nums1[i], i);
+        }
+
+        int[] res = new int[nums1.length];
+        Stack<Integer> stack = new Stack<>();
+        Arrays.fill(res, -1);
+
+        for (int i = 0; i < nums2.length; i++) {
+            while (!stack.isEmpty() && nums2[stack.peek()] < nums2[i]) {
+                int pre = nums2[stack.pop()];
+                if (map.containsKey(pre)) {
+                    res[map.get(pre)] = nums2[i];
+                }
+            }
+            stack.push(i);
+        }
+
+        return res;
+    }
+}
 ```
 Python3：
 ```python
--- a/problems/0509.斐波那契数.md
+++ b/problems/0509.斐波那契数.md
@ -370,5 +370,45 @@ object Solution {
 }
 ```

+### C#
+
+动态规划:
+
+```c#
+public class Solution
+{
+    public int Fib(int n)
+    {
+        if(n<2) return n;
+        int[] dp = new int[2] { 0, 1 };
+        for (int i = 2; i <= n; i++)
+        {
+            int temp = dp[0] + dp[1];
+            dp[0] = dp[1];
+            dp[1] = temp;
+        }
+        return dp[1];
+    }
+}
+```
+
+递归:
+
+```c#	
+public class Solution
+{
+    public int Fib(int n)
+    {
+        if(n<2)
+            return n;
+        return Fib(n-1)+Fib(n-2);
+    }
+}
+```
+
+
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
--- a/problems/0583.两个字符串的删除操作.md
+++ b/problems/0583.两个字符串的删除操作.md
@ -128,6 +128,28 @@ public:

 Java：
 ```java
+// dp数组中存储word1和word2最长相同子序列的长度
+class Solution {
+    public int minDistance(String word1, String word2) {
+        int len1 = word1.length();
+        int len2 = word2.length();
+        int[][] dp = new int[len1 + 1][len2 + 1];
+
+        for (int i = 1; i <= len1; i++) {
+            for (int j = 1; j <= len2; j++) {
+                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+
+        return len1 + len2 - dp[len1][len2] * 2;
+    }
+}
+
+// dp数组中存储需要删除的字符个数
 class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@ -225,16 +225,15 @@ class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if nums is None or len(nums)==0:
            return -1
-        l=0
-        r=len(nums)-1
-        while (l<=r):
-            m = round(l+(r-l)/2)
-            if nums[m] == target:
-                return m     
-            elif nums[m] > target:
-                r=m-1
+        left,right=0,len(nums)
+        while (left<right):
+            middle = round(left+(right-left)//2)
+            if nums[middle] == target:
+                return middle     
+            elif nums[middle] > target:
+                right=middle
            else:
-                l=m+1
+                left=middle+1
        return -1 
 ```

--- a/problems/0746.使用最小花费爬楼梯.md
+++ b/problems/0746.使用最小花费爬楼梯.md
@ -370,5 +370,26 @@ object Solution {
 }
 ```

+### C#
+
+```c#
+public class Solution
+{
+    public int MinCostClimbingStairs(int[] cost)
+    {
+        int[] dp=new int[2] { cost[0], cost[1] };
+        for (int i = 2; i < cost.Length; i++)
+        {
+            int temp = Math.Min(dp[0], dp[1])+cost[i];
+            dp[0]=dp[1];
+            dp[1]=temp;
+        }
+        return Math.Min(dp[0],dp[1]);
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
--- a/problems/1035.不相交的线.md
+++ b/problems/1035.不相交的线.md
@ -74,24 +74,27 @@ public:


 Java：
-  ```java
+```java
  class Solution {
-    public int maxUncrossedLines(int[] A, int[] B) {
-		int [][] dp = new int[A.length+1][B.length+1];
-		for(int i=1;i<=A.length;i++) {
-			for(int j=1;j<=B.length;j++) {
-				if (A[i-1]==B[j-1]) {
-					dp[i][j]=dp[i-1][j-1]+1;
-				}
-				else {
-					dp[i][j]=Math.max(dp[i-1][j], dp[i][j-1]);
-				}
-			}
-		}
-		return dp[A.length][B.length];
-	}
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        int len1 = nums1.length;
+        int len2 = nums2.length;
+        int[][] dp = new int[len1 + 1][len2 + 1];
+
+        for (int i = 1; i <= len1; i++) {
+            for (int j = 1; j <= len2; j++) {
+                if (nums1[i - 1] == nums2[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+
+        return dp[len1][len2];
+    }
 }
-  ```
+```

 Python：
 ```python