From e836f07ac69738301e13d6c626dc2f23e159deea Mon Sep 17 00:00:00 2001
From: youngyangyang04 <826123027@qq.com>
Date: Sun, 21 Nov 2021 15:56:19 +0800
Subject: [PATCH] Update

---
 problems/0045.跳跃游戏II.md               | 16 +++++------
 problems/0055.跳跃游戏.md                 | 22 +++++++--------
 ...1005.K次取反后最大化的数组和.md | 28 +++++++++----------
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/problems/0045.跳跃游戏II.md b/problems/0045.跳跃游戏II.md
index bd15ef85..b24abd43 100644
--- a/problems/0045.跳跃游戏II.md
+++ b/problems/0045.跳跃游戏II.md
@@ -6,7 +6,7 @@
 
 >  相对于[贪心算法：跳跃游戏](https://mp.weixin.qq.com/s/606_N9j8ACKCODoCbV1lSA)难了不少，做好心里准备！
 
-## 45.跳跃游戏II
+# 45.跳跃游戏II
 
 [力扣题目链接](https://leetcode-cn.com/problems/jump-game-ii/)
 
@@ -17,9 +17,9 @@
 你的目标是使用最少的跳跃次数到达数组的最后一个位置。
 
 示例:
-输入: [2,3,1,1,4]
-输出: 2
-解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+* 输入: [2,3,1,1,4]
+* 输出: 2
+* 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
 
 说明:
 假设你总是可以到达数组的最后一个位置。
@@ -139,7 +139,7 @@ public:
 ## 其他语言版本
 
 
-Java：
+### Java 
 ```Java
 class Solution {
     public int jump(int[] nums) {
@@ -171,7 +171,7 @@ class Solution {
 }
 ```
 
-Python：
+### Python
 ```python
 class Solution:
     def jump(self, nums: List[int]) -> int:
@@ -189,7 +189,7 @@ class Solution:
         return ans
 ```
 
-Go：
+### Go
 ```Go
 func jump(nums []int) int {
 	dp:=make([]int ,len(nums))
@@ -207,7 +207,7 @@ func jump(nums []int) int {
 }
 ```
 
-Javascript:
+### Javascript
 ```Javascript
 var jump = function(nums) {
     let curIndex = 0
diff --git a/problems/0055.跳跃游戏.md b/problems/0055.跳跃游戏.md
index 66d672d9..70a152fc 100644
--- a/problems/0055.跳跃游戏.md
+++ b/problems/0055.跳跃游戏.md
@@ -4,7 +4,7 @@
 </a>
 
 
-## 55. 跳跃游戏
+# 55. 跳跃游戏
 
 [力扣题目链接](https://leetcode-cn.com/problems/jump-game/)
 
@@ -15,14 +15,14 @@
 判断你是否能够到达最后一个位置。
 
 示例 1:
-输入: [2,3,1,1,4]
-输出: true
-解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
+* 输入: [2,3,1,1,4]
+* 输出: true
+* 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
 
 示例 2:
-输入: [3,2,1,0,4]
-输出: false
-解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
+* 输入: [3,2,1,0,4]
+* 输出: false
+* 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
 
 
 ## 思路
@@ -82,7 +82,7 @@ public:
 ## 其他语言版本
 
 
-Java：
+### Java 
 ```Java
 class Solution {
     public boolean canJump(int[] nums) {
@@ -103,7 +103,7 @@ class Solution {
 }
 ```
 
-Python：
+### Python
 ```python
 class Solution:
     def canJump(self, nums: List[int]) -> bool:
@@ -118,7 +118,7 @@ class Solution:
         return False
 ```
 
-Go：
+### Go
 ```Go
 func canJUmp(nums []int) bool {
 	if len(nums)<=1{
@@ -138,7 +138,7 @@ func canJUmp(nums []int) bool {
 }
 ```
 
-Javascript:
+### Javascript 
 ```Javascript
 var canJump = function(nums) {
     if(nums.length === 1) return true
diff --git a/problems/1005.K次取反后最大化的数组和.md b/problems/1005.K次取反后最大化的数组和.md
index 2a98f29e..56407e46 100644
--- a/problems/1005.K次取反后最大化的数组和.md
+++ b/problems/1005.K次取反后最大化的数组和.md
@@ -4,7 +4,7 @@
 </a>
 
 
-## 1005.K次取反后最大化的数组和
+# 1005.K次取反后最大化的数组和
 
 [力扣题目链接](https://leetcode-cn.com/problems/maximize-sum-of-array-after-k-negations/)
 
@@ -13,19 +13,19 @@
 以这种方式修改数组后，返回数组可能的最大和。
 
 示例 1：
-输入：A = [4,2,3], K = 1
-输出：5
-解释：选择索引 (1,) ，然后 A 变为 [4,-2,3]。
+* 输入：A = [4,2,3], K = 1
+* 输出：5
+* 解释：选择索引 (1,) ，然后 A 变为 [4,-2,3]。
 
 示例 2：
-输入：A = [3,-1,0,2], K = 3
-输出：6
-解释：选择索引 (1, 2, 2) ，然后 A 变为 [3,1,0,2]。
+* 输入：A = [3,-1,0,2], K = 3
+* 输出：6
+* 解释：选择索引 (1, 2, 2) ，然后 A 变为 [3,1,0,2]。
 
 示例 3：
-输入：A = [2,-3,-1,5,-4], K = 2
-输出：13
-解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。
+* 输入：A = [2,-3,-1,5,-4], K = 2
+* 输出：13
+* 解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。
 
 提示：
 
@@ -95,7 +95,7 @@ public:
 ## 其他语言版本
 
 
-Java：
+### Java 
 ```java
 class Solution {
     public int largestSumAfterKNegations(int[] nums, int K) {
@@ -145,7 +145,7 @@ class Solution {
 }
 ```
 
-Python：
+### Python
 ```python
 class Solution:
     def largestSumAfterKNegations(self, A: List[int], K: int) -> int:
@@ -159,7 +159,7 @@ class Solution:
         return sum(A)
 ```
 
-Go：
+### Go 
 ```Go
 func largestSumAfterKNegations(nums []int, K int) int {
 	sort.Slice(nums, func(i, j int) bool {
@@ -186,7 +186,7 @@ func largestSumAfterKNegations(nums []int, K int) int {
 ```
 
 
-Javascript:
+### Javascript 
 ```Javascript
 var largestSumAfterKNegations = function(nums, k) {
     nums.sort((a, b) => {