Merge pull request youngyangyang04#2452 from LYT0905/master

Update 0045.跳跃游戏II.md

Author: youngyangyang04

problems/0045.跳跃游戏II.md

@@ -492,7 +492,34 @@ impl Solution {
     }
 }
 ```
+### C
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int jump(int* nums, int numsSize) {
+    if(numsSize == 1){
+        return 0;
+    }
+    int count = 0;
+    // 记录当前能走的最远距离
+    int curDistance = 0;
+    // 记录下一步能走的最远距离
+    int nextDistance = 0;
+    for(int i = 0; i < numsSize; i++){
+        nextDistance = max(i + nums[i], nextDistance);
+        // 下标到了当前的最大距离
+        if(i == nextDistance){
+            count++;
+            curDistance = nextDistance;
+        }
+    }
+    return count;
+}
+```
+
 ### C#
+
 ```csharp
 // 版本二
 public class Solution
@@ -518,3 +545,4 @@ public class Solution
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0056.合并区间.md

@@ -336,7 +336,49 @@ impl Solution {
     }
 }
 ```
+### C
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+// 根据左边界进行排序
+int cmp(const void * var1, const void * var2){
+    int *v1 = *(int **) var1;
+    int *v2 = *(int **) var2;
+    return v1[0] - v2[0];
+}
+
+int** merge(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize, int** returnColumnSizes) {
+    int ** result = malloc(sizeof (int *) * intervalsSize);
+    * returnColumnSizes = malloc(sizeof (int ) * intervalsSize);
+    for(int i = 0; i < intervalsSize; i++){
+        result[i] = malloc(sizeof (int ) * 2);
+    }
+    qsort(intervals, intervalsSize, sizeof (int *), cmp);
+    int count = 0;
+    for(int i = 0; i < intervalsSize; i++){
+        // 记录区间的左右边界
+        int L = intervals[i][0], R = intervals[i][1];
+        // 如果count为0或者前一区间的右区间小于此时的左边，加入结果中
+        if (count == 0 || result[count - 1][1] < L) {
+            returnColumnSizes[0][count] = 2;
+            result[count][0] = L;
+            result[count][1] = R;
+            count++;
+        } 
+        else{ // 更新右边界的值
+            result[count - 1][1] = max(R, result[count - 1][1]);
+        }
+    }
+    *returnSize = count;
+    return result;
+}
+```
+
+
+
 ### C#
+
 ```csharp
 public class Solution
 {
@@ -367,4 +409,3 @@ public class Solution
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-

problems/0121.买卖股票的最佳时机.md

@@ -531,6 +531,52 @@ public class Solution
 }
 ```
 
+### C：
+
+> 贪心
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define min(a, b) ((a) > (b) ? (b) : (a))
+
+int maxProfit(int* prices, int pricesSize) {
+    int low = INT_MIN;
+    int result = 0;
+    for(int i = 0; i < pricesSize; i++){
+        low = min(low, prices[i]);
+        result = max(result, prices[i] - low);
+    }
+    return result;
+}
+```
+
+> 动态规划
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int maxProfit(int* prices, int pricesSize){
+    if(pricesSize == 0){
+        return 0;
+    }
+    // dp初始化
+    int ** dp = malloc(sizeof (int *) * pricesSize);
+    for(int i = 0; i < pricesSize; i++){
+        dp[i] = malloc(sizeof (int ) * 2);
+    }
+    // 下标0表示持有股票的情况下的最大现金，下标1表示不持有股票的情况下获得的最大现金
+    dp[0][0] = -prices[0];
+    dp[0][1] = 0;
+    for(int i = 1; i < pricesSize; i++){
+        dp[i][0] = max(dp[i - 1][0], - prices[i]);
+        dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
+    }
+    return dp[pricesSize - 1][1];
+}
+```
+
+
+
 ### Rust:
 
 > 贪心
@@ -568,4 +614,3 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-

problems/0122.买卖股票的最佳时机II（动态规划）.md

@@ -365,6 +365,49 @@ public class Solution
 }
 ```
 
