Merge pull request #1235 from KingArthur0205/master

添加 0376. 摆动序列.md, 0053.最大子数组和.md, 0122.买股票的最佳时机II.md, 0055.跳跃游戏.md, 1005. K次取反后最大化的数组和.md， 0135.分发糖果.md C语言解法

problems/0053.最大子序和.md

@@ -230,6 +230,60 @@ var maxSubArray = function(nums) {
 };
 ```
 
+
+### C:
+贪心：
+```c
+int maxSubArray(int* nums, int numsSize){
+    int maxVal = INT_MIN;
+    int subArrSum = 0;
+    
+    int i;
+    for(i = 0; i < numsSize; ++i) {
+        subArrSum += nums[i];
+        // 若当前局部和大于之前的最大结果，对结果进行更新
+        maxVal = subArrSum > maxVal ? subArrSum : maxVal;
+        // 若当前局部和为负，对结果无益。则从nums[i+1]开始应重新计算。
+        subArrSum = subArrSum < 0 ? 0 : subArrSum;
+    }
+
+    return maxVal;
+}
+```
+
+动态规划：
+```c
+/**
+ * 解题思路：动态规划：
+ * 1. dp数组：dp[i]表示从0到i的子序列中最大序列和的值
+ * 2. 递推公式：dp[i] = max(dp[i-1] + nums[i], nums[i])
+        若dp[i-1]<0，对最后结果无益。dp[i]则为nums[i]。
+ * 3. dp数组初始化：dp[0]的最大子数组和为nums[0]
+ * 4. 推导顺序：从前往后遍历
+ */
+
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+int maxSubArray(int* nums, int numsSize){
+    int dp[numsSize];
+    // dp[0]最大子数组和为nums[0]
+    dp[0] = nums[0];
+    // 若numsSize为1，应直接返回nums[0]
+    int subArrSum = nums[0];
+
+    int i;
+    for(i = 1; i < numsSize; ++i) {
+        dp[i] = max(dp[i - 1] + nums[i], nums[i]);
+
+        // 若dp[i]大于之前记录的最大值，进行更新
+        if(dp[i] > subArrSum)
+            subArrSum = dp[i];
+    }
+
+    return subArrSum;
+}
+```
+
 ### TypeScript
 
 **贪心**
@@ -267,5 +321,6 @@ function maxSubArray(nums: number[]): number {
 
 
 
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0055.跳跃游戏.md

@@ -154,6 +154,30 @@ var canJump = function(nums) {
 };
 ```
 
+
+### C
+```c
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+bool canJump(int* nums, int numsSize){
+    int cover = 0;
+
+    int i;
+    // 只可能获取cover范围中的步数，所以i<=cover
+    for(i = 0; i <= cover; ++i) {
+        // 更新cover为从i出发能到达的最大值/cover的值中较大值
+        cover = max(i + nums[i], cover);
+
+        // 若更新后cover可以到达最后的元素，返回true
+        if(cover >= numsSize - 1)
+            return true;
+    }
+
+    return false;
+}
+```
+
+
 ### TypeScript
 
 ```typescript

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

@@ -281,7 +281,7 @@ function maxProfit(prices: number[]): number {
 ```
 
 C:
-
+贪心：
 ```c
 int maxProfit(int* prices, int pricesSize){
     int result = 0;
@@ -296,5 +296,27 @@ int maxProfit(int* prices, int pricesSize){
 }
 ```
 
+动态规划：
+```c
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+int maxProfit(int* prices, int pricesSize){
+    int dp[pricesSize][2];
+    dp[0][0] = 0 - prices[0];
+    dp[0][1] = 0;
+
+    int i;
+    for(i = 1; i < pricesSize; ++i) {
+        // dp[i][0]为i-1天持股的钱数/在第i天用i-1天的钱买入的最大值。
+        // 若i-1天持股，且第i天买入股票比i-1天持股时更亏，说明应在i-1天时持股
+        dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i]);
+        //dp[i][1]为i-1天不持股钱数/在第i天卖出所持股票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];
+}
+```
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0135.分发糖果.md

