diff --git a/problems/0053.最大子序和.md b/problems/0053.最大子序和.md
index b5fb7642..d0680a3b 100644
--- a/problems/0053.最大子序和.md
+++ b/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 {
+
-----------------------
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index 94614242..17a3b4f4 100644
--- a/problems/0055.跳跃游戏.md
+++ b/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
diff --git a/problems/0122.买卖股票的最佳时机II.md b/problems/0122.买卖股票的最佳时机II.md
index 78aa5952..1e7b77d8 100644
--- a/problems/0122.买卖股票的最佳时机II.md
+++ b/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];
+}
+```
+
-----------------------
diff --git a/problems/0135.分发糖果.md b/problems/0135.分发糖果.md
index b8bdae0e..72f3dd56 100644
--- a/problems/0135.分发糖果.md
+++ b/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 {
-
-----------------------
diff --git a/problems/0376.摆动序列.md b/problems/0376.摆动序列.md
index acd8996e..6822896e 100644
--- a/problems/0376.摆动序列.md
+++ b/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
**贪心**
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 80c47147..79767deb 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/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 {
+
-----------------------
