更新图床

problems/0005.最长回文子串.md

@@ -108,7 +108,7 @@ dp[i][j]可以初始化为true么？ 当然不行，怎能刚开始就全都匹
 
 dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：
 
-![647.回文子串](https://img-blog.csdnimg.cn/20210121171032473.jpg)
+![647.回文子串](https://code-thinking-1253855093.file.myqcloud.com/pics/20210121171032473.jpg)
 
 如果这矩阵是从上到下，从左到右遍历，那么会用到没有计算过的dp[i + 1][j - 1]，也就是根据不确定是不是回文的区间[i+1,j-1]，来判断了[i,j]是不是回文，那结果一定是不对的。
 
@@ -142,7 +142,7 @@ for (int i = s.size() - 1; i >= 0; i--) { // 注意遍历顺序
 
 举例，输入："aaa"，dp[i][j]状态如下：
 
-![647.回文子串1](https://img-blog.csdnimg.cn/20210121171059951.jpg)
+![647.回文子串1](https://code-thinking-1253855093.file.myqcloud.com/pics/20210121171059951.jpg)
 
 **注意因为dp[i][j]的定义，所以j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分**。
 

problems/0017.电话号码的字母组合.md

@@ -13,7 +13,7 @@
 
 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
 
-![17.电话号码的字母组合](https://img-blog.csdnimg.cn/2020102916424043.png)
+![17.电话号码的字母组合](https://code-thinking-1253855093.file.myqcloud.com/pics/2020102916424043.png)
 
 示例:
 * 输入："23"
@@ -66,7 +66,7 @@ const string letterMap[10] = {
 
 例如：输入："23"，抽象为树形结构，如图所示：
 
-![17. 电话号码的字母组合](https://img-blog.csdnimg.cn/20201123200304469.png)
+![17. 电话号码的字母组合](https://code-thinking-1253855093.file.myqcloud.com/pics/20201123200304469.png)
 
 图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]。
 

problems/0019.删除链表的倒数第N个节点.md

@@ -17,7 +17,8 @@
 
 示例 1：
 
-![19.删除链表的倒数第N个节点](https://img-blog.csdnimg.cn/20210510085957392.png)
+
+![19.删除链表的倒数第N个节点](https://code-thinking-1253855093.file.myqcloud.com/pics/20210510085957392.png)
 
 输入：head = [1,2,3,4,5], n = 2
 输出：[1,2,3,5]

problems/0020.有效的括号.md

@@ -80,14 +80,17 @@ cd a/b/c/../../
 
 先来分析一下 这里有三种不匹配的情况，
 
+
 1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
-![括号匹配1](https://img-blog.csdnimg.cn/2020080915505387.png)
+![括号匹配1](https://code-thinking-1253855093.file.myqcloud.com/pics/2020080915505387.png)
 
 2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。
-![括号匹配2](https://img-blog.csdnimg.cn/20200809155107397.png)
+![括号匹配2](https://code-thinking-1253855093.file.myqcloud.com/pics/20200809155107397.png)
 
 3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。
-![括号匹配3](https://img-blog.csdnimg.cn/20200809155115779.png)
+![括号匹配3](https://code-thinking-1253855093.file.myqcloud.com/pics/20200809155115779.png)
+
+
 
 我们的代码只要覆盖了这三种不匹配的情况，就不会出问题，可以看出 动手之前分析好题目的重要性。
 

problems/0035.搜索插入位置.md

@@ -1,3 +1,4 @@
+
 <p align="center">
 <a href="https://programmercarl.com/other/xunlianying.html" target="_blank">
   <img src="../pics/训练营.png" width="1000"/>
@@ -7,6 +8,7 @@
 
 
 
+
 # 35.搜索插入位置
 
 [力扣题目链接](https://leetcode.cn/problems/search-insert-position/)
@@ -16,18 +18,22 @@
 你可以假设数组中无重复元素。
 
 示例 1:
+
 * 输入: [1,3,5,6], 5
 * 输出: 2
 
-示例 2:
+示例 2:
+
 * 输入: [1,3,5,6], 2
 * 输出: 1
 
 示例 3:
+
 * 输入: [1,3,5,6], 7
 * 输出: 4
 
 示例 4:
+
 * 输入: [1,3,5,6], 0
 * 输出: 0
 
@@ -37,7 +43,7 @@
 
 这道题目，要在数组中插入目标值，无非是这四种情况。
 
-![35_搜索插入位置3](https://img-blog.csdnimg.cn/20201216232148471.png)
+![35_搜索插入位置3](https://code-thinking-1253855093.file.myqcloud.com/pics/20201216232148471.png)
 
 * 目标值在数组所有元素之前
 * 目标值等于数组中某一个元素
@@ -78,13 +84,14 @@ public:
 
 效率如下：
 
-![35_搜索插入位置](https://img-blog.csdnimg.cn/20201216232127268.png)
+![35_搜索插入位置](https://code-thinking-1253855093.file.myqcloud.com/pics/20201216232127268.png)
 
 ### 二分法
 
-既然暴力解法的时间复杂度是$O(n)$，就要尝试一下使用二分查找法。
+既然暴力解法的时间复杂度是O(n)，就要尝试一下使用二分查找法。
 
-![35_搜索插入位置4](https://img-blog.csdnimg.cn/202012162326354.png)
+
+![35_搜索插入位置4](https://code-thinking-1253855093.file.myqcloud.com/pics/202012162326354.png)
 
 大家注意这道题目的前提是数组是有序数组，这也是使用二分查找的基础条件。
 
@@ -94,7 +101,7 @@ public:
 
 大体讲解一下二分法的思路，这里来举一个例子，例如在这个数组中，使用二分法寻找元素为5的位置，并返回其下标。
 
-![35_搜索插入位置5](https://img-blog.csdnimg.cn/20201216232659199.png)
+![35_搜索插入位置5](https://code-thinking-1253855093.file.myqcloud.com/pics/20201216232659199.png)
 
 二分查找涉及的很多的边界条件，逻辑比较简单，就是写不好。
 
@@ -145,7 +152,7 @@ public:
 * 空间复杂度：O(1)
 
 效率如下：
-![35_搜索插入位置2](https://img-blog.csdnimg.cn/2020121623272877.png)
+![35_搜索插入位置2](https://code-thinking-1253855093.file.myqcloud.com/pics/2020121623272877.png)
 
 ### 二分法第二种写法
 
@@ -199,7 +206,7 @@ public:
 
 ## 其他语言版本
 
-### Java 
+### Java
 
 ```java
 class Solution {
@@ -226,11 +233,12 @@ class Solution {
     }
 }
 ```
+
 ```java
 //第二种二分法：左闭右开
 public int searchInsert(int[] nums, int target) {
     int left = 0;
-    int right = nums.length; 
+    int right = nums.length;
     while (left < right) { //左闭右开 [left, right)
         int middle = left + ((right - left) >> 1);
         if (nums[middle] > target) {
@@ -290,7 +298,8 @@ impl Solution {
 }
 ```
 
-### Python 
+### Python
+
 ```python
 class Solution:
     def searchInsert(self, nums: List[int], target: int) -> int:
@@ -308,7 +317,8 @@ class Solution:
         return right + 1
 ```
 
-### JavaScript 
+### JavaScript
+
 ```js
 var searchInsert = function (nums, target) {
   let l = 0, r = nums.length - 1, ans = nums.length;
@@ -350,7 +360,7 @@ function searchInsert(nums: number[], target: number): number {
 };
 ```
 
-### Swift 
+### Swift
 
 ```swift
 // 暴力法
@@ -383,7 +393,9 @@ func searchInsert(_ nums: [Int], _ target: Int) -> Int {
     return right + 1
 }
 ```
+
 ### Scala
+
 ```scala
 object Solution {
   def searchInsert(nums: Array[Int], target: Int): Int = {
@@ -404,7 +416,7 @@ object Solution {
 }
 ```
 
-### PHP 
+### PHP
 
 ```php
 // 二分法(1)：[左闭右闭]
@@ -429,11 +441,13 @@ function searchInsert($nums, $target)
     return $r + 1;
 }
 ```
+
 ### C
+
 ```c
 //版本一 [left, right]左闭右闭区间
 int searchInsert(int* nums, int numsSize, int target){
-    //左闭右开区间 [0 , numsSize-1] 
+    //左闭右开区间 [0 , numsSize-1]
         int left =0;
         int mid =0;
         int right = numsSize - 1;
@@ -451,14 +465,15 @@ int searchInsert(int* nums, int numsSize, int target){
             }
         }
         //数组中未找到target元素
-        //target在数组所有元素之后，[left, right]是右闭区间，需要返回 right +1 
+        //target在数组所有元素之后，[left, right]是右闭区间，需要返回 right +1
         return right + 1;
 }
 ```
+
 ```c
 //版本二 [left, right]左闭右开区间
 int searchInsert(int* nums, int numsSize, int target){
-    //左闭右开区间 [0 , numsSize) 
+    //左闭右开区间 [0 , numsSize)
         int left =0;
         int mid =0;
         int right = numsSize;