From 8a2d42013cb21c7517df40009bea9e07f1fa92a9 Mon Sep 17 00:00:00 2001
From: youngyangyang04 <826123027@qq.com>
Date: Tue, 10 Aug 2021 22:20:48 +0800
Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BB=A3=E7=A0=81=E5=9D=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...36\346\226\207\345\255\220\344\270\262.md" | 12 +++++-----
 ...11\346\225\260\344\271\213\345\222\214.md" |  4 ++--
 ...33\346\225\260\344\271\213\345\222\214.md" |  2 +-
 ...4N\344\270\252\350\212\202\347\202\271.md" |  2 +-
 ...10\347\232\204\346\213\254\345\217\267.md" |  2 +-
 ...55\347\232\204\350\212\202\347\202\271.md" |  2 +-
 ...73\351\231\244\345\205\203\347\264\240.md" |  4 ++--
 .../0028.\345\256\236\347\216\260strStr.md"   | 12 +++++-----
 ...00\344\270\252\346\216\222\345\210\227.md" |  2 +-
 ...00\344\270\252\344\275\215\347\275\256.md" |  6 ++---
 ...22\345\205\245\344\275\215\347\275\256.md" |  4 ++--
 ...7.\350\247\243\346\225\260\347\213\254.md" |  6 ++---
 ...04\345\220\210\346\200\273\345\222\214.md" | 10 ++++----
 ...\345\220\210\346\200\273\345\222\214II.md" | 10 ++++----
 ...2.\346\216\245\351\233\250\346\260\264.md" | 16 ++++++-------
 ...\350\267\203\346\270\270\346\210\217II.md" |  4 ++--
 ...6.\345\205\250\346\216\222\345\210\227.md" |  2 +-
 "problems/0051.N\347\232\207\345\220\216.md"  |  2 +-
 ...47\345\255\220\345\272\217\345\222\214.md" |  6 ++---
 ...01\350\247\204\345\210\222\357\274\211.md" |  2 +-
 ...63\350\267\203\346\270\270\346\210\217.md" |  2 +-
 ...10\345\271\266\345\214\272\351\227\264.md" |  4 ++--
 ...\346\227\213\347\237\251\351\230\265II.md" |  2 +-
 ...15\345\220\214\350\267\257\345\276\204.md" | 10 ++++----
 ...\345\220\214\350\267\257\345\276\204II.md" |  6 ++---
 ...0.\347\210\254\346\245\274\346\242\257.md" |  6 ++---
 ...26\350\276\221\350\267\235\347\246\273.md" |  8 +++----
 "problems/0077.\347\273\204\345\220\210.md"   |  4 ++--
 "problems/0078.\345\255\220\351\233\206.md"   |  2 +-
 ...47\347\232\204\347\237\251\345\275\242.md" |  8 +++----
 "problems/0090.\345\255\220\351\233\206II.md" |  2 +-
 ...\345\216\237IP\345\234\260\345\235\200.md" |  2 +-
 ...11\346\220\234\347\264\242\346\240\221.md" |  4 ++--
 ...11\346\220\234\347\264\242\346\240\221.md" | 12 +++++-----
 ...70\345\220\214\347\232\204\346\240\221.md" | 10 ++++----
 ...60\344\272\214\345\217\211\346\240\221.md" | 12 +++++-----
 ...02\345\272\217\351\201\215\345\216\206.md" | 20 ++++++++--------
 ...40\344\272\214\345\217\211\346\240\221.md" | 14 +++++------
 ...11\346\220\234\347\264\242\346\240\221.md" |  4 ++--
 ...41\344\272\214\345\217\211\346\240\221.md" | 18 +++++++-------
 ...00\345\260\217\346\267\261\345\272\246.md" |  8 +++----
 ...57\345\276\204\346\200\273\345\222\214.md" | 12 +++++-----
 ...04\345\255\220\345\272\217\345\210\227.md" |  6 ++---
 ...02\347\202\271\346\214\207\351\222\210.md" |  6 ++---
 ...00\344\275\263\346\227\266\346\234\272.md" |  8 +++----
 ...\344\275\263\346\227\266\346\234\272II.md" |  4 ++--
 ...01\350\247\204\345\210\222\357\274\211.md" |  4 ++--
 ...344\275\263\346\227\266\346\234\272III.md" |  4 ++--
 ...60\345\255\227\344\271\213\345\222\214.md" |  8 +++----
 ...62\345\233\236\346\226\207\344\270\262.md" | 12 +++++-----
 ...\345\233\236\346\226\207\344\270\262II.md" | 10 ++++----
 ...4.\345\212\240\346\262\271\347\253\231.md" |  6 ++---
 ...06\345\217\221\347\263\226\346\236\234.md" |  6 ++---
 ...25\350\257\215\346\213\206\345\210\206.md" |  6 ++---
 ...57\345\275\242\351\223\276\350\241\250.md" |  2 +-
 ...\345\275\242\351\223\276\350\241\250II.md" |  2 +-
 ...15\346\216\222\351\223\276\350\241\250.md" |  6 ++---
 ...76\345\274\217\346\261\202\345\200\274.md" |  2 +-
 ...14\347\232\204\345\215\225\350\257\215.md" |  6 ++---
 ...\344\275\263\346\227\266\346\234\272IV.md" |  6 ++---
 ...13\350\275\254\346\225\260\347\273\204.md" |  2 +-
 ...23\345\256\266\345\212\253\350\210\215.md" |  6 ++---
 ...2.\345\277\253\344\271\220\346\225\260.md" |  2 +-
 ...76\350\241\250\345\205\203\347\264\240.md" |  4 ++--
 ...04\345\255\227\347\254\246\344\270\262.md" |  2 +-
 ...73\350\275\254\351\223\276\350\241\250.md" |  4 ++--
 ...04\345\255\220\346\225\260\347\273\204.md" |  4 ++--
 ...\345\256\266\345\212\253\350\210\215II.md" |  2 +-
 ...345\220\210\346\200\273\345\222\214III.md" |  6 ++---
 ...02\347\202\271\344\270\252\346\225\260.md" |  8 +++----
 ...27\345\256\236\347\216\260\346\240\210.md" |  4 ++--
 ...54\344\272\214\345\217\211\346\240\221.md" | 12 +++++-----
 ...36\347\216\260\351\230\237\345\210\227.md" |  2 +-
 ...36\346\226\207\351\223\276\350\241\250.md" |  6 ++---
 ...54\345\205\261\347\245\226\345\205\210.md" |  8 +++----
 ...54\345\205\261\347\245\226\345\205\210.md" |  6 ++---
 ...43\346\234\200\345\244\247\345\200\274.md" |  4 ++--
 ...15\345\274\202\344\275\215\350\257\215.md" |  2 +-
 ...00\346\234\211\350\267\257\345\276\204.md" | 20 ++++++++--------
 ...50\345\271\263\346\226\271\346\225\260.md" |  6 ++---
 ...3.\347\247\273\345\212\250\351\233\266.md" |  2 +-
 ...07\345\255\220\345\272\217\345\210\227.md" |  4 ++--
 ...53\345\206\267\345\206\273\346\234\237.md" |  4 ++--
 ...66\351\222\261\345\205\221\346\215\242.md" |  4 ++--
 ...11\346\216\222\350\241\214\347\250\213.md" |  4 ++--
 ...345\256\266\345\212\253\350\210\215III.md" | 12 +++++-----
 ...64\346\225\260\346\213\206\345\210\206.md" |  6 ++---
 ...54\345\255\227\347\254\246\344\270\262.md" |  8 +++----
 ...30\351\242\221\345\205\203\347\264\240.md" |  2 +-
 ...04\347\232\204\344\272\244\351\233\206.md" |  2 +-
 ...06\345\212\250\345\272\217\345\210\227.md" |  2 +-
 ...10\346\200\273\345\222\214\342\205\243.md" |  2 +-
 ...3.\350\265\216\351\207\221\344\277\241.md" |  4 ++--
 ...55\345\255\220\345\272\217\345\210\227.md" |  2 +-
 ...66\345\255\220\344\271\213\345\222\214.md" |  8 +++----
 ...15\345\273\272\351\230\237\345\210\227.md" |  4 ++--
 ...11\345\222\214\345\255\220\351\233\206.md" |  6 ++---
 ...15\345\217\240\345\214\272\351\227\264.md" |  4 ++--
 ...55\347\232\204\350\212\202\347\202\271.md" |  8 +++----
 ...25\347\210\206\346\260\224\347\220\203.md" |  2 +-
 ...\346\225\260\347\233\270\345\212\240II.md" |  2 +-
 ...06\345\217\221\351\245\274\345\271\262.md" |  4 ++--
 ...20\345\255\227\347\254\246\344\270\262.md" |  4 ++--
 ...77\347\232\204\345\221\250\351\225\277.md" |  4 ++--
 ...4.\344\270\200\345\222\214\351\233\266.md" |  4 ++--
 ...36\345\255\220\345\272\217\345\210\227.md" |  4 ++--
 ...4.\347\233\256\346\240\207\345\222\214.md" |  6 ++---
 ...4\345\244\247\345\205\203\347\264\240I.md" |  8 +++----
 ...55\347\232\204\344\274\227\346\225\260.md" | 12 +++++-----
 ...\345\244\247\345\205\203\347\264\240II.md" |  4 ++--
 ...42\351\202\243\345\245\221\346\225\260.md" |  6 ++---
 ...13\350\247\222\347\232\204\345\200\274.md" | 12 +++++-----
 ...07\345\255\220\345\272\217\345\210\227.md" |  8 +++----
 ...\351\222\261\345\205\221\346\215\242II.md" |  4 ++--
 ...17\347\273\235\345\257\271\345\267\256.md" |  6 ++---
 ...72\347\264\257\345\212\240\346\240\221.md" |  4 ++--
 ...\345\255\227\347\254\246\344\270\262II.md" |  4 ++--
 ...40\351\231\244\346\223\215\344\275\234.md" |  4 ++--
 ...66\344\272\214\345\217\211\346\240\221.md" | 12 +++++-----
 ...36\346\226\207\345\255\220\344\270\262.md" | 10 ++++----
 ...a2\345\217\202\350\256\256\351\231\242.md" |  2 +-
 ...47\344\272\214\345\217\211\346\240\221.md" |  6 ++---
 ...24\345\233\236\345\216\237\347\202\271.md" |  2 +-
 ...11\346\220\234\347\264\242\346\240\221.md" |  8 +++----
 ...27\347\232\204\344\270\252\346\225\260.md" | 12 +++++-----
 ...22\345\242\236\345\272\217\345\210\227.md" |  6 ++---
 ...27\344\275\231\350\277\236\346\216\245.md" |  4 ++--
 ...\344\275\231\350\277\236\346\216\245II.md" |  6 ++---
 ...55\347\232\204\346\220\234\347\264\242.md" |  4 ++--
 ...22\345\205\245\346\223\215\344\275\234.md" |  6 ++---
 ...14\345\210\206\346\237\245\346\211\276.md" |  4 ++--
 ...76\350\256\241\351\223\276\350\241\250.md" |  2 +-
 ...53\346\211\213\347\273\255\350\264\271.md" |  6 ++---
 ...01\350\247\204\345\210\222\357\274\211.md" |  2 +-
 ...15\345\255\220\346\225\260\347\273\204.md" |  6 ++---
 ...55\345\277\203\347\264\242\345\274\225.md" |  2 +-
 ...36\347\232\204\346\225\260\345\255\227.md" |  4 ++--
 ...17\346\227\245\346\270\251\345\272\246.md" |  4 ++--
 ...71\347\210\254\346\245\274\346\242\257.md" |  6 ++---
 ...27\346\257\215\345\214\272\351\227\264.md" |  2 +-
 ...31\345\222\214\346\210\277\351\227\264.md" |  4 ++--
 ...04\345\255\227\347\254\246\344\270\262.md" |  6 ++---
 ...54\346\260\264\346\211\276\351\233\266.md" |  2 +-
 ...\345\272\217\346\225\260\347\273\204II.md" |  6 ++---
 ...77\346\214\211\351\224\256\345\205\245.md" |  2 +-
 ...47\344\272\214\345\217\211\346\240\221.md" |  4 ++--
 ...04\347\232\204\345\271\263\346\226\271.md" |  4 ++--
 ...70\347\224\250\345\255\227\347\254\246.md" |  2 +-
 ...04\346\225\260\347\273\204\345\222\214.md" |  2 +-
 ...70\344\272\244\347\232\204\347\272\277.md" |  2 +-
 ...73\351\207\215\345\244\215\351\241\271.md" |  4 ++--
 ...\347\232\204\351\207\215\351\207\217II.md" |  4 ++--
 ...61\345\255\220\345\272\217\345\210\227.md" |  4 ++--
 ...72\347\216\260\346\254\241\346\225\260.md" |  2 +-
 ...60\347\233\256\346\216\222\345\272\217.md" |  6 ++---
 ...27\347\232\204\346\225\260\345\255\227.md" |  6 ++---
 ...21\345\217\230\345\271\263\350\241\241.md" |  2 +-
 ...57\345\244\232\345\244\247\357\274\237.md" | 10 ++++----
 ...11\346\255\245\351\223\272\345\236\253.md" |  6 ++---
 ...46\347\235\200\345\233\236\346\272\257.md" | 10 ++++----
 ...00\350\277\255\344\273\243\346\263\225.md" |  6 ++---
 ...55\344\273\243\351\201\215\345\216\206.md" |  6 ++---
 ...22\345\275\222\351\201\215\345\216\206.md" |  6 ++---
 ...57\345\244\232\345\244\247\357\274\237.md" | 10 ++++----
 ...CM\346\250\241\345\274\217\357\274\237.md" |  8 +++----
 ...43\347\240\201\351\243\216\346\240\274.md" |  2 +-
 ...52\347\226\221\351\227\256\357\274\237.md" |  4 ++--
 ...10\350\200\227\344\271\210\357\274\237.md" |  2 +-
 ...21\350\277\220\350\241\214\357\274\237.md" |  2 +-
 ...02\345\272\246\345\210\206\346\236\220.md" | 14 +++++------
 ...15\346\235\202\345\272\246\357\274\201.md" | 10 ++++----
 ...77\346\215\242\347\251\272\346\240\274.md" |  2 +-
 ...54\345\255\227\347\254\246\344\270\262.md" |  2 +-
 ...30\346\200\273\347\273\223\347\257\207.md" | 24 +++++++++----------
 ...50\346\234\253\346\200\273\347\273\223.md" |  8 +++----
 ...50\346\234\253\346\200\273\347\273\223.md" | 14 +++++------
 ...50\346\234\253\346\200\273\347\273\223.md" |  2 +-
 ...50\346\234\253\346\200\273\347\273\223.md" |  6 ++---
 ...50\346\234\253\346\200\273\347\273\223.md" |  6 ++---
 ...50\346\234\253\346\200\273\347\273\223.md" |  2 +-
 ...50\346\234\253\346\200\273\347\273\223.md" | 12 +++++-----
 ...50\346\234\253\346\200\273\347\273\223.md" | 16 ++++++-------
 ...50\346\234\253\346\200\273\347\273\223.md" |  4 ++--
 ...23\347\263\273\345\210\227\344\270\200.md" | 12 +++++-----
 ...00\347\247\215\345\206\231\346\263\225.md" | 10 ++++----
 ...06\350\256\272\345\237\272\347\241\200.md" |  2 +-
 ...06\350\256\262\350\247\243\357\274\211.md" |  6 ++---
 ...47\241\20001\350\203\214\345\214\205-1.md" |  2 +-
 ...47\241\20001\350\203\214\345\214\205-2.md" |  2 +-
 ...32\351\207\215\350\203\214\345\214\205.md" |  4 ++--
 ...14\345\205\250\350\203\214\345\214\205.md" |  8 +++----
 ...76\350\241\250\347\233\270\344\272\244.md" |  2 +-
 192 files changed, 552 insertions(+), 552 deletions(-)

diff --git "a/problems/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md" "b/problems/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md"
index def649a786..0f4cb2f68d 100644
--- "a/problems/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md"
+++ "b/problems/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.md"
@@ -67,7 +67,7 @@
 
 以上三种情况分析完了，那么递归公式如下：
 