@@ -238,6 +238,49 @@ var candy = function(ratings) {
 };
 ```
 
+
+### C
+```c
+#define max(a, b) (((a) > (b)) ? (a) : (b))
+
+int *initCandyArr(int size) {
+    int *candyArr = (int*)malloc(sizeof(int) * size);
+
+    int i;
+    for(i = 0; i < size; ++i)
+        candyArr[i] = 1;
+
+    return candyArr;
+}
+
+int candy(int* ratings, int ratingsSize){
+    // 初始化数组，每个小孩开始至少有一颗糖
+    int *candyArr = initCandyArr(ratingsSize);
+
+    int i;
+    // 先判断右边是否比左边评分高。若是，右边孩子的糖果为左边孩子+1（candyArr[i] = candyArr[i - 1] + 1)
+    for(i = 1; i < ratingsSize; ++i) {
+        if(ratings[i] > ratings[i - 1])
+            candyArr[i] = candyArr[i - 1] + 1;
+    }
+
+    // 再判断左边评分是否比右边高。
+    // 若是，左边孩子糖果为右边孩子糖果+1/自己所持糖果最大值。（若糖果已经比右孩子+1多，则不需要更多糖果）
+    // 举例：ratings为[1, 2, 3, 1]。此时评分为3的孩子在判断右边比左边大后为3，虽然它比最末尾的1(ratings[3])大，但是candyArr[3]为1。所以不必更新candyArr[2]
+    for(i = ratingsSize - 2; i >= 0; --i) {
+        if(ratings[i] > ratings[i + 1])
+            candyArr[i] = max(candyArr[i], candyArr[i + 1] + 1);
+    }
+
+    // 求出糖果之和
+    int result = 0;
+    for(i = 0; i < ratingsSize; ++i) {
+        result += candyArr[i];
+    }
+    return result;
+}
+```
+
 ### TypeScript
 
 ```typescript
@@ -264,6 +307,5 @@ function candy(ratings: number[]): number {
 
 
 
-
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0376.摆动序列.md

@@ -298,6 +298,35 @@ var wiggleMaxLength = function(nums) {
 };
 ```
 
+
+### C
+**贪心**
+```c
+int wiggleMaxLength(int* nums, int numsSize){
+    if(numsSize <= 1) 
+        return numsSize;
+
+    int length = 1;
+    int preDiff , curDiff;
+    preDiff = curDiff = 0;
+    for(int i = 0; i < numsSize - 1; ++i) {
+        // 计算当前i元素与i+1元素差值
+        curDiff = nums[i+1] - nums[i];
+
+        // 若preDiff与curDiff符号不符，则子序列长度+1。更新preDiff的符号
+        // 若preDiff与curDiff符号一致，当前i元素为连续升序/连续降序子序列的中间元素。不被记录入长度
+        // 注：当preDiff为0时，curDiff为正或为负都属于符号不同
+        if((curDiff > 0 && preDiff <= 0) || (preDiff >= 0 && curDiff < 0)) {
+            preDiff = curDiff;
+            length++;
+        }
+    }
+
+    return length;
+}
+```
+
+
 ### TypeScript
 
 **贪心**

problems/1005.K次取反后最大化的数组和.md

@@ -211,6 +211,46 @@ var largestSumAfterKNegations = function(nums, k) {
 };
 ```
 
+
+### C
+```c
+#define abs(a) (((a) > 0) ? (a) : (-(a)))
+
+// 对数组求和
+int sum(int *nums, int numsSize) {
+    int sum = 0;
+
+    int i;
+    for(i = 0; i < numsSize; ++i) {
+        sum += nums[i];
+    }
+    return sum;
+}
+
+int cmp(const void* v1, const void* v2) {
+    return abs(*(int*)v2) - abs(*(int*)v1);
+}
+
+int largestSumAfterKNegations(int* nums, int numsSize, int k){
+    qsort(nums, numsSize, sizeof(int), cmp);
+
+    int i;
+    for(i = 0; i < numsSize; ++i) {
+        // 遍历数组，若当前元素<0则将当前元素转变，k--
+        if(nums[i] < 0 && k > 0) {
+            nums[i] *= -1;
+            --k;
+        }
+    }
+
+    // 若遍历完数组后k还有剩余（此时所有元素应均为正），则将绝对值最小的元素nums[numsSize - 1]变为负
+    if(k % 2 == 1)
+        nums[numsSize - 1] *= -1;
+
+    return sum(nums, numsSize);
+}
+```
+
 ### TypeScript
 
 ```typescript
@@ -235,5 +275,6 @@ function largestSumAfterKNegations(nums: number[], k: number): number {
 
 
 
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>