+### C:
+
+> 动态规划
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int maxProfit(int* prices, int pricesSize){
+    int **dp = malloc(sizeof (int *) * pricesSize);
+    for (int i = 0; i < pricesSize; ++i) {
+        dp[i] = malloc(sizeof (int ) * 2);
+    }
+    // 0表示持有该股票所得最大，1表示不持有所得最大
+    dp[0][0] = -prices[0];
+    dp[0][1] = 0;
+    for (int i = 1; i < pricesSize; ++i) {
+        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
+        dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
+    }
+    return dp[pricesSize - 1][1];
+}
+```
+
+> 贪心
+
+```c
+int maxProfit(int* prices, int pricesSize) {
+    if(pricesSize == 0){
+        return 0;
+    }
+    int result = 0;
+    for(int i = 1; i < pricesSize; i++){
+        // 如果今天股票价格大于昨天，代表有利润
+        if(prices[i] > prices[i - 1]){
+            result += prices[i] - prices[i - 1];
+        }
+    }
+    return result;
+}
+```
+
+
+
 ### Rust:
 
 > 贪心
@@ -416,3 +459,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0123.买卖股票的最佳时机III.md

@@ -413,6 +413,34 @@ function maxProfit(prices: number[]): number {
 };
 ```
 
+### C:
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#define min(a, b) ((a) > (b) ? (b) : (a))
+
+int maxProfit(int* prices, int pricesSize) {
+    int buy1 = prices[0], buy2 = prices[0];
+    int profit1 = 0, profit2 = 0;
+    for (int i = 0; i < pricesSize; ++i) {
+        // 寻找最低点买入
+        buy1 = min(buy1, prices[i]);
+        // 找到第一次交易的最大盈利,并不断维护这一最大值
+        profit1 = max(profit1, prices[i] - buy1);
+
+        // 寻找第二次交易的最低投资点，并且考虑前一次交易的成本
+        // 当前价格 - 第一次操作的盈利=新的投入成本（
+        // 为了让盈利最大，要寻找最小的成本）
+        buy2 = min(buy2, prices[i] - profit1);
+        // 第二次卖出后的盈利：当前价格减去成本，不断维护这一最大的总利润
+        profit2 = max(profit2, prices[i] - buy2);
+    }
+    return profit2;
+}
+```
+
+
+
 ### Rust：
 
 > 版本一
@@ -465,4 +493,3 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-

problems/0139.单词拆分.md

@@ -498,6 +498,33 @@ function wordBreak(s: string, wordDict: string[]): boolean {
 };
 ```
 
+### C
+
+```c
+bool wordBreak(char* s, char** wordDict, int wordDictSize) {
+    int len = strlen(s);
+    // 初始化
+    bool dp[len + 1];
+    memset(dp, false, sizeof (dp));
+    dp[0] = true;
+    for (int i = 1; i < len + 1; ++i) {
+        for(int j =  0; j < wordDictSize; j++){
+            int wordLen = strlen(wordDict[j]);
+            // 分割点是由i和字典单词长度决定
+            int k = i - wordLen;
+            if(k < 0){
+                continue;
+            }
+            // 这里注意要限制长度，故用strncmp
+            dp[i] = (dp[k] && !strncmp(s + k, wordDict[j], wordLen)) || dp[i];
+        }
+    }
+    return dp[len];
+}
+```
+
+
+
 ### Rust:
 
 ```rust
@@ -521,4 +548,3 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
-

problems/0188.买卖股票的最佳时机IV.md

@@ -474,6 +474,34 @@ function maxProfit(k: number, prices: number[]): number {
 };
 ```
 
+### C:
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int maxProfit(int k, int* prices, int pricesSize) {
+    if(pricesSize == 0){
+        return 0;
+    }
+    
+    int dp[pricesSize][2 * k + 1];
+    memset(dp, 0, sizeof(int) * pricesSize * (2 * k + 1));
+    for (int j = 1; j < 2 * k; j += 2) {
+        dp[0][j] = -prices[0];
+    }
+
+    for (int i = 1;i < pricesSize; i++) {//枚举股票
+        for (int j = 0; j < 2 * k - 1; j += 2) { //更新每一次买入卖出
+            dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
+            dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
+        }
+    }
+    return dp[pricesSize - 1][2 * k];
+}
+```
+
+
+
 ### Rust：
 
 ```rust
@@ -529,3 +557,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+

problems/0198.打家劫舍.md

@@ -315,6 +315,31 @@ function rob(nums: number[]): number {
 };
 ```
 
+### C
+
+```c
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+int rob(int* nums, int numsSize) {
+    if(numsSize == 0){
+        return 0;
+    }
+    if(numsSize == 1){
+        return nums[0];
+    }
+    // dp初始化
+    int dp[numsSize];
+    dp[0] = nums[0];
+    dp[1] = max(nums[0], nums[1]);
+    for(int i = 2; i < numsSize; i++){
+        dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
+    }
+    return dp[numsSize - 1];
+}
+```
+
+
+
 ### Rust:
 
 ```rust
@@ -339,3 +364,4 @@ impl Solution {
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>
 </a>
+