-```C++
+```CPP
 if (s[i] == s[j]) {
     if (j - i <= 1) { // 情况一 和 情况二
         dp[i][j] = true;
@@ -81,7 +81,7 @@ if (s[i] == s[j]) {
 
 在得到[i,j]区间是否是回文子串的时候，直接保存最长回文子串的左边界和右边界，代码如下：
 
-```C++
+```CPP
 if (s[i] == s[j]) {
     if (j - i <= 1) { // 情况一 和 情况二
         dp[i][j] = true;
@@ -120,7 +120,7 @@ dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：
 
 代码如下：
 
-```C++
+```CPP
 for (int i = s.size() - 1; i >= 0; i--) { // 注意遍历顺序
     for (int j = i; j < s.size(); j++) {
         if (s[i] == s[j]) {
@@ -150,7 +150,7 @@ for (int i = s.size() - 1; i >= 0; i--) { // 注意遍历顺序
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string longestPalindrome(string s) {
@@ -181,7 +181,7 @@ public:
 ```
 以上代码是为了凸显情况一二三，当然是可以简洁一下的，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string longestPalindrome(string s) {
@@ -226,7 +226,7 @@ public:
 
 **这两种情况可以放在一起计算，但分别计算思路更清晰，我倾向于分别计算**，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int left = 0;
diff --git "a/problems/0015.\344\270\211\346\225\260\344\271\213\345\222\214.md" "b/problems/0015.\344\270\211\346\225\260\344\271\213\345\222\214.md"
index b4cdbd1e26..9a3a8d5bbe 100644
--- "a/problems/0015.\344\270\211\346\225\260\344\271\213\345\222\214.md"
+++ "b/problems/0015.\344\270\211\346\225\260\344\271\213\345\222\214.md"
@@ -46,7 +46,7 @@ https://leetcode-cn.com/problems/3sum/
 大家可以尝试使用哈希法写一写，就知道其困难的程度了。
 
 哈希法C++代码:
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> threeSum(vector<int>& nums) {
@@ -107,7 +107,7 @@ public:
 
 C++代码代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> threeSum(vector<int>& nums) {
diff --git "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md" "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
index 1958b1889a..75cd9e8e0a 100644
--- "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
+++ "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
@@ -67,7 +67,7 @@ https://leetcode-cn.com/problems/4sum/
 
 C++代码
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> fourSum(vector<int>& nums, int target) {
diff --git "a/problems/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md" "b/problems/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
index 02939249c4..3e1a682c45 100644
--- "a/problems/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
+++ "b/problems/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.md"
@@ -58,7 +58,7 @@
 
 此时不难写出如下C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     ListNode* removeNthFromEnd(ListNode* head, int n) {
diff --git "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
index 39358befb9..a26aa3082f 100644
--- "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
+++ "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -108,7 +108,7 @@ cd a/b/c/../../
 实现C++代码如下：
 
 
-```C++
+```CPP
 class Solution {
 public:
     bool isValid(string s) {
diff --git "a/problems/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md" "b/problems/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
index 0047d18611..91e566ddd6 100644
--- "a/problems/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
+++ "b/problems/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.md"
@@ -43,7 +43,7 @@ https://leetcode-cn.com/problems/swap-nodes-in-pairs/
 
 对应的C++代码实现如下： （注释中详细和如上图中的三步做对应）
 
-```C++
+```CPP
 class Solution {
 public:
     ListNode* swapPairs(ListNode* head) {
diff --git "a/problems/0027.\347\247\273\351\231\244\345\205\203\347\264\240.md" "b/problems/0027.\347\247\273\351\231\244\345\205\203\347\264\240.md"
index ecf91d410e..3819d6a56e 100644
--- "a/problems/0027.\347\247\273\351\231\244\345\205\203\347\264\240.md"
+++ "b/problems/0027.\347\247\273\351\231\244\345\205\203\347\264\240.md"
@@ -48,7 +48,7 @@
 
 代码如下：
 
-```C++
+```CPP
 // 时间复杂度：O(n^2)
 // 空间复杂度：O(1)
 class Solution {
@@ -85,7 +85,7 @@ public:
 
 后序都会一一介绍到，本题代码如下：
 
-```C++
+```CPP
 // 时间复杂度：O(n)
 // 空间复杂度：O(1)
 class Solution {
diff --git "a/problems/0028.\345\256\236\347\216\260strStr.md" "b/problems/0028.\345\256\236\347\216\260strStr.md"
index dadee4ffe9..4fb418f03a 100644
--- "a/problems/0028.\345\256\236\347\216\260strStr.md"
+++ "b/problems/0028.\345\256\236\347\216\260strStr.md"
@@ -315,7 +315,7 @@ next[i] = j;
 
 最后整体构建next数组的函数代码如下：
 
-```C++
+```CPP
 void getNext(int* next, const string& s){
     int j = -1;
     next[0] = j;
@@ -386,7 +386,7 @@ if (j == (t.size() - 1) ) {
 
 那么使用next数组，用模式串匹配文本串的整体代码如下：
 
-```C++
+```CPP
 int j = -1; // 因为next数组里记录的起始位置为-1
 for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
     while(j >= 0 && s[i] != t[j + 1]) { // 不匹配
@@ -405,7 +405,7 @@ for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
 
 # 前缀表统一减一 C++代码实现
 
-```C++
+```CPP
 class Solution {
 public:
     void getNext(int* next, const string& s) {
@@ -457,7 +457,7 @@ public:
 
 我给出的getNext的实现为：（前缀表统一减一）
 
-```C++
+```CPP
 void getNext(int* next, const string& s) {
     int j = -1;
     next[0] = j;
@@ -479,7 +479,7 @@ void getNext(int* next, const string& s) {
 
 那么前缀表不减一来构建next数组，代码如下：
 
-```C++
+```CPP
     void getNext(int* next, const string& s) {
         int j = 0;
         next[0] = 0;
@@ -502,7 +502,7 @@ void getNext(int* next, const string& s) {
 
 实现代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void getNext(int* next, const string& s) {
diff --git "a/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md" "b/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md"
index 5edc732171..10ac9df4d1 100644
--- "a/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md"
+++ "b/problems/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.md"
@@ -75,7 +75,7 @@
 
 对应的C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void nextPermutation(vector<int>& nums) {
diff --git "a/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md" "b/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md"
index 2a31994d13..f83de1a865 100644
--- "a/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md"
+++ "b/problems/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.md"
@@ -64,7 +64,7 @@
 
 可以写出如下代码
 
-```C++
+```CPP
 // 二分查找，寻找target的右边界（不包括target）
 // 如果rightBorder为没有被赋值（即target在数组范围的左边，例如数组[3,3]，target为2），为了处理情况一
 int getRightBorder(vector<int>& nums, int target) {
@@ -86,7 +86,7 @@ int getRightBorder(vector<int>& nums, int target) {
 
 ## 寻找左边界
 
-```C++
+```CPP
 // 二分查找，寻找target的左边界leftBorder（不包括target）
 // 如果leftBorder没有被赋值（即target在数组范围的右边，例如数组[3,3],target为4），为了处理情况一
 int getLeftBorder(vector<int>& nums, int target) {
@@ -110,7 +110,7 @@ int getLeftBorder(vector<int>& nums, int target) {
 
 左右边界计算完之后，看一下主体代码，这里把上面讨论的三种情况，都覆盖了
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> searchRange(vector<int>& nums, int target) {
diff --git "a/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md" "b/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
index 0160455882..4ad8a80c20 100644
--- "a/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
+++ "b/problems/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.md"
@@ -116,7 +116,7 @@ public:
 
 **大家要仔细看注释，思考为什么要写while(left <= right)， 为什么要写right = middle - 1**。
 
-```C++
+```CPP
 class Solution {
 public:
     int searchInsert(vector<int>& nums, int target) {
@@ -158,7 +158,7 @@ public:
 
 **大家要仔细看注释，思考为什么要写while (left < right)， 为什么要写right = middle**。
 
-```C++
+```CPP
 class Solution {
 public:
     int searchInsert(vector<int>& nums, int target) {
diff --git "a/problems/0037.\350\247\243\346\225\260\347\213\254.md" "b/problems/0037.\350\247\243\346\225\260\347\213\254.md"
index 7617d98983..64be7013f4 100644
--- "a/problems/0037.\350\247\243\346\225\260\347\213\254.md"
+++ "b/problems/0037.\350\247\243\346\225\260\347\213\254.md"
@@ -90,7 +90,7 @@ bool backtracking(vector<vector<char>>& board)
 
 代码如下：（**详细看注释**）
 
-```C++
+```CPP
 bool backtracking(vector<vector<char>>& board) {
     for (int i = 0; i < board.size(); i++) {        // 遍历行
         for (int j = 0; j < board[0].size(); j++) { // 遍历列
@@ -125,7 +125,7 @@ bool backtracking(vector<vector<char>>& board) {
 
 代码如下：
 
-```C++
+```CPP
 bool isValid(int row, int col, char val, vector<vector<char>>& board) {
     for (int i = 0; i < 9; i++) { // 判断行里是否重复
         if (board[row][i] == val) {
@@ -154,7 +154,7 @@ bool isValid(int row, int col, char val, vector<vector<char>>& board) {
 
 ## C++代码
 
-```C++
+```CPP
 class Solution {
 private:
 bool backtracking(vector<vector<char>>& board) {
diff --git "a/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md" "b/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
index 56a4c73703..0c452e225c 100644
--- "a/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
+++ "b/problems/0039.\347\273\204\345\220\210\346\200\273\345\222\214.md"
@@ -73,7 +73,7 @@ candidates 中的数字可以无限制重复被选取。
 
 代码如下：
 
-```C++
+```CPP
 vector<vector<int>> result;
 vector<int> path;
 void backtracking(vector<int>& candidates, int target, int sum, int startIndex)
@@ -89,7 +89,7 @@ void backtracking(vector<int>& candidates, int target, int sum, int startIndex)
 
 sum等于target的时候，需要收集结果，代码如下：
 
-```C++
+```CPP
 if (sum > target) {
     return;
 }
@@ -107,7 +107,7 @@ if (sum == target) {
 
 如何重复选取呢，看代码，注释部分：
 
-```C++
+```CPP
 for (int i = startIndex; i < candidates.size(); i++) {
     sum += candidates[i];
     path.push_back(candidates[i]);
@@ -119,7 +119,7 @@ for (int i = startIndex; i < candidates.size(); i++) {
 
 按照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中给出的模板，不难写出如下C++完整代码：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 private:
@@ -179,7 +179,7 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;
 
 整体代码如下：（注意注释的部分）
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md" "b/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
index e4d58f5452..5ea11ca7e7 100644
--- "a/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
+++ "b/problems/0040.\347\273\204\345\220\210\346\200\273\345\222\214II.md"
@@ -90,7 +90,7 @@ candidates 中的每个数字在每个组合中只能使用一次。
 
 代码如下：
 
-```C++
+```CPP
 vector<vector<int>> result; // 存放组合集合
 vector<int> path;           // 符合条件的组合
 void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
@@ -102,7 +102,7 @@ void backtracking(vector<int>& candidates, int target, int sum, int startIndex,
 
 代码如下：
 
-```C++
+```CPP
 if (sum > target) { // 这个条件其实可以省略
     return;
 }
@@ -137,7 +137,7 @@ if (sum == target) {
 
 那么单层搜索的逻辑代码如下：
 
-```C++
+```CPP
 for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
     // used[i - 1] == true，说明同一树支candidates[i - 1]使用过
     // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
@@ -161,7 +161,7 @@ for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target;
 
 回溯三部曲分析完了，整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -206,7 +206,7 @@ public:
 
 这里直接用startIndex来去重也是可以的， 就不用used数组了。
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/0042.\346\216\245\351\233\250\346\260\264.md" "b/problems/0042.\346\216\245\351\233\250\346\260\264.md"
index 54086dc739..235776a0e2 100644
--- "a/problems/0042.\346\216\245\351\233\250\346\260\264.md"
+++ "b/problems/0042.\346\216\245\351\233\250\346\260\264.md"
@@ -77,7 +77,7 @@
 一样的方法，只要从头遍历一遍所有的列，然后求出每一列雨水的体积，相加之后就是总雨水的体积了。 
 
 首先从头遍历所有的列，并且**要注意第一个柱子和最后一个柱子不接雨水**，代码如下：
-```C++
+```CPP
 for (int i = 0; i < height.size(); i++) {
     // 第一个柱子和最后一个柱子不接雨水
     if (i == 0 || i == height.size() - 1) continue;
@@ -86,7 +86,7 @@ for (int i = 0; i < height.size(); i++) {
 
 在for循环中求左右两边最高柱子，代码如下：
 
-```C++
+```CPP
 int rHeight = height[i]; // 记录右边柱子的最高高度
 int lHeight = height[i]; // 记录左边柱子的最高高度
 for (int r = i + 1; r < height.size(); r++) {
@@ -99,14 +99,14 @@ for (int l = i - 1; l >= 0; l--) {
 
 最后，计算该列的雨水高度，代码如下：
 
-```C++
+```CPP
 int h = min(lHeight, rHeight) - height[i];
 if (h > 0) sum += h; // 注意只有h大于零的时候，在统计到总和中
 ```
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int trap(vector<int>& height) {
@@ -152,7 +152,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int trap(vector<int>& height) {
@@ -287,7 +287,7 @@ if (height[i] == height[st.top()]) { // 例如 5 5 1 7 这种情况
 
 求当前凹槽雨水的体积代码如下：
 
-```C++
+```CPP
 while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，持续跟新栈顶元素
     int mid = st.top();
     st.pop();
@@ -301,7 +301,7 @@ while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，
 
 关键部分讲完了，整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int trap(vector<int>& height) {
@@ -335,7 +335,7 @@ public:
 
 以上代码冗余了一些，但是思路是清晰的，下面我将代码精简一下，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int trap(vector<int>& height) {
diff --git "a/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md" "b/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
index fe93cc3a2b..d946315b8e 100644
--- "a/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
+++ "b/problems/0045.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -63,7 +63,7 @@
 
 C++代码如下：（详细注释）
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -106,7 +106,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0046.\345\205\250\346\216\222\345\210\227.md" "b/problems/0046.\345\205\250\346\216\222\345\210\227.md"
index 70f1cf53a0..c0626fb759 100644
--- "a/problems/0046.\345\205\250\346\216\222\345\210\227.md"
+++ "b/problems/0046.\345\205\250\346\216\222\345\210\227.md"
@@ -106,7 +106,7 @@ for (int i = 0; i < nums.size(); i++) {
 整体C++代码如下：
 
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> result;
diff --git "a/problems/0051.N\347\232\207\345\220\216.md" "b/problems/0051.N\347\232\207\345\220\216.md"
index ce04258d4d..387e75c3bf 100644
--- "a/problems/0051.N\347\232\207\345\220\216.md"
+++ "b/problems/0051.N\347\232\207\345\220\216.md"
@@ -171,7 +171,7 @@ bool isValid(int row, int col, vector<string>& chessboard, int n) {
 
 ## C++代码
 
-```C++
+```CPP
 class Solution {
 private:
 vector<vector<string>> result;
diff --git "a/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md" "b/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md"
index cf4d19ec12..cba7d6c7be 100644
--- "a/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md"
+++ "b/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.md"
@@ -25,7 +25,7 @@
 
 时间复杂度：O(n^2)
 空间复杂度：O(1)
-```C++
+```CPP
 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
@@ -81,7 +81,7 @@ if (count > result) result = count;
 
 那么不难写出如下C++代码（关键地方已经注释）
 
-```C++
+```CPP
 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
@@ -109,7 +109,7 @@ public:
 
 那么先给出我的dp代码如下，有时间的录友可以提前做一做：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
diff --git "a/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md" "b/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
index da81f8a340..0932c77ff0 100644
--- "a/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
+++ "b/problems/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
@@ -65,7 +65,7 @@ dp[0]应该是多少呢?
 
 以上动规五部曲分析完毕，完整代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxSubArray(vector<int>& nums) {
diff --git "a/problems/0055.\350\267\263\350\267\203\346\270\270\346\210\217.md" "b/problems/0055.\350\267\263\350\267\203\346\270\270\346\210\217.md"
index 9019c81039..0b1c1d368a 100644
--- "a/problems/0055.\350\267\263\350\267\203\346\270\270\346\210\217.md"
+++ "b/problems/0055.\350\267\263\350\267\203\346\270\270\346\210\217.md"
@@ -58,7 +58,7 @@ i每次移动只能在cover的范围内移动，每移动一个元素，cover得
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool canJump(vector<int>& nums) {
diff --git "a/problems/0056.\345\220\210\345\271\266\345\214\272\351\227\264.md" "b/problems/0056.\345\220\210\345\271\266\345\214\272\351\227\264.md"
index 804b827b71..99c870c622 100644
--- "a/problems/0056.\345\220\210\345\271\266\345\214\272\351\227\264.md"
+++ "b/problems/0056.\345\220\210\345\271\266\345\214\272\351\227\264.md"
@@ -56,7 +56,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     // 按照区间左边界从小到大排序
@@ -92,7 +92,7 @@ public:
 
 当然以上代码有冗余一些，可以优化一下，如下：（思路是一样的）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> merge(vector<vector<int>>& intervals) {
diff --git "a/problems/0059.\350\236\272\346\227\213\347\237\251\351\230\265II.md" "b/problems/0059.\350\236\272\346\227\213\347\237\251\351\230\265II.md"
index 15186e78fb..e46dae6d9c 100644
--- "a/problems/0059.\350\236\272\346\227\213\347\237\251\351\230\265II.md"
+++ "b/problems/0059.\350\236\272\346\227\213\347\237\251\351\230\265II.md"
@@ -66,7 +66,7 @@
 
 整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> generateMatrix(int n) {
diff --git "a/problems/0062.\344\270\215\345\220\214\350\267\257\345\276\204.md" "b/problems/0062.\344\270\215\345\220\214\350\267\257\345\276\204.md"
index 629c6eb177..84c84075ef 100644
--- "a/problems/0062.\344\270\215\345\220\214\350\267\257\345\276\204.md"
+++ "b/problems/0062.\344\270\215\345\220\214\350\267\257\345\276\204.md"
@@ -59,7 +59,7 @@
 
 此时问题就可以转化为求二叉树叶子节点的个数，代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int dfs(int i, int j, int m, int n) {
@@ -128,7 +128,7 @@ for (int j = 0; j < n; j++) dp[0][j] = 1;
 
 以上动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int uniquePaths(int m, int n) {
@@ -149,7 +149,7 @@ public:
 
 其实用一个一维数组（也可以理解是滚动数组）就可以了，但是不利于理解，可以优化点空间，建议先理解了二维，在理解一维，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int uniquePaths(int m, int n) {
@@ -187,7 +187,7 @@ public:
 
 例如如下代码是不行的。
 
-```C++
+```CPP
 class Solution {
 public:
     int uniquePaths(int m, int n) {
@@ -204,7 +204,7 @@ public:
 
 需要在计算分子的时候，不断除以分母，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int uniquePaths(int m, int n) {
diff --git "a/problems/0063.\344\270\215\345\220\214\350\267\257\345\276\204II.md" "b/problems/0063.\344\270\215\345\220\214\350\267\257\345\276\204II.md"
index 74fa2e1a17..3df1b30154 100644
--- "a/problems/0063.\344\270\215\345\220\214\350\267\257\345\276\204II.md"
+++ "b/problems/0063.\344\270\215\345\220\214\350\267\257\345\276\204II.md"
@@ -97,7 +97,7 @@ for (int j = 0; j < n; j++) dp[0][j] = 1;
 
 所以本题初始化代码为：
 
-```C++
+```CPP
 vector<vector<int>> dp(m, vector<int>(n, 0));
 for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
 for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
@@ -111,7 +111,7 @@ for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < m; i++) {
     for (int j = 1; j < n; j++) {
         if (obstacleGrid[i][j] == 1) continue;
@@ -135,7 +135,7 @@ for (int i = 1; i < m; i++) {
 
 动规五部分分析完毕，对应C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
diff --git "a/problems/0070.\347\210\254\346\245\274\346\242\257.md" "b/problems/0070.\347\210\254\346\245\274\346\242\257.md"
index fe401dd6bf..bb9a757cca 100644
--- "a/problems/0070.\347\210\254\346\245\274\346\242\257.md"
+++ "b/problems/0070.\347\210\254\346\245\274\346\242\257.md"
@@ -109,7 +109,7 @@ dp[i]： 爬到第i层楼梯，有dp[i]种方法
 
 以上五部分析完之后，C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -130,7 +130,7 @@ public:
 
 当然依然也可以，优化一下空间复杂度，代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -163,7 +163,7 @@ public:
 
 这里我先给出我的实现代码：
 
-```C++
+```CPP
 class Solution {
 public:
     int climbStairs(int n) {
diff --git "a/problems/0072.\347\274\226\350\276\221\350\267\235\347\246\273.md" "b/problems/0072.\347\274\226\350\276\221\350\267\235\347\246\273.md"
index efc0a82380..d7b6438dd9 100644
--- "a/problems/0072.\347\274\226\350\276\221\350\267\235\347\246\273.md"
+++ "b/problems/0072.\347\274\226\350\276\221\350\267\235\347\246\273.md"
@@ -123,7 +123,7 @@ if (word1[i - 1] != word2[j - 1])
 
 递归公式代码如下：
 
-```C++
+```CPP
 if (word1[i - 1] == word2[j - 1]) {
     dp[i][j] = dp[i - 1][j - 1];
 }
@@ -151,7 +151,7 @@ dp[i][0] ：以下标i-1为结尾的字符串word1，和空字符串word2，最
 
 所以C++代码如下：
 
-```C++
+```CPP
 for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
 for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
 ```
@@ -175,7 +175,7 @@ for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i <= word1.size(); i++) {
     for (int j = 1; j <= word2.size(); j++) {
         if (word1[i - 1] == word2[j - 1]) {
@@ -198,7 +198,7 @@ for (int i = 1; i <= word1.size(); i++) {
 
 以上动规五部分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minDistance(string word1, string word2) {
diff --git "a/problems/0077.\347\273\204\345\220\210.md" "b/problems/0077.\347\273\204\345\220\210.md"
index fc3fc0ae47..d88a571138 100644
--- "a/problems/0077.\347\273\204\345\220\210.md"
+++ "b/problems/0077.\347\273\204\345\220\210.md"
@@ -173,7 +173,7 @@ for循环每次从startIndex开始遍历，然后用path保存取到的节点i
 
 代码如下：
 
-```C++
+```CPP
 for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
     path.push_back(i); // 处理节点 
     backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
@@ -188,7 +188,7 @@ backtracking的下面部分就是回溯的操作了，撤销本次处理的结
 关键地方都讲完了，组合问题C++完整代码如下：
 
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result; // 存放符合条件结果的集合
diff --git "a/problems/0078.\345\255\220\351\233\206.md" "b/problems/0078.\345\255\220\351\233\206.md"
index 51f33550e2..ca49f97b36 100644
--- "a/problems/0078.\345\255\220\351\233\206.md"
+++ "b/problems/0078.\345\255\220\351\233\206.md"
@@ -120,7 +120,7 @@ void backtracking(参数) {
 
 可以写出如下回溯算法C++代码：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md" "b/problems/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md"
index d5d8c92a5e..f0f58c0f86 100644
--- "a/problems/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md"
+++ "b/problems/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.md"
@@ -23,7 +23,7 @@
 
 ## 双指针解法
 
-```C++
+```CPP
 class Solution {
 public:
     int largestRectangleArea(vector<int>& heights) {
@@ -56,7 +56,7 @@ public:
 
 所以需要循环查找，也就是下面在寻找的过程中使用了while，详细请看下面注释，整理思路在题解：[42. 接雨水](https://mp.weixin.qq.com/s/QogENxhotboct9wn7GgYUw)中已经介绍了。
 
-```C++
+```CPP
 class Solution {
 public:
     int largestRectangleArea(vector<int>& heights) {
@@ -125,7 +125,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -164,7 +164,7 @@ public:
 
 代码精简之后：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0090.\345\255\220\351\233\206II.md" "b/problems/0090.\345\255\220\351\233\206II.md"
index 1ebf9f2b7d..5c19adc059 100644
--- "a/problems/0090.\345\255\220\351\233\206II.md"
+++ "b/problems/0090.\345\255\220\351\233\206II.md"
@@ -124,7 +124,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/0093.\345\244\215\345\216\237IP\345\234\260\345\235\200.md" "b/problems/0093.\345\244\215\345\216\237IP\345\234\260\345\235\200.md"
index ced57db12d..9a95af22ca 100644
--- "a/problems/0093.\345\244\215\345\216\237IP\345\234\260\345\235\200.md"
+++ "b/problems/0093.\345\244\215\345\216\237IP\345\234\260\345\235\200.md"
@@ -183,7 +183,7 @@ void backtracking(参数) {
 
 可以写出如下回溯算法C++代码：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<string> result;// 记录结果
diff --git "a/problems/0096.\344\270\215\345\220\214\347\232\204\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/problems/0096.\344\270\215\345\220\214\347\232\204\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
index 2218880048..7cbe4fec2d 100644
--- "a/problems/0096.\344\270\215\345\220\214\347\232\204\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
+++ "b/problems/0096.\344\270\215\345\220\214\347\232\204\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
@@ -103,7 +103,7 @@ j相当于是头结点的元素，从1遍历到i为止。
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i <= n; i++) {
     for (int j = 1; j <= i; j++) {
         dp[i] += dp[j - 1] * dp[i - j];
@@ -123,7 +123,7 @@ n为5时候的dp数组状态如图：
 
 综上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int numTrees(int n) {
diff --git "a/problems/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/problems/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
index 567b9784a6..d6db901e9f 100644
--- "a/problems/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
+++ "b/problems/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
@@ -32,7 +32,7 @@
 
 可以递归中序遍历将二叉搜索树转变成一个数组，代码如下：
 
-```C++
+```CPP
 vector<int> vec;
 void traversal(TreeNode* root) {
     if (root == NULL) return;
@@ -44,7 +44,7 @@ void traversal(TreeNode* root) {
 
 然后只要比较一下，这个数组是否是有序的，**注意二叉搜索树中不能有重复元素**。
 
-```C++
+```CPP
 traversal(root);
 for (int i = 1; i < vec.size(); i++) {
     // 注意要小于等于，搜索树里不能有相同元素
@@ -55,7 +55,7 @@ return true;
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<int> vec;
@@ -163,7 +163,7 @@ return left && right;
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     long long maxVal = LONG_MIN; // 因为后台测试数据中有int最小值
@@ -189,7 +189,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* pre = NULL; // 用来记录前一个节点
@@ -214,7 +214,7 @@ public:
 
 迭代法中序遍历稍加改动就可以了，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isValidBST(TreeNode* root) {
diff --git "a/problems/0100.\347\233\270\345\220\214\347\232\204\346\240\221.md" "b/problems/0100.\347\233\270\345\220\214\347\232\204\346\240\221.md"
index 5e37c9bd6b..e4eb412a8f 100644
--- "a/problems/0100.\347\233\270\345\220\214\347\232\204\346\240\221.md"
+++ "b/problems/0100.\347\233\270\345\220\214\347\232\204\346\240\221.md"
@@ -61,7 +61,7 @@ bool compare(TreeNode* tree1, TreeNode* tree2)
 此时tree1、tree2节点不为空，且数值也不相同的情况我们也处理了。
 
 代码如下：
-```C++
+```CPP
 if (tree1 == NULL && tree2 != NULL) return false;
 else if (tree1 != NULL && tree2 == NULL) return false;
 else if (tree1 == NULL && tree2 == NULL) return true;
@@ -77,7 +77,7 @@ else if (tree1->val != tree2->val) return false; // 注意这里我没有
 
 代码如下：
 
-```C++
+```CPP
 bool left = compare(tree1->left, tree2->left);   // 左子树：左、 右子树：左
 bool right = compare(tree1->right, tree2->right);  // 左子树：右、 右子树：右
 bool isSame = left && right;                    // 左子树：中、 右子树：中（逻辑处理）
@@ -85,7 +85,7 @@ return isSame;
 ```
 最后递归的C++整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* tree1, TreeNode* tree2) {
@@ -119,7 +119,7 @@ public:
 
 ## 递归
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* left, TreeNode* right) {
@@ -138,7 +138,7 @@ public:
 
 ## 迭代法
 
-```C++
+```CPP
 class Solution {
 public:
 
diff --git "a/problems/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md" "b/problems/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
index 404fa283a5..e091844b32 100644
--- "a/problems/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.md"
@@ -73,7 +73,7 @@ bool compare(TreeNode* left, TreeNode* right)
 此时左右节点不为空，且数值也不相同的情况我们也处理了。
 
 代码如下：
-```C++
+```CPP
 if (left == NULL && right != NULL) return false;
 else if (left != NULL && right == NULL) return false;
 else if (left == NULL && right == NULL) return true;
@@ -93,7 +93,7 @@ else if (left->val != right->val) return false; // 注意这里我没有
 
 代码如下：
 
-```C++
+```CPP
 bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
 bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
 bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
@@ -104,7 +104,7 @@ return isSame;
 
 最后递归的C++整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* left, TreeNode* right) {
@@ -137,7 +137,7 @@ public:
 **盲目的照着抄，结果就是：发现这是一道“简单题”，稀里糊涂的就过了，但是真正的每一步判断逻辑未必想到清楚。**
 
 当然我可以把如上代码整理如下：
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* left, TreeNode* right) {
@@ -177,7 +177,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
@@ -212,7 +212,7 @@ public:
 
 只要把队列原封不动的改成栈就可以了，我下面也给出了代码。
 
-```C++
+```CPP
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
diff --git "a/problems/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md" "b/problems/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
index b27f740833..c38cc796a3 100644
--- "a/problems/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
+++ "b/problems/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.md"
@@ -60,7 +60,7 @@
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> levelOrder(TreeNode* root) {
@@ -245,7 +245,7 @@ var levelOrder = function(root) {
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> levelOrderBottom(TreeNode* root) {
@@ -422,7 +422,7 @@ var levelOrderBottom = function(root) {
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> rightSideView(TreeNode* root) {
@@ -599,7 +599,7 @@ var rightSideView = function(root) {
 
 C++代码:
 
-```C++
+```CPP
 class Solution {
 public:
     vector<double> averageOfLevels(TreeNode* root) {
@@ -794,7 +794,7 @@ var averageOfLevels = function(root) {
 
 C++代码:
 
-```C++
+```CPP
 class Solution {
 public:
     vector<vector<int>> levelOrder(Node* root) {
@@ -1003,7 +1003,7 @@ var levelOrder = function(root) {
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> largestValues(TreeNode* root) {
@@ -1147,7 +1147,7 @@ struct Node {
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     Node* connect(Node* root) {
@@ -1269,7 +1269,7 @@ func connect(root *Node) *Node {
 
 C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     Node* connect(Node* root) {
@@ -1451,7 +1451,7 @@ func connect(root *Node) *Node {
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxDepth(TreeNode* root) {
@@ -1491,7 +1491,7 @@ JavaScript：
 
 代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     int minDepth(TreeNode* root) {
diff --git "a/problems/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md" "b/problems/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md"
index 50055290fc..4cfe28582a 100644
--- "a/problems/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.md"
@@ -59,7 +59,7 @@
 
 不难写出如下代码：（先把框架写出来）
 
-```C++
+```CPP
 TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
 
     // 第一步
@@ -155,7 +155,7 @@ root->right = traversal(rightInorder, rightPostorder);
 
 ### C++完整代码
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
@@ -209,7 +209,7 @@ public:
 加了日志的代码如下：（加了日志的代码不要在leetcode上提交，容易超时）
 
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
@@ -277,7 +277,7 @@ public:
 下面给出用下表索引写出的代码版本：（思路是一样的，只不过不用重复定义vector了，每次用下表索引来分割）
 
 ### C++优化版本
-```C++
+```CPP
 class Solution {
 private:
     // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
@@ -325,7 +325,7 @@ public:
 
 那么这个版本写出来依然要打日志进行调试，打日志的版本如下：（**该版本不要在leetcode上提交，容易超时**）
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
@@ -419,7 +419,7 @@ public:
 
 带日志的版本C++代码如下： （**带日志的版本仅用于调试，不要在leetcode上提交，会超时**）
 
-```C++
+```CPP
 class Solution {
 private:
         TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
@@ -493,7 +493,7 @@ public:
 
 105.从前序与中序遍历序列构造二叉树，最后版本，C++代码：
 
-```C++
+```CPP
 class Solution {
 private:
         TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
diff --git "a/problems/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/problems/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
index cba8a44631..9e67a677b9 100644
--- "a/problems/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
+++ "b/problems/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
@@ -122,7 +122,7 @@ return root;
 
 * 递归整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* traversal(vector<int>& nums, int left, int right) {
@@ -150,7 +150,7 @@ public:
 
 模拟的就是不断分割的过程，C++代码如下：（我已经详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* sortedArrayToBST(vector<int>& nums) {
diff --git "a/problems/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md" "b/problems/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
index f85b03c310..55d3c2e778 100644
--- "a/problems/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.md"
@@ -57,7 +57,7 @@
 
 在[104.二叉树的最大深度](https://mp.weixin.qq.com/s/jRaRcRerhEHepQbt-aKstw)中，如果真正求取二叉树的最大深度，代码应该写成如下：（前序遍历）
 
-```C++
+```CPP
 class Solution {
 public:
     int result;
@@ -91,7 +91,7 @@ public:
 
 注意以上代码是为了把细节体现出来，简化一下代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int result;
@@ -161,7 +161,7 @@ if (node == NULL) {
 
 代码如下：
 
-```C++
+```CPP
 int leftDepth = depth(node->left); // 左
 if (leftDepth == -1) return -1;
 int rightDepth = depth(node->right); // 右
@@ -179,7 +179,7 @@ return result;
 
 代码精简之后如下：
 
-```C++
+```CPP
 int leftDepth = getDepth(node->left);
 if (leftDepth == -1) return -1;
 int rightDepth = getDepth(node->right);
@@ -191,7 +191,7 @@ return abs(leftDepth - rightDepth) > 1 ? -1 : 1 + max(leftDepth, rightDepth);
 
 getDepth整体代码如下：
 
-```C++
+```CPP
 int getDepth(TreeNode* node) {
     if (node == NULL) {
         return 0;
@@ -206,7 +206,7 @@ int getDepth(TreeNode* node) {
 
 最后本题整体递归代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     // 返回以该节点为根节点的二叉树的高度，如果不是二叉搜索树了则返回-1
@@ -236,7 +236,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 // cur节点的最大深度，就是cur的高度
 int getDepth(TreeNode* cur) {
     stack<TreeNode*> st;
@@ -267,7 +267,7 @@ int getDepth(TreeNode* cur) {
 
 然后再用栈来模拟前序遍历，遍历每一个节点的时候，再去判断左右孩子的高度是否符合，代码如下：
 
-```C++
+```CPP
 bool isBalanced(TreeNode* root) {
     stack<TreeNode*> st;
     if (root == NULL) return true;
@@ -287,7 +287,7 @@ bool isBalanced(TreeNode* root) {
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int getDepth(TreeNode* cur) {
diff --git "a/problems/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md" "b/problems/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
index 2f3605c74d..b4d0e32b25 100644
--- "a/problems/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
+++ "b/problems/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.md"
@@ -87,7 +87,7 @@ return result;
 
 代码如下：
 
-```C++
+```CPP
 int leftDepth = getDepth(node->left);           // 左
 int rightDepth = getDepth(node->right);         // 右
                                                 // 中
@@ -106,7 +106,7 @@ return result;
 遍历的顺序为后序（左右中），可以看出：**求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。**
 
 整体递归代码如下：
-```C++
+```CPP
 class Solution {
 public:
     int getDepth(TreeNode* node) {
@@ -134,7 +134,7 @@ public:
 
 精简之后代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minDepth(TreeNode* root) {
@@ -162,7 +162,7 @@ public:
 
 代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
 
diff --git "a/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md" "b/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
index 5d8e81d917..b59180ac63 100644
--- "a/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
+++ "b/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
@@ -91,7 +91,7 @@ if (!cur->left && !cur->right) return false; // 遇到叶子节点而没有找
 
 代码如下：
 
-```C++
+```CPP
 if (cur->left) { // 左 （空节点不遍历）
     // 遇到叶子节点返回true，则直接返回true
     if (traversal(cur->left, count - cur->left->val)) return true; // 注意这里有回溯的逻辑
@@ -109,7 +109,7 @@ return false;
 
 为了把回溯的过程体现出来，可以改为如下代码：
 
-```C++
+```CPP
 if (cur->left) { // 左
     count -= cur->left->val; // 递归，处理节点;
     if (traversal(cur->left, count)) return true;
@@ -126,7 +126,7 @@ return false;
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     bool traversal(TreeNode* cur, int count) {
@@ -156,7 +156,7 @@ public:
 
 以上代码精简之后如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool hasPathSum(TreeNode* root, int sum) {
@@ -186,7 +186,7 @@ C++就我们用pair结构来存放这个栈里的元素。
 
 如下代码是使用栈模拟的前序遍历，如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 
 public:
@@ -243,7 +243,7 @@ public:
 
 为了尽可能的把细节体现出来，我写出如下代码（**这份代码并不简洁，但是逻辑非常清晰**）
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/0115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md" "b/problems/0115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md"
index 61c74722b9..e964e95d66 100644
--- "a/problems/0115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/0115.\344\270\215\345\220\214\347\232\204\345\255\220\345\272\217\345\210\227.md"
@@ -82,7 +82,7 @@ dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串
 
 初始化分析完毕，代码如下：
 
-```C++
+```CPP
 vector<vector<long long>> dp(s.size() + 1, vector<long long>(t.size() + 1));
 for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
 for (int j = 1; j <= t.size(); j++) dp[0][j] = 0; // 其实这行代码可以和dp数组初始化的时候放在一起，但我为了凸显初始化的逻辑，所以还是加上了。
@@ -97,7 +97,7 @@ for (int j = 1; j <= t.size(); j++) dp[0][j] = 0; // 其实这行代码可以和
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i <= s.size(); i++) {
     for (int j = 1; j <= t.size(); j++) {
         if (s[i - 1] == t[j - 1]) {
@@ -120,7 +120,7 @@ for (int i = 1; i <= s.size(); i++) {
 
 动规五部曲分析完毕，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int numDistinct(string s, string t) {
diff --git "a/problems/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.md" "b/problems/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.md"
index 5e7acebcde..f96351aaa5 100644
--- "a/problems/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.md"
+++ "b/problems/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.md"
@@ -52,7 +52,7 @@ struct Node {
 
 图中cur节点为元素4，那么搭线的逻辑代码：（**注意注释中操作1和操作2和图中的对应关系**）
 
-```C++
+```CPP
 if (cur->left) cur->left->next = cur->right; // 操作1
 if (cur->right) {
     if (cur->next) cur->right->next = cur->next->left; // 操作2
@@ -63,7 +63,7 @@ if (cur->right) {
 理解到这里，使用前序遍历，那么不难写出如下代码：
 
 
-```C++
+```CPP
 class Solution {
 private:
     void traversal(Node* cur) {
@@ -93,7 +93,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     Node* connect(Node* root) {
diff --git "a/problems/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/problems/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
index 5418cdf497..6d068c22a1 100644
--- "a/problems/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
+++ "b/problems/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
@@ -33,7 +33,7 @@
 
 这道题目最直观的想法，就是暴力，找最优间距了。
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -59,7 +59,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -139,7 +139,7 @@ dp[5][1]就是最终结果。
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -169,7 +169,7 @@ dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
 
 那么我们只需要记录 当前天的dp状态和前一天的dp状态就可以了，可以使用滚动数组来节省空间，代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md" "b/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
index b73f28b92e..5373753283 100644
--- "a/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
+++ "b/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
@@ -80,7 +80,7 @@
 
 对应C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -99,7 +99,7 @@ public:
 
 动态规划将在下一个系列详细讲解，本题解先给出我的C++代码（带详细注释），感兴趣的同学可以自己先学习一下。
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
diff --git "a/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md" "b/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
index 82608b4307..7492ee046c 100644
--- "a/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
+++ "b/problems/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
@@ -74,7 +74,7 @@
 
 代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -106,7 +106,7 @@ dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
 
 这里我依然给出滚动数组的版本，C++代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.md" "b/problems/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.md"
index e18a142e3a..0c92a5a241 100644
--- "a/problems/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.md"
+++ "b/problems/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.md"
@@ -127,7 +127,7 @@ dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
 
 以上五部都分析完了，不难写出如下代码：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -153,7 +153,7 @@ public:
 
 当然，大家可以看到力扣官方题解里的一种优化空间写法，我这里给出对应的C++版本：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md" "b/problems/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
index f83ed3e80f..b37270e21f 100644
--- "a/problems/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
+++ "b/problems/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.md"
@@ -52,7 +52,7 @@ if (!cur->left && !cur->right) { // 遇到了叶子节点
 
 这里vectorToInt函数就是把数组转成int，代码如下：
 
-```C++
+```CPP
 int vectorToInt(const vector<int>& vec) {
     int sum = 0;
     for (int i = 0; i < vec.size(); i++) {
@@ -78,7 +78,7 @@ int vectorToInt(const vector<int>& vec) {
 
 代码如下：
 
-```C++
+```CPP
                  // 中
 if (cur->left) { // 左 （空节点不遍历）
     path.push_back(cur->left->val);
@@ -94,7 +94,7 @@ if (cur->right) { // 右 （空节点不遍历）
 
 这里要注意回溯和递归要永远在一起，一个递归，对应一个回溯，是一对一的关系，有的同学写成如下代码：
 
-```C++
+```CPP
 if (cur->left) { // 左 （空节点不遍历）
     path.push_back(cur->left->val);
     traversal(cur->left);    // 递归
@@ -111,7 +111,7 @@ path.pop_back();         // 回溯
 
 关键逻辑分析完了，整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int result;
diff --git "a/problems/0131.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md" "b/problems/0131.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
index 5bcd38e072..6fe2758be0 100644
--- "a/problems/0131.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
+++ "b/problems/0131.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262.md"
@@ -70,7 +70,7 @@
 
 代码如下：
 
-```C++
+```CPP
 vector<vector<string>> result;
 vector<string> path; // 放已经回文的子串
 void backtracking (const string& s, int startIndex) {
@@ -88,7 +88,7 @@ void backtracking (const string& s, int startIndex) {
 
 所以终止条件代码如下：
 
-```C++
+```CPP
 void backtracking (const string& s, int startIndex) {
     // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
     if (startIndex >= s.size()) {
@@ -108,7 +108,7 @@ void backtracking (const string& s, int startIndex) {
 
 代码如下：
 
-```C++
+```CPP
 for (int i = startIndex; i < s.size(); i++) {
     if (isPalindrome(s, startIndex, i)) { // 是回文子串
         // 获取[startIndex,i]在s中的子串
@@ -132,7 +132,7 @@ for (int i = startIndex; i < s.size(); i++) {
 
 那么判断回文的C++代码如下：
 
-```C++
+```CPP
  bool isPalindrome(const string& s, int start, int end) {
      for (int i = start, j = end; i < j; i++, j--) {
          if (s[i] != s[j]) {
@@ -151,7 +151,7 @@ for (int i = startIndex; i < s.size(); i++) {
 
 根据Carl给出的回溯算法模板：
 
-```C++
+```CPP
 void backtracking(参数) {
     if (终止条件) {
         存放结果;
@@ -169,7 +169,7 @@ void backtracking(参数) {
 
 不难写出如下代码：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<string>> result;
diff --git "a/problems/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.md" "b/problems/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.md"
index d2b5fed4d2..80784301d7 100644
--- "a/problems/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.md"
+++ "b/problems/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.md"
@@ -101,7 +101,7 @@ dp[i]： 范围是[0, i]的回文子串，最少分割次数是dp[i]。
 
 代码如下：
 
-```C++
+```CPP
 vector<int> dp(s.size(), INT_MAX);
 dp[0] = 0;
 ```
@@ -109,7 +109,7 @@ dp[0] = 0;
 其实也可以这样初始化，更具dp[i]的定义，dp[i]的最大值其实就是i，也就是把每个字符分割出来。
 
 所以初始化代码也可以为：
-```C++
+```CPP
 vector<int> dp(s.size());
 for (int i = 0; i < s.size(); i++) dp[i] = i;
 ```
@@ -122,7 +122,7 @@ j是在[0，i]之间，所以遍历i的for循环一定在外层，这里遍历j
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < s.size(); i++) {
     if (isPalindromic[0][i]) { // 判断是不是回文子串
         dp[i] = 0;
@@ -149,7 +149,7 @@ for (int i = 1; i < s.size(); i++) {
 
 代码如下：
 
-```C++
+```CPP
 vector<vector<bool>> isPalindromic(s.size(), vector<bool>(s.size(), false));
 for (int i = s.size() - 1; i >= 0; i--) {
     for (int j = i; j < s.size(); j++) {
@@ -168,7 +168,7 @@ for (int i = s.size() - 1; i >= 0; i--) {
 
 以上分析完毕，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minCut(string s) {
diff --git "a/problems/0134.\345\212\240\346\262\271\347\253\231.md" "b/problems/0134.\345\212\240\346\262\271\347\253\231.md"
index 0200e9d8be..e270c059d3 100644
--- "a/problems/0134.\345\212\240\346\262\271\347\253\231.md"
+++ "b/problems/0134.\345\212\240\346\262\271\347\253\231.md"
@@ -65,7 +65,7 @@ cost = [3,4,3]
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
@@ -99,7 +99,7 @@ C++暴力解法在leetcode上提交也可以过。
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
@@ -160,7 +160,7 @@ i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
diff --git "a/problems/0135.\345\210\206\345\217\221\347\263\226\346\236\234.md" "b/problems/0135.\345\210\206\345\217\221\347\263\226\346\236\234.md"
index c9f1112632..3865e14baa 100644
--- "a/problems/0135.\345\210\206\345\217\221\347\263\226\346\236\234.md"
+++ "b/problems/0135.\345\210\206\345\217\221\347\263\226\346\236\234.md"
@@ -47,7 +47,7 @@
 
 代码如下：
 
-```C++
+```CPP
 // 从前向后
 for (int i = 1; i < ratings.size(); i++) {
     if (ratings[i] > ratings[i - 1]) candyVec[i] = candyVec[i - 1] + 1;
@@ -80,7 +80,7 @@ for (int i = 1; i < ratings.size(); i++) {
 
 所以该过程代码如下：
 
-```C++
+```CPP
 // 从后向前
 for (int i = ratings.size() - 2; i >= 0; i--) {
     if (ratings[i] > ratings[i + 1] ) {
@@ -90,7 +90,7 @@ for (int i = ratings.size() - 2; i >= 0; i--) {
 ```
 
 整体代码如下：
-```C++
+```CPP
 class Solution {
 public:
     int candy(vector<int>& ratings) {
diff --git "a/problems/0139.\345\215\225\350\257\215\346\213\206\345\210\206.md" "b/problems/0139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
index 391655bb82..0c19a6142c 100644
--- "a/problems/0139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
+++ "b/problems/0139.\345\215\225\350\257\215\346\213\206\345\210\206.md"
@@ -45,7 +45,7 @@
 
 那么这里我也给出回溯法C++代码：
 
-```C++
+```CPP
 class Solution {
 private:
     bool backtracking (const string& s, const unordered_set<string>& wordSet, int startIndex) {
@@ -86,7 +86,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     bool backtracking (const string& s,
@@ -190,7 +190,7 @@ dp[s.size()]就是最终结果。
 
 动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool wordBreak(string s, vector<string>& wordDict) {
diff --git "a/problems/0141.\347\216\257\345\275\242\351\223\276\350\241\250.md" "b/problems/0141.\347\216\257\345\275\242\351\223\276\350\241\250.md"
index e6ac68b53b..78bcfd432c 100644
--- "a/problems/0141.\347\216\257\345\275\242\351\223\276\350\241\250.md"
+++ "b/problems/0141.\347\216\257\345\275\242\351\223\276\350\241\250.md"
@@ -45,7 +45,7 @@ fast和slow各自再走一步， fast和slow就相遇了
 
 C++代码如下
 
-```C++
+```CPP
 class Solution {
 public:
     bool hasCycle(ListNode *head) {
diff --git "a/problems/0142.\347\216\257\345\275\242\351\223\276\350\241\250II.md" "b/problems/0142.\347\216\257\345\275\242\351\223\276\350\241\250II.md"
index 03f5b20829..91e14e27a4 100644
--- "a/problems/0142.\347\216\257\345\275\242\351\223\276\350\241\250II.md"
+++ "b/problems/0142.\347\216\257\345\275\242\351\223\276\350\241\250II.md"
@@ -109,7 +109,7 @@ fast指针走过的节点数：` x + y + n (y + z)`，n为fast指针在环内走
 
 代码如下：
 
-```C++
+```CPP
 /**
  * Definition for singly-linked list.
  * struct ListNode {
diff --git "a/problems/0143.\351\207\215\346\216\222\351\223\276\350\241\250.md" "b/problems/0143.\351\207\215\346\216\222\351\223\276\350\241\250.md"
index 76dbf20b62..6223205132 100644
--- "a/problems/0143.\351\207\215\346\216\222\351\223\276\350\241\250.md"
+++ "b/problems/0143.\351\207\215\346\216\222\351\223\276\350\241\250.md"
@@ -24,7 +24,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void reorderList(ListNode* head) {
@@ -63,7 +63,7 @@ public:
 
 把链表放进双向队列，然后通过双向队列一前一后弹出数据，来构造新的链表。这种方法比操作数组容易一些，不用双指针模拟一前一后了
 
-```C++
+```CPP
 class Solution {
 public:
     void reorderList(ListNode* head) {
@@ -108,7 +108,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     // 反转链表
diff --git "a/problems/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" "b/problems/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
index d7a2a0fc87..2b2943377e 100644
--- "a/problems/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
+++ "b/problems/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
@@ -80,7 +80,7 @@ https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/
 C++代码如下：
 
 
-```C++
+```CPP
 class Solution {
 public:
     int evalRPN(vector<string>& tokens) {
diff --git "a/problems/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.md" "b/problems/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.md"
index 3d31605439..3f4d00b26f 100644
--- "a/problems/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.md"
+++ "b/problems/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.md"
@@ -61,7 +61,7 @@ https://leetcode-cn.com/problems/reverse-words-in-a-string/
 
 思路很明确了，我们说一说代码的实现细节，就拿移除多余空格来说，一些同学会上来写如下代码：
 
-```C++
+```CPP
 void removeExtraSpaces(string& s) {
     for (int i = s.size() - 1; i > 0; i--) {
         if (s[i] == s[i - 1] && s[i] == ' ') {
@@ -93,7 +93,7 @@ erase操作上面还套了一个for循环，那么以上代码移除冗余空格
 
 那么使用双指针来移除冗余空格代码如下： fastIndex走的快，slowIndex走的慢，最后slowIndex就标记着移除多余空格后新字符串的长度。
 
-```C++
+```CPP
 void removeExtraSpaces(string& s) {
     int slowIndex = 0, fastIndex = 0; // 定义快指针，慢指针
     // 去掉字符串前面的空格
@@ -141,7 +141,7 @@ void reverse(string& s, int start, int end) {
 本题C++整体代码
 
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
diff --git "a/problems/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.md" "b/problems/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.md"
index c7b77021d0..9fe7a919e1 100644
--- "a/problems/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.md"
+++ "b/problems/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.md"
@@ -84,7 +84,7 @@ vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
 
 同理可以类比剩下的状态，代码如下：
 
-```C++
+```CPP
 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]);
@@ -117,7 +117,7 @@ for (int j = 0; j < 2 * k - 1; j += 2) {
 
 代码如下：
 
-```C++
+```CPP
 for (int j = 1; j < 2 * k; j += 2) {
     dp[0][j] = -prices[0];
 }
@@ -139,7 +139,7 @@ for (int j = 1; j < 2 * k; j += 2) {
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(int k, vector<int>& prices) {
diff --git "a/problems/0189.\346\227\213\350\275\254\346\225\260\347\273\204.md" "b/problems/0189.\346\227\213\350\275\254\346\225\260\347\273\204.md"
index 0b64cc87b5..be46bf4c1b 100644
--- "a/problems/0189.\346\227\213\350\275\254\346\225\260\347\273\204.md"
+++ "b/problems/0189.\346\227\213\350\275\254\346\225\260\347\273\204.md"
@@ -69,7 +69,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void rotate(vector<int>& nums, int k) {
diff --git "a/problems/0198.\346\211\223\345\256\266\345\212\253\350\210\215.md" "b/problems/0198.\346\211\223\345\256\266\345\212\253\350\210\215.md"
index aa2d556398..93b56dae91 100644
--- "a/problems/0198.\346\211\223\345\256\266\345\212\253\350\210\215.md"
+++ "b/problems/0198.\346\211\223\345\256\266\345\212\253\350\210\215.md"
@@ -59,7 +59,7 @@
 
 代码如下：
 
-```C++
+```CPP
 vector<int> dp(nums.size());
 dp[0] = nums[0];
 dp[1] = max(nums[0], nums[1]);
@@ -70,7 +70,7 @@ dp[1] = max(nums[0], nums[1]);
 dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！
 
 代码如下：
-```C++
+```CPP
 for (int i = 2; i < nums.size(); i++) {
     dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
 }
@@ -86,7 +86,7 @@ for (int i = 2; i < nums.size(); i++) {
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int rob(vector<int>& nums) {
diff --git "a/problems/0202.\345\277\253\344\271\220\346\225\260.md" "b/problems/0202.\345\277\253\344\271\220\346\225\260.md"
index f6c2d5dcbe..1c630b6a8e 100644
--- "a/problems/0202.\345\277\253\344\271\220\346\225\260.md"
+++ "b/problems/0202.\345\277\253\344\271\220\346\225\260.md"
@@ -46,7 +46,7 @@ https://leetcode-cn.com/problems/happy-number/
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     // 取数值各个位上的单数之和
diff --git "a/problems/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md" "b/problems/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
index 406efe888d..a2c6e90d5b 100644
--- "a/problems/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
+++ "b/problems/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.md"
@@ -89,7 +89,7 @@ https://leetcode-cn.com/problems/remove-linked-list-elements/
 
 **直接使用原来的链表来进行移除节点操作：**
 
-```C++
+```CPP
 class Solution {
 public:
     ListNode* removeElements(ListNode* head, int val) {
@@ -118,7 +118,7 @@ public:
 
 **设置一个虚拟头结点在进行移除节点操作：**
 
-```C++
+```CPP
 class Solution {
 public:
     ListNode* removeElements(ListNode* head, int val) {
diff --git "a/problems/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md" "b/problems/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
index 4daea83992..d5077e03de 100644
--- "a/problems/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
@@ -39,7 +39,7 @@
 
 C++代码 如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isIsomorphic(string s, string t) {
diff --git "a/problems/0206.\347\277\273\350\275\254\351\223\276\350\241\250.md" "b/problems/0206.\347\277\273\350\275\254\351\223\276\350\241\250.md"
index 397a26c96b..8bb359bd52 100644
--- "a/problems/0206.\347\277\273\350\275\254\351\223\276\350\241\250.md"
+++ "b/problems/0206.\347\277\273\350\275\254\351\223\276\350\241\250.md"
@@ -48,7 +48,7 @@ https://leetcode-cn.com/problems/reverse-linked-list/
 # C++代码
 
 ## 双指针法
-```C++
+```CPP
 class Solution {
 public:
     ListNode* reverseList(ListNode* head) {
@@ -74,7 +74,7 @@ public:
 关键是初始化的地方，可能有的同学会不理解， 可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了。
 
 具体可以看代码（已经详细注释），**双指针法写出来之后，理解如下递归写法就不难了，代码逻辑都是一样的。**
-```C++
+```CPP
 class Solution {
 public:
     ListNode* reverse(ListNode* pre,ListNode* cur){
diff --git "a/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
index ed3a7a9bc1..3a31b91876 100644
--- "a/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
+++ "b/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
@@ -26,7 +26,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minSubArrayLen(int s, vector<int>& nums) {
@@ -86,7 +86,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minSubArrayLen(int s, vector<int>& nums) {
diff --git "a/problems/0213.\346\211\223\345\256\266\345\212\253\350\210\215II.md" "b/problems/0213.\346\211\223\345\256\266\345\212\253\350\210\215II.md"
index ec69c3ea8a..e828d17a8e 100644
--- "a/problems/0213.\346\211\223\345\256\266\345\212\253\350\210\215II.md"
+++ "b/problems/0213.\346\211\223\345\256\266\345\212\253\350\210\215II.md"
@@ -59,7 +59,7 @@
 
 代码如下：
 
-```C++
+```CPP
 // 注意注释中的情况二情况三，以及把198.打家劫舍的代码抽离出来了
 class Solution {
 public:
diff --git "a/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md" "b/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
index c71d0589cb..c9cfa97329 100644
--- "a/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
+++ "b/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
@@ -94,7 +94,7 @@ void backtracking(int targetSum, int k, int sum, int startIndex)
 
 所以 终止代码如下：
 
-```C++
+```CPP
 if (path.size() == k) {
     if (sum == targetSum) result.push_back(path);
     return; // 如果path.size() == k 但sum != targetSum 直接返回
@@ -112,7 +112,7 @@ if (path.size() == k) {
 
 代码如下：
 
-```C++
+```CPP
 for (int i = startIndex; i <= 9; i++) {
     sum += i;
     path.push_back(i);
@@ -126,7 +126,7 @@ for (int i = startIndex; i <= 9; i++) {
 
 参照[关于回溯算法，你该了解这些！](https://mp.weixin.qq.com/s/gjSgJbNbd1eAA5WkA-HeWw)中的模板，不难写出如下C++代码：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result; // 存放结果集
diff --git "a/problems/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.md" "b/problems/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.md"
index 59e6e8196e..0d3a818e48 100644
--- "a/problems/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.md"
+++ "b/problems/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.md"
@@ -77,7 +77,7 @@ return treeNum;
 
 所以整体C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 private:
@@ -96,7 +96,7 @@ public:
 ```
 
 代码精简之后C++代码如下：
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -119,7 +119,7 @@ public:
 
 那么只要模板少做改动，加一个变量result，统计节点数量就可以了
 
-```C++
+```CPP
 class Solution {
 public:
     int countNodes(TreeNode* root) {
@@ -163,7 +163,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int countNodes(TreeNode* root) {
diff --git "a/problems/0225.\347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md" "b/problems/0225.\347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md"
index 03172c243f..b327c17b8b 100644
--- "a/problems/0225.\347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md"
+++ "b/problems/0225.\347\224\250\351\230\237\345\210\227\345\256\236\347\216\260\346\240\210.md"
@@ -65,7 +65,7 @@ queue.empty();
 详细如代码注释所示：
 
 
-```C++
+```CPP
 class MyStack {
 public:
     queue<int> que1;
@@ -118,7 +118,7 @@ public:
 
 C++优化代码
 
-```C++
+```CPP
 class MyStack {
 public:
     queue<int> que;
diff --git "a/problems/0226.\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.md" "b/problems/0226.\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.md"
index 31983de22c..6eb6f301f8 100644
--- "a/problems/0226.\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0226.\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.md"
@@ -89,7 +89,7 @@ invertTree(root->right);
 
 基于这递归三步法，代码基本写完，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -111,7 +111,7 @@ public:
 
 C++代码迭代法（前序遍历）
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -136,7 +136,7 @@ public:
 
 C++代码如下迭代法（前序遍历）
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -168,7 +168,7 @@ public:
 
 也就是层序遍历，层数遍历也是可以翻转这棵树的，因为层序遍历也可以把每个节点的左右孩子都翻转一遍，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -196,7 +196,7 @@ public:
 
 如果非要使用递归中序的方式写，也可以，如下代码就可以避免节点左右孩子翻转两次的情况：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -215,7 +215,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
diff --git "a/problems/0232.\347\224\250\346\240\210\345\256\236\347\216\260\351\230\237\345\210\227.md" "b/problems/0232.\347\224\250\346\240\210\345\256\236\347\216\260\351\230\237\345\210\227.md"
index 66e82746f8..0df82d35b5 100644
--- "a/problems/0232.\347\224\250\346\240\210\345\256\236\347\216\260\351\230\237\345\210\227.md"
+++ "b/problems/0232.\347\224\250\346\240\210\345\256\236\347\216\260\351\230\237\345\210\227.md"
@@ -67,7 +67,7 @@ queue.empty();
 
 C++代码如下：
 
-```C++
+```CPP
 class MyQueue {
 public:
     stack<int> stIn;
diff --git "a/problems/0234.\345\233\236\346\226\207\351\223\276\350\241\250.md" "b/problems/0234.\345\233\236\346\226\207\351\223\276\350\241\250.md"
index fbb79e6440..6a24b1d09c 100644
--- "a/problems/0234.\345\233\236\346\226\207\351\223\276\350\241\250.md"
+++ "b/problems/0234.\345\233\236\346\226\207\351\223\276\350\241\250.md"
@@ -30,7 +30,7 @@
 
 代码也比较简单。如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isPalindrome(ListNode* head) {
@@ -51,7 +51,7 @@ public:
 
 上面代码可以在优化，就是先求出链表长度，然后给定vector的初始长度，这样避免vector每次添加节点重新开辟空间
 
-```C++
+```CPP
 class Solution {
 public:
     bool isPalindrome(ListNode* head) {
@@ -95,7 +95,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isPalindrome(ListNode* head) {
diff --git "a/problems/0235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" "b/problems/0235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
index af91098707..fe87506754 100644
--- "a/problems/0235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
+++ "b/problems/0235.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
@@ -93,7 +93,7 @@ if (cur == NULL) return cur;
 
 代码如下：
 
-```C++
+```CPP
 if (cur->val > p->val && cur->val > q->val) {
     TreeNode* left = traversal(cur->left, p, q);
     if (left != NULL) {
@@ -147,7 +147,7 @@ return cur;
 
 那么整体递归代码如下:
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
@@ -177,7 +177,7 @@ public:
 
 精简后代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
@@ -198,7 +198,7 @@ public:
 
 迭代代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
diff --git "a/problems/0236.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md" "b/problems/0236.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
index a1045d8af9..0885e20f07 100644
--- "a/problems/0236.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
+++ "b/problems/0236.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.md"
@@ -150,7 +150,7 @@ TreeNode* right = lowestCommonAncestor(root->right, p, q);
 
 代码如下：
 
-```C++
+```CPP
 if (left == NULL && right != NULL) return right;
 else if (left != NULL && right == NULL) return left;
 else  { //  (left == NULL && right == NULL)
@@ -167,7 +167,7 @@ else  { //  (left == NULL && right == NULL)
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
@@ -188,7 +188,7 @@ public:
 
 稍加精简，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
diff --git "a/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md" "b/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
index 9658ae36a0..3c12a985b2 100644
--- "a/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
+++ "b/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
@@ -108,7 +108,7 @@ public:
 
 基于刚刚说过的单调队列pop和push的规则，代码不难实现，如下：
 
-```C++
+```CPP
 class MyQueue { //单调队列（从大到小）
 public:
     deque<int> que; // 使用deque来实现单调队列
@@ -140,7 +140,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     class MyQueue { //单调队列（从大到小）
diff --git "a/problems/0242.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/problems/0242.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
index e89bf82c2f..b215a88a38 100644
--- "a/problems/0242.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
+++ "b/problems/0242.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
@@ -61,7 +61,7 @@ https://leetcode-cn.com/problems/valid-anagram/
 
 
 C++ 代码如下：
-```C++
+```CPP
 class Solution {
 public:
     bool isAnagram(string s, string t) {
diff --git "a/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md" "b/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
index 0486f8edfd..8431550779 100644
--- "a/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
+++ "b/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
@@ -77,7 +77,7 @@ if (cur->left == NULL && cur->right == NULL) {
 
 这里我们先使用vector<int>结构的path容器来记录路径，那么终止处理逻辑如下：
 
-```C++
+```CPP
 if (cur->left == NULL && cur->right == NULL) { // 遇到叶子节点
     string sPath;
     for (int i = 0; i < path.size() - 1; i++) { // 将path里记录的路径转为string格式
@@ -113,7 +113,7 @@ if (cur->right) {
 
 那么回溯要怎么回溯呢，一些同学会这么写，如下：
 
-```C++
+```CPP
 if (cur->left) {
     traversal(cur->left, path, result);
 }
@@ -129,7 +129,7 @@ path.pop_back();
 
 那么代码应该这么写：
 
-```C++
+```CPP
 if (cur->left) {
     traversal(cur->left, path, result);
     path.pop_back(); // 回溯
@@ -142,7 +142,7 @@ if (cur->right) {
 
 那么本题整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
 
@@ -183,7 +183,7 @@ public:
 
 那么如上代码可以精简成如下代码：
 
-```C++
+```CPP
 class Solution {
 private:
 
@@ -217,20 +217,20 @@ public:
 
 为了把这份精简代码的回溯过程展现出来，大家可以试一试把：
 
-```C++
+```CPP
 if (cur->left) traversal(cur->left, path + "->", result); // 左  回溯就隐藏在这里
 ```
 
 改成如下代码：
 
-```C++
+```CPP
 path += "->";
 traversal(cur->left, path, result); // 左
 ```
 
 即：
 
-```C++
+```CPP
 if (cur->left) {
     path += "->";
     traversal(cur->left, path, result); // 左
@@ -245,7 +245,7 @@ if (cur->right) {
 
 如果想把回溯加上，就要 在上面代码的基础上，加上回溯，就可以AC了。
 
-```C++
+```CPP
 if (cur->left) {
     path += "->";
     traversal(cur->left, path, result); // 左
@@ -276,7 +276,7 @@ if (cur->right) {
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<string> binaryTreePaths(TreeNode* root) {
diff --git "a/problems/0279.\345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md" "b/problems/0279.\345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md"
index b5d9189b37..199259ac00 100644
--- "a/problems/0279.\345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md"
+++ "b/problems/0279.\345\256\214\345\205\250\345\271\263\346\226\271\346\225\260.md"
@@ -76,7 +76,7 @@ dp[0]表示 和为0的完全平方数的最小数量，那么dp[0]一定是0。
 
 我这里先给出外层遍历背包，里层遍历物品的代码：
 
-```C++
+```CPP
 vector<int> dp(n + 1, INT_MAX);
 dp[0] = 0;
 for (int i = 0; i <= n; i++) { // 遍历背包
@@ -106,7 +106,7 @@ dp[5] = min(dp[4] + 1, dp[1] + 1) = 2
 
 以上动规五部曲分析完毕C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -125,7 +125,7 @@ public:
 
 同样我在给出先遍历物品，在遍历背包的代码，一样的可以AC的。
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0283.\347\247\273\345\212\250\351\233\266.md" "b/problems/0283.\347\247\273\345\212\250\351\233\266.md"
index 29cf31d9cf..af7142faed 100644
--- "a/problems/0283.\347\247\273\345\212\250\351\233\266.md"
+++ "b/problems/0283.\347\247\273\345\212\250\351\233\266.md"
@@ -42,7 +42,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void moveZeroes(vector<int>& nums) {
diff --git "a/problems/0300.\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227.md" "b/problems/0300.\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227.md"
index 7706a1123f..57edd13ecf 100644
--- "a/problems/0300.\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/0300.\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227.md"
@@ -60,7 +60,7 @@ dp[i] 是有0到i-1各个位置的最长升序子序列 推导而来，那么遍
 
 j其实就是0到i-1，遍历i的循环里外层，遍历j则在内层，代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < nums.size(); i++) {
     for (int j = 0; j < i; j++) {
         if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
@@ -80,7 +80,7 @@ for (int i = 1; i < nums.size(); i++) {
 
 以上五部分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int lengthOfLIS(vector<int>& nums) {
diff --git "a/problems/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md" "b/problems/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md"
index 7f81f4ba91..3b1b65003c 100644
--- "a/problems/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md"
+++ "b/problems/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.md"
@@ -95,7 +95,7 @@ p[i][3] = dp[i - 1][2];
 
 综上分析，递推代码如下：
 
-```C++
+```CPP
 dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i];
 dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
 dp[i][2] = dp[i - 1][0] + prices[i];
@@ -129,7 +129,7 @@ dp[i][3] = dp[i - 1][2];
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
diff --git "a/problems/0322.\351\233\266\351\222\261\345\205\221\346\215\242.md" "b/problems/0322.\351\233\266\351\222\261\345\205\221\346\215\242.md"
index 72f25a35e2..758bd5b8a8 100644
--- "a/problems/0322.\351\233\266\351\222\261\345\205\221\346\215\242.md"
+++ "b/problems/0322.\351\233\266\351\222\261\345\205\221\346\215\242.md"
@@ -112,7 +112,7 @@ dp[amount]为最终结果。
 ## C++代码
 以上分析完毕，C++ 代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -134,7 +134,7 @@ public:
 
 对于遍历方式遍历背包放在外循环，遍历物品放在内循环也是可以的，我就直接给出代码了
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0332.\351\207\215\346\226\260\345\256\211\346\216\222\350\241\214\347\250\213.md" "b/problems/0332.\351\207\215\346\226\260\345\256\211\346\216\222\350\241\214\347\250\213.md"
index 90c338280b..8a28899be6 100644
--- "a/problems/0332.\351\207\215\346\226\260\345\256\211\346\216\222\350\241\214\347\250\213.md"
+++ "b/problems/0332.\351\207\215\346\226\260\345\256\211\346\216\222\350\241\214\347\250\213.md"
@@ -178,7 +178,7 @@ if (result.size() == ticketNum + 1) {
 
 遍历过程如下：
 
-```C++
+```CPP
 for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
     if (target.second > 0 ) { // 记录到达机场是否飞过了
         result.push_back(target.first);
@@ -194,7 +194,7 @@ for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
 
 分析完毕，此时完整C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
 // unordered_map<出发机场, map<到达机场, 航班次数>> targets
diff --git "a/problems/0337.\346\211\223\345\256\266\345\212\253\350\210\215III.md" "b/problems/0337.\346\211\223\345\256\266\345\212\253\350\210\215III.md"
index 98dc1f8f63..44e60fb3d3 100644
--- "a/problems/0337.\346\211\223\345\256\266\345\212\253\350\210\215III.md"
+++ "b/problems/0337.\346\211\223\345\256\266\345\212\253\350\210\215III.md"
@@ -35,7 +35,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int rob(TreeNode* root) {
@@ -65,7 +65,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     unordered_map<TreeNode* , int> umap; // 记录计算过的结果
@@ -103,7 +103,7 @@ public:
 
 参数为当前节点，代码如下：
 
-```C++
+```CPP
 vector<int> robTree(TreeNode* cur) {
 ```
 
@@ -138,7 +138,7 @@ if (cur == NULL) return vector<int>{0, 0};
 
 代码如下：
 
-```C++
+```CPP
 // 下标0：不偷，下标1：偷
 vector<int> left = robTree(cur->left); // 左
 vector<int> right = robTree(cur->right); // 右
@@ -156,7 +156,7 @@ vector<int> right = robTree(cur->right); // 右
 
 代码如下：
 
-```C++
+```CPP
 vector<int> left = robTree(cur->left); // 左
 vector<int> right = robTree(cur->right); // 右
 
@@ -179,7 +179,7 @@ return {val2, val1};
 
 递归三部曲与动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int rob(TreeNode* root) {
diff --git "a/problems/0343.\346\225\264\346\225\260\346\213\206\345\210\206.md" "b/problems/0343.\346\225\264\346\225\260\346\213\206\345\210\206.md"
index e558d399b4..a9c55a8576 100644
--- "a/problems/0343.\346\225\264\346\225\260\346\213\206\345\210\206.md"
+++ "b/problems/0343.\346\225\264\346\225\260\346\213\206\345\210\206.md"
@@ -105,7 +105,7 @@ for (int i = 3; i <= n ; i++) {
 
 以上动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int integerBreak(int n) {
@@ -132,7 +132,7 @@ public:
 
 给出我的C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int integerBreak(int n) {
@@ -158,7 +158,7 @@ public:
 
 其实这道题目的递推公式并不好想，而且初始化的地方也很有讲究，我在写本题的时候一开始写的代码是这样的：
 
-```C++
+```CPP
 class Solution {
 public:
     int integerBreak(int n) {
diff --git "a/problems/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md" "b/problems/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
index af8198eed2..4f96f8395e 100644
--- "a/problems/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.md"
@@ -74,7 +74,7 @@ https://leetcode-cn.com/problems/reverse-string/
 
 不难写出如下C++代码:
 
-```C++
+```CPP
 void reverseString(vector<char>& s) {
     for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
         swap(s[i],s[j]);
@@ -90,7 +90,7 @@ swap可以有两种实现。
 
 一种就是常见的交换数值：
 
-```C++
+```CPP
 int tmp = s[i];
 s[i] = s[j];
 s[j] = tmp;
@@ -99,7 +99,7 @@ s[j] = tmp;
 
 一种就是通过位运算：
 
-```C++
+```CPP
 s[i] ^= s[j];
 s[j] ^= s[i];
 s[i] ^= s[j];
@@ -120,7 +120,7 @@ s[i] ^= s[j];
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void reverseString(vector<char>& s) {
diff --git "a/problems/0347.\345\211\215K\344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md" "b/problems/0347.\345\211\215K\344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md"
index 93f1060b10..680de3bde3 100644
--- "a/problems/0347.\345\211\215K\344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md"
+++ "b/problems/0347.\345\211\215K\344\270\252\351\253\230\351\242\221\345\205\203\347\264\240.md"
@@ -76,7 +76,7 @@ https://leetcode-cn.com/problems/top-k-frequent-elements/
 我们来看一下C++代码：
 
 
-```C++
+```CPP
 // 时间复杂度：O(nlogk)
 // 空间复杂度：O(n)
 class Solution {
diff --git "a/problems/0349.\344\270\244\344\270\252\346\225\260\347\273\204\347\232\204\344\272\244\351\233\206.md" "b/problems/0349.\344\270\244\344\270\252\346\225\260\347\273\204\347\232\204\344\272\244\351\233\206.md"
index 80dca17dc3..29c1c14490 100644
--- "a/problems/0349.\344\270\244\344\270\252\346\225\260\347\273\204\347\232\204\344\272\244\351\233\206.md"
+++ "b/problems/0349.\344\270\244\344\270\252\346\225\260\347\273\204\347\232\204\344\272\244\351\233\206.md"
@@ -54,7 +54,7 @@ std::set和std::multiset底层实现都是红黑树，std::unordered_set的底
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
diff --git "a/problems/0376.\346\221\206\345\212\250\345\272\217\345\210\227.md" "b/problems/0376.\346\221\206\345\212\250\345\272\217\345\210\227.md"
index fefb549742..0ccc405afa 100644
--- "a/problems/0376.\346\221\206\345\212\250\345\272\217\345\210\227.md"
+++ "b/problems/0376.\346\221\206\345\212\250\345\272\217\345\210\227.md"
@@ -70,7 +70,7 @@
 
 C++代码如下（和上图是对应的逻辑）：
 
-```C++
+```CPP
 class Solution {
 public:
     int wiggleMaxLength(vector<int>& nums) {
diff --git "a/problems/0377.\347\273\204\345\220\210\346\200\273\345\222\214\342\205\243.md" "b/problems/0377.\347\273\204\345\220\210\346\200\273\345\222\214\342\205\243.md"
index 4130d12fe3..3f735727f5 100644
--- "a/problems/0377.\347\273\204\345\220\210\346\200\273\345\222\214\342\205\243.md"
+++ "b/problems/0377.\347\273\204\345\220\210\346\200\273\345\222\214\342\205\243.md"
@@ -107,7 +107,7 @@ dp[i]（考虑nums[j]）可以由 dp[i - nums[j]]（不考虑nums[j]） 推导
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int combinationSum4(vector<int>& nums, int target) {
diff --git "a/problems/0383.\350\265\216\351\207\221\344\277\241.md" "b/problems/0383.\350\265\216\351\207\221\344\277\241.md"
index dafbaf09ce..f2c1685a13 100644
--- "a/problems/0383.\350\265\216\351\207\221\344\277\241.md"
+++ "b/problems/0383.\350\265\216\351\207\221\344\277\241.md"
@@ -40,7 +40,7 @@ canConstruct("aa", "aab") -> true
 
 那么第一个思路其实就是暴力枚举了，两层for循环，不断去寻找，代码如下：
 
-```C++
+```CPP
 // 时间复杂度: O(n^2)
 // 空间复杂度：O(1)
 class Solution {
@@ -79,7 +79,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 // 时间复杂度: O(n)
 // 空间复杂度：O(1)
 class Solution {
diff --git "a/problems/0392.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md" "b/problems/0392.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
index 7e4d66b7ca..bcf3462b6e 100644
--- "a/problems/0392.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/0392.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
@@ -107,7 +107,7 @@ dp[i][j]表示以下标i-1为结尾的字符串s和以下标j-1为结尾的字
 
 动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isSubsequence(string s, string t) {
diff --git "a/problems/0404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md" "b/problems/0404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
index aad59368be..84ec2310b8 100644
--- "a/problems/0404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
+++ "b/problems/0404.\345\267\246\345\217\266\345\255\220\344\271\213\345\222\214.md"
@@ -65,7 +65,7 @@ if (root == NULL) return 0;
 
 代码如下：
 
-```C++
+```CPP
 int leftValue = sumOfLeftLeaves(root->left);    // 左
 int rightValue = sumOfLeftLeaves(root->right);  // 右
                                                 // 中
@@ -81,7 +81,7 @@ return sum;
 
 整体递归代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int sumOfLeftLeaves(TreeNode* root) {
@@ -102,7 +102,7 @@ public:
 
 以上代码精简之后如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int sumOfLeftLeaves(TreeNode* root) {
@@ -123,7 +123,7 @@ public:
 
 判断条件都是一样的，代码如下：
 
-```C++
+```CPP
 
 class Solution {
 public:
diff --git "a/problems/0406.\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227.md" "b/problems/0406.\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227.md"
index 7bc4e76cc5..e9b9a7386c 100644
--- "a/problems/0406.\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227.md"
+++ "b/problems/0406.\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227.md"
@@ -99,7 +99,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -127,7 +127,7 @@ public:
 
 改成链表之后，C++代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
index 03225fb683..0f1f094aef 100644
--- "a/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
+++ "b/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
@@ -106,7 +106,7 @@
 
 代码如下：
 
-```C++
+```CPP
 // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
 // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
 vector<int> dp(10001, 0);
@@ -118,7 +118,7 @@ vector<int> dp(10001, 0);
 
 代码如下：
 
-```C++
+```CPP
 // 开始 01背包
 for(int i = 0; i < nums.size(); i++) {
     for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
@@ -141,7 +141,7 @@ dp[i]的数值一定是小于等于i的。
 
 综上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool canPartition(vector<int>& nums) {
diff --git "a/problems/0435.\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md" "b/problems/0435.\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md"
index 39a8828701..70d0ff3adc 100644
--- "a/problems/0435.\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md"
+++ "b/problems/0435.\346\227\240\351\207\215\345\217\240\345\214\272\351\227\264.md"
@@ -126,7 +126,7 @@ public:
 
 把[452.用最少数量的箭引爆气球](https://mp.weixin.qq.com/s/HxVAJ6INMfNKiGwI88-RFw)代码稍做修改，就可以AC本题。
 
-```C++
+```CPP
 class Solution {
 public:
     // 按照区间右边界排序
@@ -152,7 +152,7 @@ public:
 ```
 
 这里按照 左区间遍历，或者按照右边界遍历，都可以AC，具体原因我还没有仔细看，后面有空再补充。
-```C++
+```CPP
 class Solution {
 public:
     // 按照区间左边界排序
diff --git "a/problems/0450.\345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md" "b/problems/0450.\345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
index 13a1f0e456..96c4946860 100644
--- "a/problems/0450.\345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
+++ "b/problems/0450.\345\210\240\351\231\244\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\350\212\202\347\202\271.md"
@@ -78,7 +78,7 @@ if (root == nullptr) return root;
 
 代码如下：
 
-```C++
+```CPP
 if (root->val == key) {
     // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
     // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
@@ -111,7 +111,7 @@ return root;
 
 **整体代码如下：（注释中：情况1，2，3，4，5和上面分析严格对应）**
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* deleteNode(TreeNode* root, int key) {
@@ -156,7 +156,7 @@ public:
 
 代码如下：（关键部分已经注释）
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* deleteNode(TreeNode* root, int key) {
@@ -186,7 +186,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     // 将目标节点（删除节点）的左子树放到 目标节点的右子树的最左面节点的左孩子位置上
diff --git "a/problems/0452.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" "b/problems/0452.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
index f6c7783b62..589105b260 100644
--- "a/problems/0452.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
+++ "b/problems/0452.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
@@ -84,7 +84,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     static bool cmp(const vector<int>& a, const vector<int>& b) {
diff --git "a/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md" "b/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
index 23d50c2d6f..eafee43e86 100644
--- "a/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
+++ "b/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
@@ -53,7 +53,7 @@ D = [ 0, 2]
 
 C++代码:
 
-```C++
+```CPP
 class Solution {
 public:
     int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
diff --git "a/problems/0455.\345\210\206\345\217\221\351\245\274\345\271\262.md" "b/problems/0455.\345\210\206\345\217\221\351\245\274\345\271\262.md"
index d1a93c2768..1926894237 100644
--- "a/problems/0455.\345\210\206\345\217\221\351\245\274\345\271\262.md"
+++ "b/problems/0455.\345\210\206\345\217\221\351\245\274\345\271\262.md"
@@ -59,7 +59,7 @@
 
 C++代码整体如下：
 
-```C++
+```CPP
 // 时间复杂度：O(nlogn)
 // 空间复杂度：O(1)
 class Solution {
@@ -88,7 +88,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findContentChildren(vector<int>& g, vector<int>& s) {
diff --git "a/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md" "b/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
index c6cb0840fb..3b73594244 100644
--- "a/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
@@ -70,7 +70,7 @@ next[len - 1] = 7，next[len - 1] + 1 = 8，8就是此时字符串asdfasdfasdf
 
 C++代码如下：（这里使用了前缀表统一减一的实现方式）
 
-```C++
+```CPP
 class Solution {
 public:
     void getNext (int* next, const string& s){
@@ -104,7 +104,7 @@ public:
 
 前缀表（不减一）的C++代码实现
 
-```C++
+```CPP
 class Solution {
 public:
     void getNext (int* next, const string& s){
diff --git "a/problems/0463.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md" "b/problems/0463.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md"
index d19ce6ccbe..15255d3ec5 100644
--- "a/problems/0463.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md"
+++ "b/problems/0463.\345\262\233\345\261\277\347\232\204\345\221\250\351\225\277.md"
@@ -16,7 +16,7 @@ https://leetcode-cn.com/problems/island-perimeter/
 
 C++代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     int direction[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};
@@ -56,7 +56,7 @@ result = 岛屿数量 * 4 - cover * 2;
 
 C++代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     int islandPerimeter(vector<vector<int>>& grid) {
diff --git "a/problems/0474.\344\270\200\345\222\214\351\233\266.md" "b/problems/0474.\344\270\200\345\222\214\351\233\266.md"
index 76cf29f71a..90d1227a4a 100644
--- "a/problems/0474.\344\270\200\345\222\214\351\233\266.md"
+++ "b/problems/0474.\344\270\200\345\222\214\351\233\266.md"
@@ -95,7 +95,7 @@ dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。
 那么本题也是，物品就是strs里的字符串，背包容量就是题目描述中的m和n。
 
 代码如下：
-```C++
+```CPP
 for (string str : strs) { // 遍历物品
     int oneNum = 0, zeroNum = 0;
     for (char c : str) {
@@ -126,7 +126,7 @@ for (string str : strs) { // 遍历物品
 
 以上动规五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findMaxForm(vector<string>& strs, int m, int n) {
diff --git "a/problems/0491.\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md" "b/problems/0491.\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md"
index c3a1d631b1..ed712f34b3 100644
--- "a/problems/0491.\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/0491.\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227.md"
@@ -105,7 +105,7 @@ for (int i = startIndex; i < nums.size(); i++) {
 
 最后整体C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 private:
@@ -150,7 +150,7 @@ public:
 
 那么优化后的代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 private:
diff --git "a/problems/0494.\347\233\256\346\240\207\345\222\214.md" "b/problems/0494.\347\233\256\346\240\207\345\222\214.md"
index 3bd8536c9a..77b3c76d5c 100644
--- "a/problems/0494.\347\233\256\346\240\207\345\222\214.md"
+++ "b/problems/0494.\347\233\256\346\240\207\345\222\214.md"
@@ -67,7 +67,7 @@ target是固定的，sum是固定的，left就可以求出来。
 
 我也把代码给出来吧，大家可以了解一下，回溯的解法，以下是本题转变为组合总和问题的回溯法代码：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -124,7 +124,7 @@ x = (S + sum) / 2
 
 这么担心就对了，例如sum 是5，S是2的话其实就是无解的，所以：
 
-```C++
+```CPP
 if ((S + sum) % 2 == 1) return 0; // 此时没有方案
 ```
 
@@ -194,7 +194,7 @@ dp数组状态变化如下：
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findTargetSumWays(vector<int>& nums, int S) {
diff --git "a/problems/0496.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240I.md" "b/problems/0496.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240I.md"
index a6c0e3bcb4..bbc21d24e2 100644
--- "a/problems/0496.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240I.md"
+++ "b/problems/0496.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240I.md"
@@ -64,7 +64,7 @@ C++中，当我们要使用集合来解决哈希问题的时候，优先使用un
 
 那么预处理代码如下:
 
-```C++
+```CPP
 unordered_map<int, int> umap; // key:下表元素，value：下表
 for (int i = 0; i < nums1.size(); i++) {
     umap[nums1[i]] = i;
@@ -100,7 +100,7 @@ for (int i = 0; i < nums1.size(); i++) {
 
 代码如下：
 
-```C++
+```CPP
 while (!st.empty() && nums2[i] > nums2[st.top()]) {
     if (umap.count(nums2[st.top()]) > 0) { // 看map里是否存在这个元素
         int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下表
@@ -114,7 +114,7 @@ st.push(i);
 以上分析完毕，C++代码如下：
 
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -152,7 +152,7 @@ public:
 针对版本一，进行代码精简后，代码如下：
 
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0501.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md" "b/problems/0501.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
index 3804f42447..f29fd08aab 100644
--- "a/problems/0501.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
+++ "b/problems/0501.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\344\274\227\346\225\260.md"
@@ -53,7 +53,7 @@
 
 这里采用前序遍历，代码如下：
 
-```C++
+```CPP
 // map<int, int> key:元素，value:出现频率
 void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
     if (cur == NULL) return ;
@@ -87,7 +87,7 @@ sort(vec.begin(), vec.end(), cmp); // 给频率排个序
 
 代码如下：
 
-```C++
+```CPP
 result.push_back(vec[0].first);
 for (int i = 1; i < vec.size(); i++) {
     // 取最高的放到result数组中
@@ -100,7 +100,7 @@ return result;
 
 整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
 
@@ -145,7 +145,7 @@ public:
 
 中序遍历代码如下：
 
-```C++
+```CPP
 void searchBST(TreeNode* cur) {
     if (cur == NULL) return ;
     searchBST(cur->left);       // 左
@@ -217,7 +217,7 @@ if (count > maxCount) { // 如果计数大于最大值
 关键代码都讲完了，完整代码如下：（**只需要遍历一遍二叉搜索树，就求出了众数的集合**）
 
 
-```C++
+```CPP
 class Solution {
 private:
     int maxCount; // 最大频率
@@ -279,7 +279,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> findMode(TreeNode* root) {
diff --git "a/problems/0503.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240II.md" "b/problems/0503.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240II.md"
index c9c7604669..13c2cb29d7 100644
--- "a/problems/0503.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240II.md"
+++ "b/problems/0503.\344\270\213\344\270\200\344\270\252\346\233\264\345\244\247\345\205\203\347\264\240II.md"
@@ -32,7 +32,7 @@
 
 代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -69,7 +69,7 @@ resize倒是不费时间，是O(1)的操作，但扩充nums数组相当于多了
 
 代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" "b/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
index 7a672de59f..3b3d5056f1 100644
--- "a/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
+++ "b/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
@@ -88,7 +88,7 @@ dp[1] = 1;
 
 以上我们用动规的方法分析完了，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int fib(int N) {
@@ -110,7 +110,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int fib(int N) {
@@ -137,7 +137,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int fib(int N) {
diff --git "a/problems/0513.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md" "b/problems/0513.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md"
index 45648e2f9e..bca7e074c6 100644
--- "a/problems/0513.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md"
+++ "b/problems/0513.\346\211\276\346\240\221\345\267\246\344\270\213\350\247\222\347\232\204\345\200\274.md"
@@ -55,7 +55,7 @@
 
 代码如下：
 
-```C++
+```CPP
 int maxLen = INT_MIN;   // 全局变量 记录最大深度
 int maxleftValue;       // 全局变量 最大深度最左节点的数值
 void traversal(TreeNode* root, int leftLen)
@@ -77,7 +77,7 @@ void traversal(TreeNode* root, int leftLen)
 
 代码如下：
 
-```C++
+```CPP
 if (root->left == NULL && root->right == NULL) {
     if (leftLen > maxLen) {
         maxLen = leftLen;           // 更新最大深度
@@ -91,7 +91,7 @@ if (root->left == NULL && root->right == NULL) {
 
 在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：
 
-```C++
+```CPP
                     // 中
 if (root->left) {   // 左
     leftLen++; // 深度加一
@@ -108,7 +108,7 @@ return;
 
 完整代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxLen = INT_MIN;
@@ -142,7 +142,7 @@ public:
 
 当然回溯的地方可以精简，精简代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxLen = INT_MIN;
@@ -183,7 +183,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findBottomLeftValue(TreeNode* root) {
diff --git "a/problems/0516.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227.md" "b/problems/0516.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227.md"
index 9ec481452f..54cea10eb6 100644
--- "a/problems/0516.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/0516.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\345\272\217\345\210\227.md"
@@ -69,7 +69,7 @@
 
 代码如下：
 
-```C++
+```CPP
 if (s[i] == s[j]) {
     dp[i][j] = dp[i + 1][j - 1] + 2;
 } else {
@@ -85,7 +85,7 @@ if (s[i] == s[j]) {
 
 其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); 中dp[i][j]才不会被初始值覆盖。
 
-```C++
+```CPP
 vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
 for (int i = 0; i < s.size(); i++) dp[i][i] = 1;
 ```
@@ -102,7 +102,7 @@ for (int i = 0; i < s.size(); i++) dp[i][i] = 1;
 
 代码如下：
 
-```C++
+```CPP
 for (int i = s.size() - 1; i >= 0; i--) {
     for (int j = i + 1; j < s.size(); j++) {
         if (s[i] == s[j]) {
@@ -124,7 +124,7 @@ for (int i = s.size() - 1; i >= 0; i--) {
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int longestPalindromeSubseq(string s) {
diff --git "a/problems/0518.\351\233\266\351\222\261\345\205\221\346\215\242II.md" "b/problems/0518.\351\233\266\351\222\261\345\205\221\346\215\242II.md"
index 3e372fabb8..ea2b1777b7 100644
--- "a/problems/0518.\351\233\266\351\222\261\345\205\221\346\215\242II.md"
+++ "b/problems/0518.\351\233\266\351\222\261\345\205\221\346\215\242II.md"
@@ -111,7 +111,7 @@ dp[j] （考虑coins[i]的组合总和） 就是所有的dp[j - coins[i]]（不
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 0; i < coins.size(); i++) { // 遍历物品
     for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
         dp[j] += dp[j - coins[i]];
@@ -151,7 +151,7 @@ for (int j = 0; j <= amount; j++) { // 遍历背包容量
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int change(int amount, vector<int>& coins) {
diff --git "a/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md" "b/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
index 5a06173400..04c03b3f48 100644
--- "a/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
+++ "b/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
@@ -39,7 +39,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
 vector<int> vec;
@@ -75,7 +75,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
 int result = INT_MAX;
@@ -105,7 +105,7 @@ public:
 
 下面我给出其中的一种中序遍历的迭代法，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int getMinimumDifference(TreeNode* root) {
diff --git "a/problems/0538.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md" "b/problems/0538.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md"
index fd1999ec11..d22cb4bcaf 100644
--- "a/problems/0538.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md"
+++ "b/problems/0538.\346\212\212\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\275\254\346\215\242\344\270\272\347\264\257\345\212\240\346\240\221.md"
@@ -107,7 +107,7 @@ traversal(cur->left);   // 左
 
 递归法整体代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int pre; // 记录前一个节点的数值
@@ -133,7 +133,7 @@ public:
 
 这里我给出其中的一种，代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int pre; // 记录前一个节点的数值
diff --git "a/problems/0541.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262II.md" "b/problems/0541.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262II.md"
index 20e1525405..ab1ef16afa 100644
--- "a/problems/0541.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262II.md"
+++ "b/problems/0541.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262II.md"
@@ -46,7 +46,7 @@ https://leetcode-cn.com/problems/reverse-string-ii/
 
 使用C++库函数reverse的版本如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string reverseStr(string s, int k) {
@@ -69,7 +69,7 @@ public:
 
 下面我实现的reverse函数区间是左闭右闭区间，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     void reverse(string& s, int start, int end) {
diff --git "a/problems/0583.\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234.md" "b/problems/0583.\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234.md"
index 926fda31ed..f6c13039f5 100644
--- "a/problems/0583.\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234.md"
+++ "b/problems/0583.\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234.md"
@@ -56,7 +56,7 @@ dp[i][0]：word2为空字符串，以i-1为结尾的字符串word2要删除多
 
 dp[0][j]的话同理，所以代码如下：
 
-```C++
+```CPP
 vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
 for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
 for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
@@ -78,7 +78,7 @@ for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
 
 以上分析完毕，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int minDistance(string word1, string word2) {
diff --git "a/problems/0617.\345\220\210\345\271\266\344\272\214\345\217\211\346\240\221.md" "b/problems/0617.\345\220\210\345\271\266\344\272\214\345\217\211\346\240\221.md"
index 57d61ab311..b24a934b66 100644
--- "a/problems/0617.\345\220\210\345\271\266\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0617.\345\220\210\345\271\266\344\272\214\345\217\211\346\240\221.md"
@@ -90,7 +90,7 @@ return t1;
 
 此时前序遍历，完整代码就写出来了，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
@@ -107,7 +107,7 @@ public:
 
 那么中序遍历也是可以的，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
@@ -124,7 +124,7 @@ public:
 
 后序遍历依然可以，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
@@ -145,7 +145,7 @@ public:
 
 不修改输入树的结构，前序遍历，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
@@ -169,7 +169,7 @@ public:
 
 本题我们也使用队列，模拟的层序遍历，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
@@ -216,7 +216,7 @@ public:
 如下代码中，想要更改二叉树的值，应该传入指向指针的指针。
 
 代码如下：（前序遍历）
-```C++
+```CPP
 class Solution {
 public:
     void process(TreeNode** t1, TreeNode** t2) {
diff --git "a/problems/0647.\345\233\236\346\226\207\345\255\220\344\270\262.md" "b/problems/0647.\345\233\236\346\226\207\345\255\220\344\270\262.md"
index 22d8d0be9c..f81801b76e 100644
--- "a/problems/0647.\345\233\236\346\226\207\345\255\220\344\270\262.md"
+++ "b/problems/0647.\345\233\236\346\226\207\345\255\220\344\270\262.md"
@@ -61,7 +61,7 @@
 
 以上三种情况分析完了，那么递归公式如下：
 
-```C++
+```CPP
 if (s[i] == s[j]) {
     if (j - i <= 1) { // 情况一 和 情况二
         result++;
@@ -101,7 +101,7 @@ dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：
 
 代码如下：
 
-```C++
+```CPP
 for (int i = s.size() - 1; i >= 0; i--) {  // 注意遍历顺序
     for (int j = i; j < s.size(); j++) {
         if (s[i] == s[j]) {
@@ -129,7 +129,7 @@ for (int i = s.size() - 1; i >= 0; i--) {  // 注意遍历顺序
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int countSubstrings(string s) {
@@ -154,7 +154,7 @@ public:
 ```
 以上代码是为了凸显情况一二三，当然是可以简洁一下的，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int countSubstrings(string s) {
@@ -192,7 +192,7 @@ public:
 
 **这两种情况可以放在一起计算，但分别计算思路更清晰，我倾向于分别计算**，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int countSubstrings(string s) {
diff --git "a/problems/0649.Dota2\345\217\202\350\256\256\351\231\242.md" "b/problems/0649.Dota2\345\217\202\350\256\256\351\231\242.md"
index 5015ab6157..b73686c472 100644
--- "a/problems/0649.Dota2\345\217\202\350\256\256\351\231\242.md"
+++ "b/problems/0649.Dota2\345\217\202\350\256\256\351\231\242.md"
@@ -78,7 +78,7 @@ Dota2 参议院由来自两派的参议员组成。现在参议院希望对一
 C++代码如下：
 
 
-```C++
+```CPP
 class Solution {
 public:
     string predictPartyVictory(string senate) {
diff --git "a/problems/0654.\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.md" "b/problems/0654.\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.md"
index 361c4a1f1d..8c310a21f3 100644
--- "a/problems/0654.\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0654.\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.md"
@@ -107,7 +107,7 @@ if (maxValueIndex < (nums.size() - 1)) {
 ```
 这样我们就分析完了，整体代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
@@ -147,7 +147,7 @@ public:
 
 优化后代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     // 在左闭右开区间[left, right)，构造二叉树
@@ -182,7 +182,7 @@ public:
 可以发现上面的代码看上去简洁一些，**主要是因为第二版其实是允许空节点进入递归，所以不用在递归的时候加判断节点是否为空**
 
 第一版递归过程：（加了if判断，为了不让空节点进入递归）
-```C++
+```CPP
 
 if (maxValueIndex > 0) { // 这里加了判断是为了不让空节点进入递归
     vector<int> newVec(nums.begin(), nums.begin() + maxValueIndex);
diff --git "a/problems/0657.\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271.md" "b/problems/0657.\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271.md"
index 796cd579d3..480e830f4d 100644
--- "a/problems/0657.\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271.md"
+++ "b/problems/0657.\346\234\272\345\231\250\344\272\272\350\203\275\345\220\246\350\277\224\345\233\236\345\216\237\347\202\271.md"
@@ -48,7 +48,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool judgeCircle(string moves) {
diff --git "a/problems/0669.\344\277\256\345\211\252\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md" "b/problems/0669.\344\277\256\345\211\252\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
index 0dc48f87a4..3b315350aa 100644
--- "a/problems/0669.\344\277\256\345\211\252\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
+++ "b/problems/0669.\344\277\256\345\211\252\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.md"
@@ -32,7 +32,7 @@
 
 不难写出如下代码：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* trimBST(TreeNode* root, int low, int high) {
@@ -145,7 +145,7 @@ root->left = trimBST(root->left, low, high);
 
 最后整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* trimBST(TreeNode* root, int low, int high) {
@@ -167,7 +167,7 @@ public:
 
 精简之后代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* trimBST(TreeNode* root, int low, int high) {
@@ -195,7 +195,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* trimBST(TreeNode* root, int L, int R) {
diff --git "a/problems/0673.\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227\347\232\204\344\270\252\346\225\260.md" "b/problems/0673.\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227\347\232\204\344\270\252\346\225\260.md"
index bc56b8c916..ce3e863997 100644
--- "a/problems/0673.\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227\347\232\204\344\270\252\346\225\260.md"
+++ "b/problems/0673.\346\234\200\351\225\277\351\200\222\345\242\236\345\255\220\345\272\217\345\210\227\347\232\204\344\270\252\346\225\260.md"
@@ -58,7 +58,7 @@ if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
 
 代码如下：
 
-```C++
+```CPP
 if (nums[i] > nums[j]) {
     if (dp[j] + 1 > dp[i]) {
         count[i] = count[j];
@@ -71,7 +71,7 @@ if (nums[i] > nums[j]) {
 
 当然也可以这么写：
 
-```C++
+```CPP
 if (nums[i] > nums[j]) {
     if (dp[j] + 1 > dp[i]) {
         dp[i] = dp[j] + 1; // 更新dp[i]放在这里，就不用max了
@@ -88,7 +88,7 @@ if (nums[i] > nums[j]) {
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < nums.size(); i++) {
     for (int j = 0; j < i; j++) {
         if (nums[i] > nums[j]) {
@@ -131,7 +131,7 @@ dp[i] 是由0到i-1各个位置的最长升序子序列 推导而来，那么遍
 
 j其实就是0到i-1，遍历i的循环里外层，遍历j则在内层，代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < nums.size(); i++) {
     for (int j = 0; j < i; j++) {
         if (nums[i] > nums[j]) {
@@ -152,7 +152,7 @@ for (int i = 1; i < nums.size(); i++) {
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i < nums.size(); i++) {
     for (int j = 0; j < i; j++) {
         if (nums[i] > nums[j]) {
@@ -184,7 +184,7 @@ for (int i = 0; i < nums.size(); i++) {
 
 以上分析完毕，C++整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findNumberOfLIS(vector<int>& nums) {
diff --git "a/problems/0674.\346\234\200\351\225\277\350\277\236\347\273\255\351\200\222\345\242\236\345\272\217\345\210\227.md" "b/problems/0674.\346\234\200\351\225\277\350\277\236\347\273\255\351\200\222\345\242\236\345\272\217\345\210\227.md"
index b8fc738af6..0fe1c49a7b 100644
--- "a/problems/0674.\346\234\200\351\225\277\350\277\236\347\273\255\351\200\222\345\242\236\345\272\217\345\210\227.md"
+++ "b/problems/0674.\346\234\200\351\225\277\350\277\236\347\273\255\351\200\222\345\242\236\345\272\217\345\210\227.md"
@@ -73,7 +73,7 @@
 
 本文在确定递推公式的时候也说明了为什么本题只需要一层for循环，代码如下：
 
-```C++
+```CPP
 for (int i = 0; i < nums.size() - 1; i++) {
     if (nums[i + 1] > nums[i]) { // 连续记录
         dp[i + 1] = dp[i] + 1; // 递推公式
@@ -91,7 +91,7 @@ for (int i = 0; i < nums.size() - 1; i++) {
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findLengthOfLCIS(vector<int>& nums) {
@@ -118,7 +118,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findLengthOfLCIS(vector<int>& nums) {
diff --git "a/problems/0684.\345\206\227\344\275\231\350\277\236\346\216\245.md" "b/problems/0684.\345\206\227\344\275\231\350\277\236\346\216\245.md"
index 20e8080627..c9eb33c40b 100644
--- "a/problems/0684.\345\206\227\344\275\231\350\277\236\346\216\245.md"
+++ "b/problems/0684.\345\206\227\344\275\231\350\277\236\346\216\245.md"
@@ -37,7 +37,7 @@
 
 这里整理出我的并查集模板如下：
 
-```C++
+```CPP
 int n = 1005; // 节点数量3 到 1000
 int father[1005];
 
@@ -88,7 +88,7 @@ bool same(int u, int v) {
 
 并查集C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     int n = 1005; // 节点数量3 到 1000
diff --git "a/problems/0685.\345\206\227\344\275\231\350\277\236\346\216\245II.md" "b/problems/0685.\345\206\227\344\275\231\350\277\236\346\216\245II.md"
index cde55a6e82..e282e620a8 100644
--- "a/problems/0685.\345\206\227\344\275\231\350\277\236\346\216\245II.md"
+++ "b/problems/0685.\345\206\227\344\275\231\350\277\236\346\216\245II.md"
@@ -58,7 +58,7 @@
 
 首先先计算节点的入度，代码如下：
 
-```C++
+```CPP
 int inDegree[N] = {0}; // 记录节点入度
 n = edges.size(); // 边的数量
 for (int i = 0; i < n; i++) {
@@ -70,7 +70,7 @@ for (int i = 0; i < n; i++) {
 
 代码如下：
 
-```C++
+```CPP
 vector<int> vec; // 记录入度为2的边（如果有的话就两条边）
 // 找入度为2的节点所对应的边，注意要倒叙，因为优先返回最后出现在二维数组中的答案
 for (int i = n - 1; i >= 0; i--) {
@@ -112,7 +112,7 @@ vector<int> getRemoveEdge(const vector<vector<int>>& edges)
 本题C++代码如下：（详细注释了）
 
 
-```C++
+```CPP
 class Solution {
 private:
     static const int N = 1010; // 如题：二维数组大小的在3到1000范围内
diff --git "a/problems/0700.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\220\234\347\264\242.md" "b/problems/0700.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\220\234\347\264\242.md"
index 3bcf231c87..68d30e3f85 100644
--- "a/problems/0700.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\220\234\347\264\242.md"
+++ "b/problems/0700.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\220\234\347\264\242.md"
@@ -79,7 +79,7 @@ return NULL;
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* searchBST(TreeNode* root, int val) {
@@ -109,7 +109,7 @@ public:
 
 所以迭代法代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* searchBST(TreeNode* root, int val) {
diff --git "a/problems/0701.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\217\222\345\205\245\346\223\215\344\275\234.md" "b/problems/0701.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\217\222\345\205\245\346\223\215\344\275\234.md"
index 6890705604..fdaba43ed1 100644
--- "a/problems/0701.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\217\222\345\205\245\346\223\215\344\275\234.md"
+++ "b/problems/0701.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\344\270\255\347\232\204\346\217\222\345\205\245\346\223\215\344\275\234.md"
@@ -96,7 +96,7 @@ return root;
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* insertIntoBST(TreeNode* root, int val) {
@@ -126,7 +126,7 @@ void traversal(TreeNode* cur, int val)
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     TreeNode* parent;
@@ -172,7 +172,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* insertIntoBST(TreeNode* root, int val) {
diff --git "a/problems/0704.\344\272\214\345\210\206\346\237\245\346\211\276.md" "b/problems/0704.\344\272\214\345\210\206\346\237\245\346\211\276.md"
index 02c231bce7..2efbd7c471 100644
--- "a/problems/0704.\344\272\214\345\210\206\346\237\245\346\211\276.md"
+++ "b/problems/0704.\344\272\214\345\210\206\346\237\245\346\211\276.md"
@@ -63,7 +63,7 @@
 
 代码如下：（详细注释）
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -102,7 +102,7 @@ public:
 
 代码如下：（详细注释）
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md" "b/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
index 90f6bcf970..0aa038e8e6 100644
--- "a/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
+++ "b/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
@@ -56,7 +56,7 @@ https://leetcode-cn.com/problems/design-linked-list/
 
 
 ## 代码
-```C++
+```CPP
 class MyLinkedList {
 public:
     // 定义链表节点结构体
diff --git "a/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md" "b/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md"
index 450976a478..6dc95a2df5 100644
--- "a/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md"
+++ "b/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.md"
@@ -60,7 +60,7 @@
 
 贪心算法C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices, int fee) {
@@ -101,7 +101,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices, int fee) {
@@ -126,7 +126,7 @@ public:
 
 C++ 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices, int fee) {
diff --git "a/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md" "b/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
index c75d596e1c..53952a7fcf 100644
--- "a/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
+++ "b/problems/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271\357\274\210\345\212\250\346\200\201\350\247\204\345\210\222\357\274\211.md"
@@ -72,7 +72,7 @@ dp[i][1] 表示第i天不持有股票所得最多现金
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices, int fee) {
diff --git "a/problems/0718.\346\234\200\351\225\277\351\207\215\345\244\215\345\255\220\346\225\260\347\273\204.md" "b/problems/0718.\346\234\200\351\225\277\351\207\215\345\244\215\345\255\220\346\225\260\347\273\204.md"
index b60585e38c..2fe38f0a37 100644
--- "a/problems/0718.\346\234\200\351\225\277\351\207\215\345\244\215\345\255\220\346\225\260\347\273\204.md"
+++ "b/problems/0718.\346\234\200\351\225\277\351\207\215\345\244\215\345\255\220\346\225\260\347\273\204.md"
@@ -74,7 +74,7 @@ dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 1; i <= A.size(); i++) {
     for (int j = 1; j <= B.size(); j++) {
         if (A[i - 1] == B[j - 1]) {
@@ -94,7 +94,7 @@ for (int i = 1; i <= A.size(); i++) {
 
 以上五部曲分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int findLength(vector<int>& A, vector<int>& B) {
@@ -128,7 +128,7 @@ public:
 
 **此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖**。
 
-```C++
+```CPP
 class Solution {
 public:
     int findLength(vector<int>& A, vector<int>& B) {
diff --git "a/problems/0724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\347\264\242\345\274\225.md" "b/problems/0724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\347\264\242\345\274\225.md"
index 45a9c05c56..3ed68d4705 100644
--- "a/problems/0724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\347\264\242\345\274\225.md"
+++ "b/problems/0724.\345\257\273\346\211\276\346\225\260\347\273\204\347\232\204\344\270\255\345\277\203\347\264\242\345\274\225.md"
@@ -43,7 +43,7 @@
     * 判断leftSum和rightSum是否相同
 
 C++代码如下：
-```C++
+```CPP
 class Solution {
 public:
     int pivotIndex(vector<int>& nums) {
diff --git "a/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md" "b/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
index 169fe2caae..7cb2423670 100644
--- "a/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
+++ "b/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
@@ -34,7 +34,7 @@
 题意很简单，那么首先想的就是暴力解法了，来我替大家暴力一波，结果自然是超时！
 
 代码如下：
-```C++
+```CPP
 class Solution {
 private:
     bool checkNum(int num) {
@@ -87,7 +87,7 @@ public:
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int monotoneIncreasingDigits(int N) {
diff --git "a/problems/0739.\346\257\217\346\227\245\346\270\251\345\272\246.md" "b/problems/0739.\346\257\217\346\227\245\346\270\251\345\272\246.md"
index a023de3521..ddcbe428f3 100644
--- "a/problems/0739.\346\257\217\346\227\245\346\270\251\345\272\246.md"
+++ "b/problems/0739.\346\257\217\346\227\245\346\270\251\345\272\246.md"
@@ -117,7 +117,7 @@ T[4]弹出之后， T[5] > T[3] （当前遍历的元素T[i]大于栈顶元素T[
 
 C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -148,7 +148,7 @@ public:
 
 精简代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/0746.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md" "b/problems/0746.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md"
index f039c5027b..9b691c5f7f 100644
--- "a/problems/0746.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md"
+++ "b/problems/0746.\344\275\277\347\224\250\346\234\200\345\260\217\350\212\261\350\264\271\347\210\254\346\245\274\346\242\257.md"
@@ -98,7 +98,7 @@ dp[1] = cost[1];
 
 以上分析完毕，整体C++代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -120,7 +120,7 @@ public:
 
 还可以优化空间复杂度，因为dp[i]就是由前两位推出来的，那么也不用dp数组了，C++代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -165,7 +165,7 @@ public:
 
 所以代码这么写：
 
-```C++
+```CPP
 class Solution {
 public:
     int minCostClimbingStairs(vector<int>& cost) {
diff --git "a/problems/0763.\345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md" "b/problems/0763.\345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
index 40b241feec..ccf654d47a 100644
--- "a/problems/0763.\345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
+++ "b/problems/0763.\345\210\222\345\210\206\345\255\227\346\257\215\345\214\272\351\227\264.md"
@@ -47,7 +47,7 @@
 
 明白原理之后，代码并不复杂，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> partitionLabels(string S) {
diff --git "a/problems/0841.\351\222\245\345\214\231\345\222\214\346\210\277\351\227\264.md" "b/problems/0841.\351\222\245\345\214\231\345\222\214\346\210\277\351\227\264.md"
index de49df3a2d..bd7c99c9a7 100644
--- "a/problems/0841.\351\222\245\345\214\231\345\222\214\346\210\277\351\227\264.md"
+++ "b/problems/0841.\351\222\245\345\214\231\345\222\214\346\210\277\351\227\264.md"
@@ -54,7 +54,7 @@
 
 BFS C++代码代码如下：
 
-```C++
+```CPP
 class Solution {
 bool bfs(const vector<vector<int>>& rooms) {
     vector<int> visited(rooms.size(), 0); // 标记房间是否被访问过
@@ -89,7 +89,7 @@ public:
 
 DFS C++代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     void dfs(int key, const vector<vector<int>>& rooms, vector<int>& visited) {
diff --git "a/problems/0844.\346\257\224\350\276\203\345\220\253\351\200\200\346\240\274\347\232\204\345\255\227\347\254\246\344\270\262.md" "b/problems/0844.\346\257\224\350\276\203\345\220\253\351\200\200\346\240\274\347\232\204\345\255\227\347\254\246\344\270\262.md"
index ac94ea3664..32232c4ab2 100644
--- "a/problems/0844.\346\257\224\350\276\203\345\220\253\351\200\200\346\240\274\347\232\204\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/0844.\346\257\224\350\276\203\345\220\253\351\200\200\346\240\274\347\232\204\345\255\227\347\254\246\344\270\262.md"
@@ -50,7 +50,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool backspaceCompare(string S, string T) {
@@ -78,7 +78,7 @@ public:
 
 当然以上代码，大家可以发现有重复的逻辑处理S，处理T，可以把这块公共逻辑抽离出来，代码精简如下：
 
-```C++
+```CPP
 class Solution {
 private:
 string getString(const string& S) {
@@ -115,7 +115,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool backspaceCompare(string S, string T) {
diff --git "a/problems/0860.\346\237\240\346\252\254\346\260\264\346\211\276\351\233\266.md" "b/problems/0860.\346\237\240\346\252\254\346\260\264\346\211\276\351\233\266.md"
index d5b87d82ab..792bee9a01 100644
--- "a/problems/0860.\346\237\240\346\252\254\346\260\264\346\211\276\351\233\266.md"
+++ "b/problems/0860.\346\237\240\346\252\254\346\260\264\346\211\276\351\233\266.md"
@@ -82,7 +82,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool lemonadeChange(vector<int>& bills) {
diff --git "a/problems/0922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204II.md" "b/problems/0922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204II.md"
index 4f4394ec13..92db204d09 100644
--- "a/problems/0922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204II.md"
+++ "b/problems/0922.\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204II.md"
@@ -32,7 +32,7 @@
 
 其实这道题可以用很朴实的方法，时间复杂度就就是O(n)了，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> sortArrayByParityII(vector<int>& A) {
@@ -64,7 +64,7 @@ public:
 
 以上代码我是建了两个辅助数组，而且A数组还相当于遍历了两次，用辅助数组的好处就是思路清晰，优化一下就是不用这两个辅助树，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> sortArrayByParityII(vector<int>& A) {
@@ -93,7 +93,7 @@ public:
 
 当然还可以在原数组上修改，连result数组都不用了。
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> sortArrayByParityII(vector<int>& A) {
diff --git "a/problems/0925.\351\225\277\346\214\211\351\224\256\345\205\245.md" "b/problems/0925.\351\225\277\346\214\211\351\224\256\345\205\245.md"
index be7991632a..4d3543f45f 100644
--- "a/problems/0925.\351\225\277\346\214\211\351\224\256\345\205\245.md"
+++ "b/problems/0925.\351\225\277\346\214\211\351\224\256\345\205\245.md"
@@ -59,7 +59,7 @@
 
 上面的逻辑想清楚了，不难写出如下C++代码：
 
-```C++
+```CPP
 class Solution {
 public:
     bool isLongPressedName(string name, string typed) {
diff --git "a/problems/0968.\347\233\221\346\216\247\344\272\214\345\217\211\346\240\221.md" "b/problems/0968.\347\233\221\346\216\247\344\272\214\345\217\211\346\240\221.md"
index 67bc9faa0f..380ca8f86b 100644
--- "a/problems/0968.\347\233\221\346\216\247\344\272\214\345\217\211\346\240\221.md"
+++ "b/problems/0968.\347\233\221\346\216\247\344\272\214\345\217\211\346\240\221.md"
@@ -216,7 +216,7 @@ int minCameraCover(TreeNode* root) {
 
 ## C++代码
 
-```C++
+```CPP
 // 版本一
 class Solution {
 private:
@@ -270,7 +270,7 @@ public:
 
 在以上代码的基础上，再进行精简，代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 private:
diff --git "a/problems/0977.\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\345\271\263\346\226\271.md" "b/problems/0977.\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\345\271\263\346\226\271.md"
index 2f72acb7a7..9e71ec0d8c 100644
--- "a/problems/0977.\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\345\271\263\346\226\271.md"
+++ "b/problems/0977.\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\345\271\263\346\226\271.md"
@@ -29,7 +29,7 @@ https://leetcode-cn.com/problems/squares-of-a-sorted-array/
 
 最直观的相反，莫过于：每个数平方之后，排个序，美滋滋，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> sortedSquares(vector<int>& A) {
@@ -64,7 +64,7 @@ public:
 
 不难写出如下代码：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> sortedSquares(vector<int>& A) {
diff --git "a/problems/1002.\346\237\245\346\211\276\345\270\270\347\224\250\345\255\227\347\254\246.md" "b/problems/1002.\346\237\245\346\211\276\345\270\270\347\224\250\345\255\227\347\254\246.md"
index faf2bea471..82dbf4cfd3 100644
--- "a/problems/1002.\346\237\245\346\211\276\345\270\270\347\224\250\345\255\227\347\254\246.md"
+++ "b/problems/1002.\346\237\245\346\211\276\345\270\270\347\224\250\345\255\227\347\254\246.md"
@@ -97,7 +97,7 @@ for (int i = 0; i < 26; i++) {
 
 整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<string> commonChars(vector<string>& A) {
diff --git "a/problems/1005.K\346\254\241\345\217\226\345\217\215\345\220\216\346\234\200\345\244\247\345\214\226\347\232\204\346\225\260\347\273\204\345\222\214.md" "b/problems/1005.K\346\254\241\345\217\226\345\217\215\345\220\216\346\234\200\345\244\247\345\214\226\347\232\204\346\225\260\347\273\204\345\222\214.md"
index 344aa68143..a689fbf7d5 100644
--- "a/problems/1005.K\346\254\241\345\217\226\345\217\215\345\220\216\346\234\200\345\244\247\345\214\226\347\232\204\346\225\260\347\273\204\345\222\214.md"
+++ "b/problems/1005.K\346\254\241\345\217\226\345\217\215\345\220\216\346\234\200\345\244\247\345\214\226\347\232\204\346\225\260\347\273\204\345\222\214.md"
@@ -61,7 +61,7 @@
 
 对应C++代码如下：
 
-```C++
+```CPP
 class Solution {
 static bool cmp(int a, int b) {
     return abs(a) > abs(b);
diff --git "a/problems/1035.\344\270\215\347\233\270\344\272\244\347\232\204\347\272\277.md" "b/problems/1035.\344\270\215\347\233\270\344\272\244\347\232\204\347\272\277.md"
index 9d30052a16..3172cfc719 100644
--- "a/problems/1035.\344\270\215\347\233\270\344\272\244\347\232\204\347\272\277.md"
+++ "b/problems/1035.\344\270\215\347\233\270\344\272\244\347\232\204\347\272\277.md"
@@ -45,7 +45,7 @@
 
 本题代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxUncrossedLines(vector<int>& A, vector<int>& B) {
diff --git "a/problems/1047.\345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\346\211\200\346\234\211\347\233\270\351\202\273\351\207\215\345\244\215\351\241\271.md" "b/problems/1047.\345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\346\211\200\346\234\211\347\233\270\351\202\273\351\207\215\345\244\215\351\241\271.md"
index d42856cba8..c4ae85c956 100644
--- "a/problems/1047.\345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\346\211\200\346\234\211\347\233\270\351\202\273\351\207\215\345\244\215\351\241\271.md"
+++ "b/problems/1047.\345\210\240\351\231\244\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\346\211\200\346\234\211\347\233\270\351\202\273\351\207\215\345\244\215\351\241\271.md"
@@ -69,7 +69,7 @@ https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string/
 
 C++代码 :
 
-```C++
+```CPP
 class Solution {
 public:
     string removeDuplicates(string S) {
@@ -97,7 +97,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string removeDuplicates(string S) {
diff --git "a/problems/1049.\346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217II.md" "b/problems/1049.\346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217II.md"
index 06ca872b19..7b71eae449 100644
--- "a/problems/1049.\346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217II.md"
+++ "b/problems/1049.\346\234\200\345\220\216\344\270\200\345\235\227\347\237\263\345\244\264\347\232\204\351\207\215\351\207\217II.md"
@@ -93,7 +93,7 @@ vector<int> dp(15001, 0);
 
 代码如下：
 
-```C++
+```CPP
 for (int i = 0; i < stones.size(); i++) { // 遍历物品
     for (int j = target; j >= stones[i]; j--) { // 遍历背包
         dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
@@ -119,7 +119,7 @@ for (int i = 0; i < stones.size(); i++) { // 遍历物品
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int lastStoneWeightII(vector<int>& stones) {
diff --git "a/problems/1143.\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md" "b/problems/1143.\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
index fc38f34a04..c0468d087f 100644
--- "a/problems/1143.\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
+++ "b/problems/1143.\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.md"
@@ -65,7 +65,7 @@ dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符
 
 代码如下：
 
-```C++
+```CPP
 if (text1[i - 1] == text2[j - 1]) {
     dp[i][j] = dp[i - 1][j - 1] + 1;
 } else {
@@ -107,7 +107,7 @@ vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));
 
 以上分析完毕，C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int longestCommonSubsequence(string text1, string text2) {
diff --git "a/problems/1207.\347\213\254\344\270\200\346\227\240\344\272\214\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md" "b/problems/1207.\347\213\254\344\270\200\346\227\240\344\272\214\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md"
index 84ddfa5c3f..1c09ee8ad9 100644
--- "a/problems/1207.\347\213\254\344\270\200\346\227\240\344\272\214\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md"
+++ "b/problems/1207.\347\213\254\344\270\200\346\227\240\344\272\214\347\232\204\345\207\272\347\216\260\346\254\241\346\225\260.md"
@@ -53,7 +53,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool uniqueOccurrences(vector<int>& arr) {
diff --git "a/problems/1356.\346\240\271\346\215\256\346\225\260\345\255\227\344\272\214\350\277\233\345\210\266\344\270\2131\347\232\204\346\225\260\347\233\256\346\216\222\345\272\217.md" "b/problems/1356.\346\240\271\346\215\256\346\225\260\345\255\227\344\272\214\350\277\233\345\210\266\344\270\2131\347\232\204\346\225\260\347\233\256\346\216\222\345\272\217.md"
index 2e7e8aae5a..300aa0e256 100644
--- "a/problems/1356.\346\240\271\346\215\256\346\225\260\345\255\227\344\272\214\350\277\233\345\210\266\344\270\2131\347\232\204\346\225\260\347\233\256\346\216\222\345\272\217.md"
+++ "b/problems/1356.\346\240\271\346\215\256\346\225\260\345\255\227\344\272\214\350\277\233\345\210\266\344\270\2131\347\232\204\346\225\260\347\233\256\346\216\222\345\272\217.md"
@@ -68,7 +68,7 @@ sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是
 这里就需要一个技巧了，**在构造数组hash的时候，从后向前遍历，这样hash里存放的就是相同元素最左面的数值和下标了**。
 代码如下：
 
-```C++
+```CPP
 int hash[101];
 for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
     hash[vec[i]] = i;
@@ -79,7 +79,7 @@ for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对
 
 代码如下：
 
-```C++
+```CPP
 // 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
 for (int i = 0; i < nums.size(); i++) {
     vec[i] = hash[nums[i]];
@@ -92,7 +92,7 @@ for (int i = 0; i < nums.size(); i++) {
 
 关键地方讲完了，整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
diff --git "a/problems/1365.\346\234\211\345\244\232\345\260\221\345\260\217\344\272\216\345\275\223\345\211\215\346\225\260\345\255\227\347\232\204\346\225\260\345\255\227.md" "b/problems/1365.\346\234\211\345\244\232\345\260\221\345\260\217\344\272\216\345\275\223\345\211\215\346\225\260\345\255\227\347\232\204\346\225\260\345\255\227.md"
index 4a5f08a0ea..156efea66f 100644
--- "a/problems/1365.\346\234\211\345\244\232\345\260\221\345\260\217\344\272\216\345\275\223\345\211\215\346\225\260\345\255\227\347\232\204\346\225\260\345\255\227.md"
+++ "b/problems/1365.\346\234\211\345\244\232\345\260\221\345\260\217\344\272\216\345\275\223\345\211\215\346\225\260\345\255\227\347\232\204\346\225\260\345\255\227.md"
@@ -69,7 +69,7 @@ sort(vec.begin(), vec.end()); // 从小到大排序之后，元素下标就是
 这里就需要一个技巧了，**在构造数组hash的时候，从后向前遍历，这样hash里存放的就是相同元素最左面的数值和下标了**。
 代码如下：
 
-```C++
+```CPP
 int hash[101];
 for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对应的下标
     hash[vec[i]] = i;
@@ -80,7 +80,7 @@ for (int i = vec.size() - 1; i >= 0; i--) { // 从后向前，记录 vec[i] 对
 
 代码如下：
 
-```C++
+```CPP
 // 此时hash里保存的每一个元素数值 对应的 小于这个数值的个数
 for (int i = 0; i < nums.size(); i++) {
     vec[i] = hash[nums[i]];
@@ -93,7 +93,7 @@ for (int i = 0; i < nums.size(); i++) {
 
 关键地方讲完了，整体C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> smallerNumbersThanCurrent(vector<int>& nums) {
diff --git "a/problems/1382.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\345\217\230\345\271\263\350\241\241.md" "b/problems/1382.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\345\217\230\345\271\263\350\241\241.md"
index 683f482f0d..b9d4fb6592 100644
--- "a/problems/1382.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\345\217\230\345\271\263\350\241\241.md"
+++ "b/problems/1382.\345\260\206\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\345\217\230\345\271\263\350\241\241.md"
@@ -42,7 +42,7 @@
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<int> vec;
diff --git "a/problems/O(n)\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md" "b/problems/O(n)\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
index 319e0950b4..6897c01f2b 100644
--- "a/problems/O(n)\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
+++ "b/problems/O(n)\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
@@ -67,7 +67,7 @@
 
 实现三个函数，时间复杂度分别是 O(n) , O(n^2), O(nlogn)，使用加法运算来统一测试。
 
-```C++
+```CPP
 // O(n)
 void function1(long long n) {
     long long k = 0;
@@ -78,7 +78,7 @@ void function1(long long n) {
 
 ```
 
-```C++
+```CPP
 // O(n^2)
 void function2(long long n) {
     long long k = 0;
@@ -91,7 +91,7 @@ void function2(long long n) {
 }
 ```
 
-```C++
+```CPP
 // O(nlogn)
 void function3(long long n) {
     long long k = 0;
@@ -105,7 +105,7 @@ void function3(long long n) {
 ```
 
 来看一下这三个函数随着n的规模变化，耗时会产生多大的变化，先测function1 ，就把 function2 和 function3 注释掉
-```C++
+```CPP
 int main() {
     long long n; // 数据规模
     while (1) {
@@ -154,7 +154,7 @@ O(nlogn)的算法，1s内大概计算机可以运行 2 * (10^7)次计算，符
 
 # 完整测试代码
 
-```C++
+```CPP
 #include <iostream>
 #include <chrono>
 #include <thread>
diff --git "a/problems/\344\270\272\344\272\206\347\273\235\346\235\200\347\274\226\350\276\221\350\267\235\347\246\273\357\274\214\345\215\241\345\260\224\345\201\232\344\272\206\344\270\211\346\255\245\351\223\272\345\236\253.md" "b/problems/\344\270\272\344\272\206\347\273\235\346\235\200\347\274\226\350\276\221\350\267\235\347\246\273\357\274\214\345\215\241\345\260\224\345\201\232\344\272\206\344\270\211\346\255\245\351\223\272\345\236\253.md"
index aa818a5db8..4a0ef0d28c 100644
--- "a/problems/\344\270\272\344\272\206\347\273\235\346\235\200\347\274\226\350\276\221\350\267\235\347\246\273\357\274\214\345\215\241\345\260\224\345\201\232\344\272\206\344\270\211\346\255\245\351\223\272\345\236\253.md"
+++ "b/problems/\344\270\272\344\272\206\347\273\235\346\235\200\347\274\226\350\276\221\350\267\235\347\246\273\357\274\214\345\215\241\345\260\224\345\201\232\344\272\206\344\270\211\346\255\245\351\223\272\345\236\253.md"
@@ -58,7 +58,7 @@ else dp[i][j] = dp[i][j - 1];
 
 
 状态转移方程：
-```C++
+```CPP
 if (s[i - 1] == t[j - 1]) {
     dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
 } else {
@@ -89,7 +89,7 @@ if (s[i - 1] == t[j - 1]) {
 那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
 
 状态转移方程：
-```C++
+```CPP
 if (word1[i - 1] == word2[j - 1]) {
     dp[i][j] = dp[i - 1][j - 1];
 } else {
@@ -150,7 +150,7 @@ if (word1[i - 1] != word2[j - 1])，此时就需要编辑了，如何编辑呢
 
 递归公式代码如下：
 
-```C++
+```CPP
 if (word1[i - 1] == word2[j - 1]) {
     dp[i][j] = dp[i - 1][j - 1];
 }
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\344\270\255\351\200\222\345\275\222\345\270\246\347\235\200\345\233\236\346\272\257.md" "b/problems/\344\272\214\345\217\211\346\240\221\344\270\255\351\200\222\345\275\222\345\270\246\347\235\200\345\233\236\346\272\257.md"
index 61e590d505..0f768e0fea 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\344\270\255\351\200\222\345\275\222\345\270\246\347\235\200\345\233\236\346\272\257.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\344\270\255\351\200\222\345\275\222\345\270\246\347\235\200\345\233\236\346\272\257.md"
@@ -19,7 +19,7 @@
 
 那么如下我再给出求100. 相同的树 的代码，如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* tree1, TreeNode* tree2) {
@@ -52,7 +52,7 @@ public:
 
 如下的代码充分的体现出回溯：(257. 二叉树的所有路径)
 
-```C++
+```CPP
 class Solution {
 private:
 
@@ -120,13 +120,13 @@ public:
 
 为了把这份精简代码的回溯过程展现出来，大家可以试一试把：
 
-```C++
+```CPP
 if (cur->left) traversal(cur->left, path + "->", result); // 左  回溯就隐藏在这里
 ```
 
 改成如下代码：
 
-```C++
+```CPP
 path += "->";
 traversal(cur->left, path, result); // 左
 ```
@@ -149,7 +149,7 @@ if (cur->right) {
 
 如果想把回溯加上，就要 在上面代码的基础上，加上回溯，就可以AC了。
 
-```C++
+```CPP
 if (cur->left) {
     path += "->";
     traversal(cur->left, path, result); // 左
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
index 6119bc69d5..d105f4b80d 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
@@ -34,7 +34,7 @@
 
 中序遍历代码如下：（详细注释）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> inorderTraversal(TreeNode* root) {
@@ -77,7 +77,7 @@ public:
 
 迭代法前序遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> preorderTraversal(TreeNode* root) {
@@ -108,7 +108,7 @@ public:
 
 后续遍历代码如下： (**注意此时我们和中序遍历相比仅仅改变了两行代码的顺序**)
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> postorderTraversal(TreeNode* root) {
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md"
index d4dadd7c3e..faa580e09e 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\350\277\255\344\273\243\351\201\215\345\216\206.md"
@@ -37,7 +37,7 @@
 
 不难写出如下代码: （**注意代码中空节点不入栈**）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> preorderTraversal(TreeNode* root) {
@@ -84,7 +84,7 @@ public:
 
 **中序遍历，可以写出如下代码：**
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> inorderTraversal(TreeNode* root) {
@@ -116,7 +116,7 @@ public:
 
 **所以后序遍历只需要前序遍历的代码稍作修改就可以了，代码如下：**
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> postorderTraversal(TreeNode* root) {
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\351\200\222\345\275\222\351\201\215\345\216\206.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\351\200\222\345\275\222\351\201\215\345\216\206.md"
index 6d91e115cc..223cf7222e 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\351\200\222\345\275\222\351\201\215\345\216\206.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\351\200\222\345\275\222\351\201\215\345\216\206.md"
@@ -58,7 +58,7 @@ traversal(cur->right, vec); // 右
 
 前序遍历：
 
-```C++
+```CPP
 class Solution {
 public:
     void traversal(TreeNode* cur, vector<int>& vec) {
@@ -79,7 +79,7 @@ public:
 
 中序遍历：
 
-```C++
+```CPP
 void traversal(TreeNode* cur, vector<int>& vec) {
     if (cur == NULL) return;
     traversal(cur->left, vec);  // 左
@@ -90,7 +90,7 @@ void traversal(TreeNode* cur, vector<int>& vec) {
 
 后序遍历：
 
-```C++
+```CPP
 void traversal(TreeNode* cur, vector<int>& vec) {
     if (cur == NULL) return;
     traversal(cur->left, vec);  // 左
diff --git "a/problems/\345\211\215\345\272\217/On\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md" "b/problems/\345\211\215\345\272\217/On\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
index 5c43812065..d9cc8d450c 100644
--- "a/problems/\345\211\215\345\272\217/On\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
+++ "b/problems/\345\211\215\345\272\217/On\347\232\204\347\256\227\346\263\225\345\261\205\347\204\266\350\266\205\346\227\266\344\272\206\357\274\214\346\255\244\346\227\266\347\232\204n\347\251\266\347\253\237\346\230\257\345\244\232\345\244\247\357\274\237.md"
@@ -67,7 +67,7 @@
 
 实现三个函数，时间复杂度分别是 O(n) , O(n^2), O(nlogn)，使用加法运算来统一测试。
 
-```C++
+```CPP
 // O(n)
 void function1(long long n) {
     long long k = 0;
@@ -78,7 +78,7 @@ void function1(long long n) {
 
 ```
 
-```C++
+```CPP
 // O(n^2)
 void function2(long long n) {
     long long k = 0;
@@ -91,7 +91,7 @@ void function2(long long n) {
 }
 ```
 
-```C++
+```CPP
 // O(nlogn)
 void function3(long long n) {
     long long k = 0;
@@ -105,7 +105,7 @@ void function3(long long n) {
 ```
 
 来看一下这三个函数随着n的规模变化，耗时会产生多大的变化，先测function1 ，就把 function2 和 function3 注释掉
-```C++
+```CPP
 int main() {
     long long n; // 数据规模
     while (1) {
@@ -154,7 +154,7 @@ O(nlogn)的算法，1s内大概计算机可以运行 2 * (10^7)次计算，符
 
 # 完整测试代码
 
-```C++
+```CPP
 #include <iostream>
 #include <chrono>
 #include <thread>
diff --git "a/problems/\345\211\215\345\272\217/\344\273\200\344\271\210\346\230\257\346\240\270\345\277\203\344\273\243\347\240\201\346\250\241\345\274\217\357\274\214\344\273\200\344\271\210\345\217\210\346\230\257ACM\346\250\241\345\274\217\357\274\237.md" "b/problems/\345\211\215\345\272\217/\344\273\200\344\271\210\346\230\257\346\240\270\345\277\203\344\273\243\347\240\201\346\250\241\345\274\217\357\274\214\344\273\200\344\271\210\345\217\210\346\230\257ACM\346\250\241\345\274\217\357\274\237.md"
index 29e45f9a4e..3c5fb4e47f 100644
--- "a/problems/\345\211\215\345\272\217/\344\273\200\344\271\210\346\230\257\346\240\270\345\277\203\344\273\243\347\240\201\346\250\241\345\274\217\357\274\214\344\273\200\344\271\210\345\217\210\346\230\257ACM\346\250\241\345\274\217\357\274\237.md"
+++ "b/problems/\345\211\215\345\272\217/\344\273\200\344\271\210\346\230\257\346\240\270\345\277\203\344\273\243\347\240\201\346\250\241\345\274\217\357\274\214\344\273\200\344\271\210\345\217\210\346\230\257ACM\346\250\241\345\274\217\357\274\237.md"
@@ -13,7 +13,7 @@
 
 而力扣上是核心代码模式，就是把要处理的数据都已经放入容器里，可以直接写逻辑，例如这样：
 
-```C++
+```CPP
 class Solution {
 public:
     int minimumTotal(vector<vector<int>>& triangle) {
@@ -55,7 +55,7 @@ public:
 
 这道题如果要是力扣上的核心代码模式，OJ应该直接给出如下代码：
 
-```C++
+```CPP
 class Solution {
 public:
     int getDays(vector<int>& work, vector<int>& gym) {
@@ -72,7 +72,7 @@ ACM模式要求写出来的代码是直接可以本地运行的，所以我们
 
 拿本题来说，为了让代码可以运行，需要include这些库函数：
 
-```C++
+```CPP
 #include<iostream>
 #include<vector>
 using namespace std;
@@ -87,7 +87,7 @@ using namespace std;
 
 完整代码如下：
 
-```C++
+```CPP
 #include<iostream>
 #include<vector>
 using namespace std;
diff --git "a/problems/\345\211\215\345\272\217/\344\273\243\347\240\201\351\243\216\346\240\274.md" "b/problems/\345\211\215\345\272\217/\344\273\243\347\240\201\351\243\216\346\240\274.md"
index 4c240080f8..a71ac420a5 100644
--- "a/problems/\345\211\215\345\272\217/\344\273\243\347\240\201\351\243\216\346\240\274.md"
+++ "b/problems/\345\211\215\345\272\217/\344\273\243\347\240\201\351\243\216\346\240\274.md"
@@ -108,7 +108,7 @@ while (n) {
 ```
 
 以下是我刚写的力扣283.移动零的代码，大家可以看一下整体风格，注意空格的细节！
-```C++
+```CPP
 class Solution {
 public:
     void moveZeroes(vector<int>& nums) {
diff --git "a/problems/\345\211\215\345\272\217/\345\205\263\344\272\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\357\274\214\345\217\257\350\203\275\346\234\211\345\207\240\344\270\252\347\226\221\351\227\256\357\274\237.md" "b/problems/\345\211\215\345\272\217/\345\205\263\344\272\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\357\274\214\345\217\257\350\203\275\346\234\211\345\207\240\344\270\252\347\226\221\351\227\256\357\274\237.md"
index 8ff891b466..0f25f3781d 100644
--- "a/problems/\345\211\215\345\272\217/\345\205\263\344\272\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\357\274\214\345\217\257\350\203\275\346\234\211\345\207\240\344\270\252\347\226\221\351\227\256\357\274\237.md"
+++ "b/problems/\345\211\215\345\272\217/\345\205\263\344\272\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\357\274\214\345\217\257\350\203\275\346\234\211\345\207\240\344\270\252\347\226\221\351\227\256\357\274\237.md"
@@ -42,7 +42,7 @@
 
 来看一下例子，什么时候的空间复杂度是O(1)呢，C++代码如下：
 
-```C++
+```CPP
 int j = 0;
 for (int i = 0; i < n; i++) {
     j++;
@@ -54,7 +54,7 @@ for (int i = 0; i < n; i++) {
 什么时候的空间复杂度是O(n)？
 
 当消耗空间和输入参数n保持线性增长，这样的空间复杂度为O(n)，来看一下这段C++代码
-```C++
+```CPP
 int* a = new int(n);
 for (int i = 0; i < n; i++) {
     a[i] = i;
diff --git "a/problems/\345\211\215\345\272\217/\345\210\267\344\272\206\350\277\231\344\271\210\345\244\232\351\242\230\357\274\214\344\275\240\344\272\206\350\247\243\350\207\252\345\267\261\344\273\243\347\240\201\347\232\204\345\206\205\345\255\230\346\266\210\350\200\227\344\271\210\357\274\237.md" "b/problems/\345\211\215\345\272\217/\345\210\267\344\272\206\350\277\231\344\271\210\345\244\232\351\242\230\357\274\214\344\275\240\344\272\206\350\247\243\350\207\252\345\267\261\344\273\243\347\240\201\347\232\204\345\206\205\345\255\230\346\266\210\350\200\227\344\271\210\357\274\237.md"
index b7b6dd4d56..3fccfb2278 100644
--- "a/problems/\345\211\215\345\272\217/\345\210\267\344\272\206\350\277\231\344\271\210\345\244\232\351\242\230\357\274\214\344\275\240\344\272\206\350\247\243\350\207\252\345\267\261\344\273\243\347\240\201\347\232\204\345\206\205\345\255\230\346\266\210\350\200\227\344\271\210\357\274\237.md"
+++ "b/problems/\345\211\215\345\272\217/\345\210\267\344\272\206\350\277\231\344\271\210\345\244\232\351\242\230\357\274\214\344\275\240\344\272\206\350\247\243\350\207\252\345\267\261\344\273\243\347\240\201\347\232\204\345\206\205\345\255\230\346\266\210\350\200\227\344\271\210\357\274\237.md"
@@ -77,7 +77,7 @@
 
 可以看一下这段C++代码输出的各个数据类型大小是多少？
 
-```C++
+```CPP
 struct node{
    int num;
    char cha;
diff --git "a/problems/\345\211\215\345\272\217/\345\212\233\346\211\243\344\270\212\347\232\204\344\273\243\347\240\201\346\203\263\345\234\250\346\234\254\345\234\260\347\274\226\350\257\221\350\277\220\350\241\214\357\274\237.md" "b/problems/\345\211\215\345\272\217/\345\212\233\346\211\243\344\270\212\347\232\204\344\273\243\347\240\201\346\203\263\345\234\250\346\234\254\345\234\260\347\274\226\350\257\221\350\277\220\350\241\214\357\274\237.md"
index 7105db8459..a0fcbcd825 100644
--- "a/problems/\345\211\215\345\272\217/\345\212\233\346\211\243\344\270\212\347\232\204\344\273\243\347\240\201\346\203\263\345\234\250\346\234\254\345\234\260\347\274\226\350\257\221\350\277\220\350\241\214\357\274\237.md"
+++ "b/problems/\345\211\215\345\272\217/\345\212\233\346\211\243\344\270\212\347\232\204\344\273\243\347\240\201\346\203\263\345\234\250\346\234\254\345\234\260\347\274\226\350\257\221\350\277\220\350\241\214\357\274\237.md"
@@ -27,7 +27,7 @@
 
 力扣746. 使用最小花费爬楼梯，完整的可以在直接本地运行的C++代码如下：
 
-```C++
+```CPP
 #include <iostream>
 #include <vector>
 using namespace std;
diff --git "a/problems/\345\211\215\345\272\217/\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\344\270\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\345\210\206\346\236\220.md" "b/problems/\345\211\215\345\272\217/\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\344\270\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\345\210\206\346\236\220.md"
index 03323d3a54..b6c79f2506 100644
--- "a/problems/\345\211\215\345\272\217/\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\344\270\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\345\210\206\346\236\220.md"
+++ "b/problems/\345\211\215\345\272\217/\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\344\270\216\347\251\272\351\227\264\345\244\215\346\235\202\345\272\246\345\210\206\346\236\220.md"
@@ -18,7 +18,7 @@
 
 先来看一下求斐波那契数的递归写法。
 
-```C++
+```CPP
 int fibonacci(int i) {
        if(i <= 0) return 0;
        if(i == 1) return 1;
@@ -50,7 +50,7 @@ int fibonacci(int i) {
 
 以下为C++代码，来测一下，让我们输入n的时候，这段递归求斐波那契代码的耗时。
 
-```C++
+```CPP
 #include <iostream>
 #include <chrono>
 #include <thread>
@@ -99,7 +99,7 @@ int main()
 
 其实罪魁祸首就是这里的两次递归，导致了时间复杂度以指数上升。
 
-```C++
+```CPP
 return fibonacci(i-1) + fibonacci(i-2);
 ```
 
@@ -107,7 +107,7 @@ return fibonacci(i-1) + fibonacci(i-2);
 
 来看一下如下代码：
 
-```C++
+```CPP
 // 版本二
 int fibonacci(int first, int second, int n) {
     if (n <= 0) {
@@ -138,7 +138,7 @@ int fibonacci(int first, int second, int n) {
 
 此时再来测一下耗时情况验证一下：
 
-```C++
+```CPP
 #include <iostream>
 #include <chrono>
 #include <thread>
@@ -208,7 +208,7 @@ int main()
 
 那么每次递归的空间复杂度是O(1)， 调用栈深度为n，所以这段递归代码的空间复杂度就是O(n)。
 
-```C++
+```CPP
 int fibonacci(int i) {
        if(i <= 0) return 0;
        if(i == 1) return 1;
@@ -227,7 +227,7 @@ int fibonacci(int i) {
 
 带大家再分析一段二分查找的递归实现。
 
-```C++
+```CPP
 int binary_search( int arr[], int l, int r, int x) {
     if (r >= l) {
         int mid = l + (r - l) / 2;
diff --git "a/problems/\345\211\215\345\272\217/\351\200\232\350\277\207\344\270\200\351\201\223\351\235\242\350\257\225\351\242\230\347\233\256\357\274\214\350\256\262\344\270\200\350\256\262\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\345\244\215\346\235\202\345\272\246\357\274\201.md" "b/problems/\345\211\215\345\272\217/\351\200\232\350\277\207\344\270\200\351\201\223\351\235\242\350\257\225\351\242\230\347\233\256\357\274\214\350\256\262\344\270\200\350\256\262\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\345\244\215\346\235\202\345\272\246\357\274\201.md"
index cb3d6a4b13..b3aef43c37 100644
--- "a/problems/\345\211\215\345\272\217/\351\200\232\350\277\207\344\270\200\351\201\223\351\235\242\350\257\225\351\242\230\347\233\256\357\274\214\350\256\262\344\270\200\350\256\262\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\345\244\215\346\235\202\345\272\246\357\274\201.md"
+++ "b/problems/\345\211\215\345\272\217/\351\200\232\350\277\207\344\270\200\351\201\223\351\235\242\350\257\225\351\242\230\347\233\256\357\274\214\350\256\262\344\270\200\350\256\262\351\200\222\345\275\222\347\256\227\346\263\225\347\232\204\346\227\266\351\227\264\345\244\215\346\235\202\345\272\246\357\274\201.md"
@@ -27,7 +27,7 @@
 
 想一下这么简单的一道题目，代码应该如何写呢。最直观的方式应该就是，一个for循环求出结果，代码如下：
 
-```C++
+```CPP
 int function1(int x, int n) {
     int result = 1;  // 注意 任何数的0次方等于1
     for (int i = 0; i < n; i++) {
@@ -44,7 +44,7 @@ int function1(int x, int n) {
 
 那么就可以写出了如下这样的一个递归的算法，使用递归解决了这个问题。
 
-```C++
+```CPP
 int function2(int x, int n) {
     if (n == 0) {
         return 1; // return 1 同样是因为0次方是等于1的
@@ -62,7 +62,7 @@ int function2(int x, int n) {
 
 这个时间复杂度就没有达到面试官的预期。于是又写出了如下的递归算法的代码：
 
-```C++
+```CPP
 int function3(int x, int n) {
     if (n == 0) {
         return 1;
@@ -101,7 +101,7 @@ int function3(int x, int n) {
 
 于是又写出如下递归算法的代码：
 
-```C++
+```CPP
 int function4(int x, int n) {
     if (n == 0) {
         return 1;
@@ -132,7 +132,7 @@ int function4(int x, int n) {
 
 对于function3 这样的递归实现，很容易让人感觉这是O(logn)的时间复杂度，其实这是O(n)的算法！
 
-```C++
+```CPP
 int function3(int x, int n) {
     if (n == 0) {
         return 1;
diff --git "a/problems/\345\211\221\346\214\207Offer05.\346\233\277\346\215\242\347\251\272\346\240\274.md" "b/problems/\345\211\221\346\214\207Offer05.\346\233\277\346\215\242\347\251\272\346\240\274.md"
index 4f99160262..4ae5f9f22a 100644
--- "a/problems/\345\211\221\346\214\207Offer05.\346\233\277\346\215\242\347\251\272\346\240\274.md"
+++ "b/problems/\345\211\221\346\214\207Offer05.\346\233\277\346\215\242\347\251\272\346\240\274.md"
@@ -46,7 +46,7 @@ i指向新长度的末尾，j指向旧长度的末尾。
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string replaceSpace(string s) {
diff --git "a/problems/\345\211\221\346\214\207Offer58-II.\345\267\246\346\227\213\350\275\254\345\255\227\347\254\246\344\270\262.md" "b/problems/\345\211\221\346\214\207Offer58-II.\345\267\246\346\227\213\350\275\254\345\255\227\347\254\246\344\270\262.md"
index 4a756e82c7..76908f2dda 100644
--- "a/problems/\345\211\221\346\214\207Offer58-II.\345\267\246\346\227\213\350\275\254\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/\345\211\221\346\214\207Offer58-II.\345\267\246\346\227\213\350\275\254\345\255\227\347\254\246\344\270\262.md"
@@ -58,7 +58,7 @@ https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     string reverseLeftWords(string s, int n) {
diff --git "a/problems/\345\212\250\346\200\201\350\247\204\345\210\222-\350\202\241\347\245\250\351\227\256\351\242\230\346\200\273\347\273\223\347\257\207.md" "b/problems/\345\212\250\346\200\201\350\247\204\345\210\222-\350\202\241\347\245\250\351\227\256\351\242\230\346\200\273\347\273\223\347\257\207.md"
index 0edf8d49d3..d186aaf950 100644
--- "a/problems/\345\212\250\346\200\201\350\247\204\345\210\222-\350\202\241\347\245\250\351\227\256\351\242\230\346\200\273\347\273\223\347\257\207.md"
+++ "b/problems/\345\212\250\346\200\201\350\247\204\345\210\222-\350\202\241\347\245\250\351\227\256\351\242\230\346\200\273\347\273\223\347\257\207.md"
@@ -24,7 +24,7 @@
 【贪心解法】
 
 取最左最小值，取最右最大值，那么得到的差值就是最大利润，代码如下：
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -56,7 +56,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -79,7 +79,7 @@ public:
 
 使用滚动数组，代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -110,7 +110,7 @@ public:
 
 收集每天的正利润便可，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -146,7 +146,7 @@ dp数组定义：
 
 代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -204,7 +204,7 @@ dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
 
 代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -230,7 +230,7 @@ public:
 
 当然，大家可以看到力扣官方题解里的一种优化空间写法，我这里给出对应的C++版本：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -291,7 +291,7 @@ dp[i][2] = max(dp[i - 1][i] + prices[i], dp[i][2])
 
 同理可以类比剩下的状态，代码如下：
 
-```C++
+```CPP
 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]);
@@ -300,7 +300,7 @@ for (int j = 0; j < 2 * k - 1; j += 2) {
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(int k, vector<int>& prices) {
@@ -375,7 +375,7 @@ p[i][3] = dp[i - 1][2];
 
 综上分析，递推代码如下：
 
-```C++
+```CPP
 dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3]- prices[i], dp[i - 1][1]) - prices[i];
 dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
 dp[i][2] = dp[i - 1][0] + prices[i];
@@ -384,7 +384,7 @@ dp[i][3] = dp[i - 1][2];
 
 整体代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -439,7 +439,7 @@ dp[i][1] 表示第i天不持有股票所得最多现金
 
 以上分析完毕，代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices, int fee) {
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20200927\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20200927\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 1f5768ab50..f81cc6bb71 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20200927\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20200927\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -13,7 +13,7 @@
 
 对于二叉树节点的定义，C++代码如下：
 
-```C++
+```CPP
 struct TreeNode {
     int val;
     TreeNode *left;
@@ -35,7 +35,7 @@ TreeNode* a = new TreeNode(9);
 
 没有构造函数的话就要这么写：
 
-```C++
+```CPP
 TreeNode* a = new TreeNode();
 a->val = 9;
 a->left = NULL;
@@ -66,7 +66,7 @@ morris遍历是二叉树遍历算法的超强进阶算法，morris遍历可以
 
 拿前序遍历来举例，空节点入栈：
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> preorderTraversal(TreeNode* root) {
@@ -88,7 +88,7 @@ public:
 
 前序遍历空节点不入栈的代码：（注意注释部分和上文的区别）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> preorderTraversal(TreeNode* root) {
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20201003\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20201003\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 6626c27e4a..db89fc827b 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20201003\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20201003\344\272\214\345\217\211\346\240\221\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -21,7 +21,7 @@
 
 100.相同的树的递归代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* left, TreeNode* right) {
@@ -48,7 +48,7 @@ public:
 
 100.相同的树，精简之后代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     bool compare(TreeNode* left, TreeNode* right) {
@@ -67,7 +67,7 @@ public:
 
 100.相同的树，迭代法代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
 
@@ -109,7 +109,7 @@ public:
 **而根节点的高度就是二叉树的最大深度**，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度，所以[二叉树：看看这些树的最大深度](https://mp.weixin.qq.com/s/guKwV-gSNbA1CcbvkMtHBg)中使用的是后序遍历。
 
 本题当然也可以使用前序，代码如下：(**充分表现出求深度回溯的过程**)
-```C++
+```CPP
 class Solution {
 public:
     int result;
@@ -143,7 +143,7 @@ public:
 
 注意以上代码是为了把细节体现出来，简化一下代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     int result;
@@ -223,12 +223,12 @@ public:
 文中我明确的说了：**回溯就隐藏在traversal(cur->left, path + "->", result);中的 path + "->"。 每次函数调用完，path依然是没有加上"->" 的，这就是回溯了。**
 
 如果还不理解的话，可以把
-```C++
+```CPP
 traversal(cur->left, path + "->", result);
 ```
 
 改成
-```C++
+```CPP
 string tmp = path + "->";
 traversal(cur->left, tmp, result);
 ```
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20201224\350\264\252\345\277\203\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20201224\350\264\252\345\277\203\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 6077a00aea..a82433cf36 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20201224\350\264\252\345\277\203\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20201224\350\264\252\345\277\203\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -31,7 +31,7 @@
 把[贪心算法：用最少数量的箭引爆气球](https://mp.weixin.qq.com/s/HxVAJ6INMfNKiGwI88-RFw)代码稍做修改，别可以AC本题。
 
 修改后的C++代码如下：
-```C++
+```CPP
 class Solution {
 public:
     // 按照区间左边界从大到小排序
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210107\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210107\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 3434fe9621..67957f059e 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210107\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210107\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -51,7 +51,7 @@ dp[0]其实就是一个无意义的存在，不用去初始化dp[0]。
 
 一个严谨的思考过程，应该是初始化dp[1] = 1，dp[2] = 2，然后i从3开始遍历，代码如下：
 
-```C++
+```CPP
 dp[1] = 1;
 dp[2] = 2;
 for (int i = 3; i <= n; i++) { // 注意i是从3开始的
@@ -67,7 +67,7 @@ for (int i = 3; i <= n; i++) { // 注意i是从3开始的
 
 这里我先给出我的实现代码：
 
-```C++
+```CPP
 class Solution {
 public:
     int climbStairs(int n) {
@@ -122,7 +122,7 @@ public:
 
 所以代码也可以这么写：
 
-```C++
+```CPP
 class Solution {
 public:
     int minCostClimbingStairs(vector<int>& cost) {
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210121\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210121\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 4b63a3a381..bffe47fb40 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210121\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210121\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -29,7 +29,7 @@ dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
 
 3. dp数组如何初始化
 
-```C++
+```CPP
 // 初始化 dp
 vector<vector<int>> dp(weight.size() + 1, vector<int>(bagWeight + 1, 0));
 for (int j = bagWeight; j >= weight[0]; j--) {
@@ -43,7 +43,7 @@ for (int j = bagWeight; j >= weight[0]; j--) {
 
 但是先遍历物品更好理解。代码如下：
 
-```C++
+```CPP
 // weight数组的大小 就是物品个数
 for(int i = 1; i < weight.size(); i++) { // 遍历物品
     for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
@@ -107,7 +107,7 @@ dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
 
 代码如下：
 
-```C++
+```CPP
 for(int i = 0; i < weight.size(); i++) { // 遍历物品
     for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
         dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210128\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210128\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index bb08bc1f9a..bea4cc6001 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210128\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210128\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -86,7 +86,7 @@ dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
 
 完全背包的物品是可以添加多次的，所以遍历背包容量要从小到大去遍历，即：
 
-```C++
+```CPP
 // 先遍历物品，再遍历背包
 for(int i = 0; i < weight.size(); i++) { // 遍历物品
     for(int j = weight[i]; j < bagWeight ; j++) { // 遍历背包容量
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210204\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210204\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 1341b83f9a..d2417f8fc2 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210204\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210204\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -20,7 +20,7 @@
 
 所以本题遍历顺序最终遍历顺序：**target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历**。
 
-```C++
+```CPP
 class Solution {
 public:
     int combinationSum4(vector<int>& nums, int target) {
@@ -56,7 +56,7 @@ public:
 和昨天的题目[动态规划：377. 组合总和 Ⅳ](https://mp.weixin.qq.com/s/Iixw0nahJWQgbqVNk8k6gA)基本就是一道题了，遍历顺序也是一样一样的！
 
 代码如下：
-```C++
+```CPP
 class Solution {
 public:
     int climbStairs(int n) {
@@ -93,7 +93,7 @@ public:
 
 
 外层for循环遍历物品，内层for遍历背包：
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -115,7 +115,7 @@ public:
 
 外层for遍历背包，内层for循环遍历物品：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
@@ -148,7 +148,7 @@ public:
 
 先遍历背包，在遍历物品：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -167,7 +167,7 @@ public:
 
 先遍历物品，在遍历背包：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210225\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210225\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 7e6ed19b30..ea3c551565 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210225\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210225\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -71,7 +71,7 @@ dp[1] = max(nums[0], nums[1]);
 
 这道题目我给出了暴力的解法：
 
-```C++
+```CPP
 class Solution {
 public:
     int rob(TreeNode* root) {
@@ -94,7 +94,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     unordered_map<TreeNode* , int> umap; // 记录计算过的结果
@@ -120,7 +120,7 @@ public:
 
 1. 确定递归函数的参数和返回值
 
-```C++
+```CPP
 vector<int> robTree(TreeNode* cur) {
 ```
 
@@ -142,7 +142,7 @@ if (cur == NULL) return vector<int>{0, 0};
 
 采用后序遍历，代码如下：
 
-```C++
+```CPP
 // 下标0：不偷，下标1：偷
 vector<int> left = robTree(cur->left); // 左
 vector<int> right = robTree(cur->right); // 右
@@ -160,7 +160,7 @@ vector<int> right = robTree(cur->right); // 右
 
 代码如下：
 
-```C++
+```CPP
 vector<int> left = robTree(cur->left); // 左
 vector<int> right = robTree(cur->right); // 右
 
@@ -218,7 +218,7 @@ public:
 
 因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。
 
-```C++
+```CPP
 class Solution {
 public:
     int maxProfit(vector<int>& prices) {
@@ -237,7 +237,7 @@ public:
 
 动规解法，版本一，代码如下：
 
-```C++
+```CPP
 // 版本一
 class Solution {
 public:
@@ -262,7 +262,7 @@ public:
 
 那么我们只需要记录 当前天的dp状态和前一天的dp状态就可以了，可以使用滚动数组来节省空间，代码如下：
 
-```C++
+```CPP
 // 版本二
 class Solution {
 public:
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/20210304\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md" "b/problems/\345\221\250\346\200\273\347\273\223/20210304\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
index 37ad8499c2..9fea624422 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/20210304\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/20210304\345\212\250\350\247\204\345\221\250\346\234\253\346\200\273\347\273\223.md"
@@ -110,7 +110,7 @@ j的状态表示为：
 
 还要强调一下：dp[i][1]，**表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区**。
 
-```C++
+```CPP
 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]);
@@ -125,7 +125,7 @@ for (int j = 0; j < 2 * k - 1; j += 2) {
 
 代码如下：
 
-```C++
+```CPP
 for (int j = 1; j < 2 * k; j += 2) {
     dp[0][j] = -prices[0];
 }
diff --git "a/problems/\345\221\250\346\200\273\347\273\223/\344\272\214\345\217\211\346\240\221\351\230\266\346\256\265\346\200\273\347\273\223\347\263\273\345\210\227\344\270\200.md" "b/problems/\345\221\250\346\200\273\347\273\223/\344\272\214\345\217\211\346\240\221\351\230\266\346\256\265\346\200\273\347\273\223\347\263\273\345\210\227\344\270\200.md"
index e586e0e843..c8235ff18b 100644
--- "a/problems/\345\221\250\346\200\273\347\273\223/\344\272\214\345\217\211\346\240\221\351\230\266\346\256\265\346\200\273\347\273\223\347\263\273\345\210\227\344\270\200.md"
+++ "b/problems/\345\221\250\346\200\273\347\273\223/\344\272\214\345\217\211\346\240\221\351\230\266\346\256\265\346\200\273\347\273\223\347\263\273\345\210\227\344\270\200.md"
@@ -18,7 +18,7 @@
 
 对于二叉树节点的定义，C++代码如下：
 
-```C++
+```CPP
 struct TreeNode {
     int val;
     TreeNode *left;
@@ -40,7 +40,7 @@ TreeNode* a = new TreeNode(9);
 
 没有构造函数的话就要这么写：
 
-```C++
+```CPP
 TreeNode* a = new TreeNode();
 a->val = 9;
 a->left = NULL;
@@ -68,7 +68,7 @@ morris遍历是二叉树遍历算法的超强进阶算法，morris遍历可以
 
 前序遍历空节点不入栈的代码：（注意注释部分，和文章中的区别）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> preorderTraversal(TreeNode* root) {
@@ -91,7 +91,7 @@ public:
 
 后序遍历空节点不入栈的代码：（注意注释部分，和文章中的区别）
 
-```C++
+```CPP
 class Solution {
 public:
     vector<int> postorderTraversal(TreeNode* root) {
@@ -152,7 +152,7 @@ public:
 
 如果非要使用递归中序的方式写，也可以，如下代码就可以避免节点左右孩子翻转两次的情况：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
@@ -171,7 +171,7 @@ public:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     TreeNode* invertTree(TreeNode* root) {
diff --git "a/problems/\345\233\236\346\272\257\347\256\227\346\263\225\345\216\273\351\207\215\351\227\256\351\242\230\347\232\204\345\217\246\344\270\200\347\247\215\345\206\231\346\263\225.md" "b/problems/\345\233\236\346\272\257\347\256\227\346\263\225\345\216\273\351\207\215\351\227\256\351\242\230\347\232\204\345\217\246\344\270\200\347\247\215\345\206\231\346\263\225.md"
index 763b8cbf28..cc563fb1a2 100644
--- "a/problems/\345\233\236\346\272\257\347\256\227\346\263\225\345\216\273\351\207\215\351\227\256\351\242\230\347\232\204\345\217\246\344\270\200\347\247\215\345\206\231\346\263\225.md"
+++ "b/problems/\345\233\236\346\272\257\347\256\227\346\263\225\345\216\273\351\207\215\351\227\256\351\242\230\347\232\204\345\217\246\344\270\200\347\247\215\345\206\231\346\263\225.md"
@@ -30,7 +30,7 @@ used数组去重版本： [回溯算法：求子集问题（二）](https://mp.w
 
 使用set去重的版本如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -71,7 +71,7 @@ public:
 
 例如：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -110,7 +110,7 @@ private:
 
 代码如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -142,7 +142,7 @@ uset已经是全局变量，本层的uset记录了一个元素，然后进入下
 
 使用set去重的版本如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
@@ -183,7 +183,7 @@ public:
 
 使用set去重的版本如下：
 
-```C++
+```CPP
 class Solution {
 private:
     vector<vector<int>> result;
diff --git "a/problems/\346\225\260\347\273\204\347\220\206\350\256\272\345\237\272\347\241\200.md" "b/problems/\346\225\260\347\273\204\347\220\206\350\256\272\345\237\272\347\241\200.md"
index 9fe7744b59..6d7b9f9ab6 100644
--- "a/problems/\346\225\260\347\273\204\347\220\206\350\256\272\345\237\272\347\241\200.md"
+++ "b/problems/\346\225\260\347\273\204\347\220\206\350\256\272\345\237\272\347\241\200.md"
@@ -53,7 +53,7 @@
 
 我们来做一个实验，C++测试代码如下：
 
-```C++
+```CPP
 void test_arr() {
     int array[2][3] = {
 		{0, 1, 2},
diff --git "a/problems/\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227\357\274\210vector\345\216\237\347\220\206\350\256\262\350\247\243\357\274\211.md" "b/problems/\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227\357\274\210vector\345\216\237\347\220\206\350\256\262\350\247\243\357\274\211.md"
index d504cf8eaa..baf7dcf542 100644
--- "a/problems/\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227\357\274\210vector\345\216\237\347\220\206\350\256\262\350\247\243\357\274\211.md"
+++ "b/problems/\346\240\271\346\215\256\350\272\253\351\253\230\351\207\215\345\273\272\351\230\237\345\210\227\357\274\210vector\345\216\237\347\220\206\350\256\262\350\247\243\357\274\211.md"
@@ -12,7 +12,7 @@
 但是在解释的过程中有不恰当的地方，所以来专门写一篇文章来详细说一说这个问题。
 
 使用vector的代码如下：
-```C++
+```CPP
 // 版本一，使用vector（动态数组）
 class Solution {
 public:
@@ -38,7 +38,7 @@ public:
 其直观上来看数组的insert操作是O(n)的，整体代码的时间复杂度是O(n^2)。
 
 这么一分析好像和版本二链表实现的时间复杂度是一样的啊，为什么提交之后效率会差距这么大呢？
-```C++
+```CPP
 // 版本二，使用list（链表）
 class Solution {
 public:
@@ -107,7 +107,7 @@ for (int i = 0; i < vec.size(); i++) {
 
 手动模拟的过程其实不是很简单的，需要很多细节，我粗略写了一个版本，如下：
 
-```C++
+```CPP
 // 版本三
 // 使用vector，但不让它动态扩容
 class Solution {
diff --git "a/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-1.md" "b/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-1.md"
index c94bff3278..c13efc3a28 100644
--- "a/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-1.md"
+++ "b/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-1.md"
@@ -223,7 +223,7 @@ dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括
 
 ## 完整C++测试代码
 
-```C++
+```CPP
 void test_2_wei_bag_problem1() {
     vector<int> weight = {1, 3, 4};
     vector<int> value = {15, 20, 30};
diff --git "a/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-2.md" "b/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-2.md"
index 9acc5f73c1..4f1455e976 100644
--- "a/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-2.md"
+++ "b/problems/\350\203\214\345\214\205\347\220\206\350\256\272\345\237\272\347\241\20001\350\203\214\345\214\205-2.md"
@@ -153,7 +153,7 @@ dp[1] = dp[1 - weight[0]] + value[0] = 15
 
 ## 一维dp01背包完整C++测试代码
 
-```C++
+```CPP
 void test_1_wei_bag_problem() {
     vector<int> weight = {1, 3, 4};
     vector<int> value = {15, 20, 30};
diff --git "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\244\232\351\207\215\350\203\214\345\214\205.md" "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\244\232\351\207\215\350\203\214\345\214\205.md"
index 7d4ec08f6d..85cbf4ded7 100644
--- "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\244\232\351\207\215\350\203\214\345\214\205.md"
+++ "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\244\232\351\207\215\350\203\214\345\214\205.md"
@@ -56,7 +56,7 @@
 这种方式来实现多重背包的代码如下：
 
 
-```C++
+```CPP
 void test_multi_pack() {
     vector<int> weight = {1, 3, 4};
     vector<int> value = {15, 20, 30};
@@ -96,7 +96,7 @@ int main() {
 代码如下：（详看注释）
 
 
-```C++
+```CPP
 void test_multi_pack() {
     vector<int> weight = {1, 3, 4};
     vector<int> value = {15, 20, 30};
diff --git "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md" "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
index 474f485f78..dc4f06f953 100644
--- "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
+++ "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
@@ -51,7 +51,7 @@ for(int i = 0; i < weight.size(); i++) { // 遍历物品
 
 而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：
 
-```C++
+```CPP
 // 先遍历物品，再遍历背包
 for(int i = 0; i < weight.size(); i++) { // 遍历物品
     for(int j = weight[i]; j < bagWeight ; j++) { // 遍历背包容量
@@ -98,7 +98,7 @@ dp状态图如下：
 
 先遍历被背包在遍历物品，代码如下：
 
-```C++
+```CPP
 // 先遍历背包，再遍历物品
 for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
     for(int i = 0; i < weight.size(); i++) { // 遍历物品
@@ -112,7 +112,7 @@ for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
 
 完整的C++测试代码如下：
 
-```C++
+```CPP
 // 先遍历物品，在遍历背包
 void test_CompletePack() {
     vector<int> weight = {1, 3, 4};
@@ -132,7 +132,7 @@ int main() {
 
 ```
 
-```C++
+```CPP
 
 // 先遍历背包，再遍历物品
 void test_CompletePack() {
diff --git "a/problems/\351\235\242\350\257\225\351\242\23002.07.\351\223\276\350\241\250\347\233\270\344\272\244.md" "b/problems/\351\235\242\350\257\225\351\242\23002.07.\351\223\276\350\241\250\347\233\270\344\272\244.md"
index 22f064b43b..9acda71ce6 100644
--- "a/problems/\351\235\242\350\257\225\351\242\23002.07.\351\223\276\350\241\250\347\233\270\344\272\244.md"
+++ "b/problems/\351\235\242\350\257\225\351\242\23002.07.\351\223\276\350\241\250\347\233\270\344\272\244.md"
@@ -44,7 +44,7 @@
 
 C++代码如下：
 
-```C++
+```CPP
 class Solution {
 public:
     ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {