更新代码块

problems/周总结/20200927二叉树周末总结.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) {

problems/周总结/20201003二叉树周末总结.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);
 ```

problems/周总结/20201224贪心周末总结.md

@@ -31,7 +31,7 @@
 把[贪心算法：用最少数量的箭引爆气球](https://mp.weixin.qq.com/s/HxVAJ6INMfNKiGwI88-RFw)代码稍做修改，别可以AC本题。
 
 修改后的C++代码如下：
-```C++
+```CPP
 class Solution {
 public:
     // 按照区间左边界从大到小排序

problems/周总结/20210107动规周末总结.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) {

problems/周总结/20210121动规周末总结.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]);

problems/周总结/20210128动规周末总结.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++) { // 遍历背包容量

problems/周总结/20210204动规周末总结.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:

problems/周总结/20210225动规周末总结.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:

problems/周总结/20210304动规周末总结.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];
 }

problems/周总结/二叉树阶段总结系列一.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) {