代码随想录一刷总结（leetcode解题整理）

代码随想录算法训练营一刷总结

不知不觉两个月过去了，陆陆续续还是把代码随想录一刷结束，很早之前就知道代码随想录的存在，但是一直没有能一股气把所有题目过一遍，刚开学的时候正好看到算法训练营的报名，想着趁此机会让自己的算法刷题踏上正轨，作为结尾，把这段时间的题目好好整理一遍思路，作为后面刷题的基石

我的整理方式是模拟实战做题时的感受，主要想法是提取问题本质尽可能化为具象的数学模型
往后会持续更新，主要是记录实战过程中遇到的题目将其归类到后面的思想方法中去。

二分查找

解决问题：
给定一个 $n$ 个元素有序的（升序）整型数组 $nums$ 和一个目标值 $target$ ，写一个函数搜索 $nums$ 中的 $target$，如果目标值存在返回下标，否则返回 -1
二分查找的意义在于通过二分将遍历的复杂度$O(n)$降低为$O({\log }_{2}n)$，故二分的优化意义大于对问题的解决意义
借助题目展现代码细节
704. 二分查找
在实现代码的过程中用到了循环不变量的概念，在这里体现为区间，我们整个过程中查找的区间的定义是什么？如果我们的定义是$[left,right]$,那么此时的代码实现为：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        while (left <= right) {
            int middle = (left + right) / 2; //关于middle的两种写法在之前的文章有讨论
            if (nums[middle] == target) return middle;
            else if (nums[middle] > target) {
                right = middle - 1;
            }
            else {
                left = middle + 1;
            }
        }
        return -1;
    }
};

关于$middle$的两种写法
再借助一道其他题目体会
34. 在排序数组中查找元素的第一个和最后一个位置
题目描述：
给你一个按照非递减顺序排列的整数数组 $nums$，和一个目标值 $target$。请你找出给定目标值在数组中的开始位置和结束位置,如果数组中不存在目标值 $target$，返回 $[-1,-1]$。你必须设计并实现时间复杂度为 $O(lo{g}_{k}n)$的算法解决此问题。
我们的关注点需要集中于如何将本题转化为原有题目的模型
原问题$⟺$查找目标值的区间$⟺$查找第一个小于目标值与第一个大于目标值的位置
如是我们明白二分查找真正常用的是查找特定区间而非特定值
我们尝试去推导这个问题：
记住一句话，二分查找本质是分而治之，我们不仅要关心查找的位置，更要关心这个位置两边元素的特征，以左闭右闭为例，$right$代表的是在其右边(包括自己)的元素都大于等于$target$（此处理论上是大于，但是在区间问题中应有所变化）,$left$代表的是在其左边的元素（包括自己）都小于$target$，而这个特点在整个循环过程中没有发生改变，我们能否利用这一点推导出我们想要的区间位置?
很显然最后的结果一定是$left$的位置即是第一个$target$的位置
同理当我们改变$left$和$right$的含义之后，我们可以得到类似的结果
那么我们得到代码实现结果：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        vector<int> result(2, -1);
        bool tmp = false;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (nums[middle] == target) {
                tmp = true;
                break;
            }
            else if (nums[middle] > target) {
                right = middle - 1;
            }
            else {
                left = middle + 1;
            }
        }
        if (!tmp) return result;
        left = 0;
        right = nums.size() - 1;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (nums[middle] >= target) {
                right = middle - 1;
            }
            else {
                left = middle + 1;
            }
        }
        result[0] = left;
        left = 0;
        right = nums.size() - 1;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (nums[middle] > target) {
                right = middle - 1;
            }
            else {
                left = middle + 1;
            }
        }
        result[1] = right;
        return result;
    }
};

双指针

双指针法（快慢指针法）在数组和链表的操作中非常常见
双指针法本质是改变了遍历方式，使得遍历过程无回溯，故而降低了时间复杂度，我们不妨将数组的一般遍历看作$right$指针不动的特殊双指针
1.同向双指针
2.异向双指针
例题：345. 反转字符串中的元音字母

给你一个字符串 $s$ ，仅反转字符串中的所有元音字母，并返回结果字符串。元音字母包括 ${}^{\prime }{a}^{\prime }{,}^{\prime }{e}^{\prime }{,}^{\prime }{i}^{\prime }{,}^{\prime }{o}^{\prime }{,}^{\prime }{u}^{\prime }$，且可能以大小写两种形式出现不止一次。

反转元音字母$⟺$反转序列中的特殊字符$⟺$反转序列
在此题中，我们需要改变的无非是增加一些$left$与$right$指针的移动条件
简而言之，双指针的问题的关键就在于指针移动的条件

class Solution {
public:
    string reverseVowels(string s) {
        int left = 0, right = s.size() - 1;
        unordered_set<char> hashset = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'};
        while (left <= right) {
            if (hashset.count(s[left]) <= 0) {
                left++;
            }
            else if (hashset.count(s[right]) <= 0) {
                right--;
            }
            else {
                char temp = s[left];
                s[left] = s[right];
                s[right] = temp;
                left++;
                right--;
            }
        }
        return s;
    }
};

动态规划

动态规划通过分割子问题，记忆子问题结果，减少重复运算
动态规划五部曲：
1.确定dp数组及其下标含义
2.确定递推公式
3.初始化dp数组
4.确定遍历顺序
5.举例推导dp数组
我们在实际处理问题中主要就是就是对这五部曲的映照
例题：32. 最长有效括号
给你一个只包含${}^{\prime }{(}^{\prime }$和${}^{\prime }{)}^{\prime }$的字符串，找出最长有效（格式正确且连续）括号子串的长度。
有效括号子串最长长度$\to$什么是有效括号？我们应该怎么运用有效括号这个条件？
很自然想到栈，但是栈适合的是判断有效括号，不宜处理，我们考虑代入动态规划的世界尝试解决。
当问题的规模从$n$变为$n+1$时，我们能否借助$n$解决$n+1$?
联想到一些子序列的题目了，当问题规模变大时，新增的字符如何影响有效子串最大长度?
不可避免要考虑最长有效子串的位置，并由此进行分类讨论。遇到思路的问题，如果将dp数组定义为最长长度，无法体现子串位置，难以写出递推公式，考虑其他方向。
如果我定义$dp[i][j]$为$i$到$j$的子串有效性，这样的话如果能找到递推公式，问题就得到了解决。
$dp[i][j]$应当如何确定？
考虑递推公式其实就是一个等价推导的过程，能否把有效的情况全部列举是关键
1.$s[i]={=}^{\prime }{(}^{\prime }\&\&s[j]={=}^{\prime }{)}^{\prime }$
2.$dp[i+1][j-1]==true$或者$s[i+1]={=}^{\prime }{)}^{\prime }\&\&dp[i+2][j]==true$或者$s[j-1]={=}^{\prime }{(}^{\prime }\&\&dp[i][j-2]==true$
我们来试着用动规五部曲分析一遍：
1.$dp[i][j]$代表$i$到$j$的子串有效性
2.如上
3.先初始化全为$false$，再遍历一遍，将$j-i==1$的情况全部初始化,在这里我们自然想到一个问题便是对于单个括号是否有效？题目并没有给出明确定义。
4.遍历顺序，通过递归公式来确定，如上，在确定$dp[i][j]$时要用到$dp[i+1][j-1]$,那么显然应该对$i$倒序遍历，对$j$正序遍历
5.举例推导$dp$数组，直接尝试解题作为验证
第一遍解题失败

class Solution {
public:
    int longestValidParentheses(string s) {
        if (s.empty()) return 0;
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int result = 0;
        for (int i = 0; i < s.size() - 1; ++i) {
            if (s[i] == '(' && s[i + 1] == ')') dp[i][i + 1] = true;
            if (dp[i][i + 1] == true) result = 2;
        }
        for (int i = s.size() - 1; i >= 0; --i) {
            for (int j = i + 3;j < s.size(); ++j) {
                if (s[i] == '(' && s[j] == ')') {
                    if (dp[i + 1][j - 1] == true) {
                        dp[i][j] = true;
                    }
                    else if (s[i + 1] == ')' && dp[i + 2][j] == true) {
                        dp[i][j] = true;
                    }
                    else if (s[j - 1] == '(' && dp[i][j - 2] == true) {
                        dp[i][j] = true;
                    }
                }
                if (dp[i][j] == true && result <= (j - i + 1)) {
                    result = j - i + 1;
                }
            }
        }
        return result;
    }
};

反思问题并进行修改
思路是错误的，没有把握动态规划的特质，最大长度这一点自己没有很好的理解。
我们原来在确定$dp$数组时遇到的最大问题是无法确定最长有效子串的位置，那么其实我们要做的就是在$dp$数组的定义中处理这个问题，基于此，重新进行动规五部曲的分析
1.$dp[i]$代表以$i$为结尾的最长有效子串的长度
2.递归公式，
如果$s[i]={=}^{\prime }{(}^{\prime }$，显然$dp[i]=0$，反之如果$s[i]={=}^{\prime }{)}^{\prime }$
如果$s[i-1]={=}^{\prime }{(}^{\prime }$,$dp[i]=dp[i-2]+2$
否则当$s[i-1]={=}^{\prime }{)}^{\prime }$,如果$dp[i-dp[i-1]-1]={=}^{\prime }{)}^{\prime }$,此时$dp[i]=0$,否则$dp[i]=dp[i-1]+2$
3.初始化，$dp[0]=0$,全部初始化为$0$
4.遍历顺序显然是对$i$顺序遍历
5.举例推导$dp$数组
尝试解题

class Solution {
public:
    int longestValidParentheses(string s) {
        vector<int> dp(s.size(), 0);
        int result = 0;
        if (s[0] == '(' && s[1] == ')') {
            dp[1] = 2;
            result = 2;
        }
        for (int i = 2; i < s.size(); ++i) {
            if (s[i] == ')') {
                if (s[i - 1] == '(') {
                    dp[i] = dp[i - 2] + 2;
                }
                else if ((i - dp[i - 1] - 1) >= 0 && s[i - dp[i - 1] - 1] == '(') {
                    dp[i] = dp[i - 1] + 2;
                }
            }
            if (dp[i] >= result) result = dp[i];
        }
        return result;
    }
};

发现解答依旧是错误的，继续反思问题出在哪里，发现自己的递归公式仍然存在问题
在$s[i-1]={=}^{\prime }{)}^{\prime }\&\&s[i-dp[i-1]-1]={=}^{\prime }{(}^{\prime }$时，
$dp[i]=dp[i-1]+2+dp[i-dp[i-1]-2]$
经过修改后发现通过题例

class Solution {
public:
    int longestValidParentheses(string s) {
        vector<int> dp(s.size(), 0);
        int result = 0;
        if (s[0] == '(' && s[1] == ')') {
            dp[1] = 2;
            result = 2;
        }
        for (int i = 2; i < s.size(); ++i) {
            if (s[i] == ')') {
                if (s[i - 1] == '(') {
                    dp[i] = dp[i - 2] + 2;
                }
                else if ((i - dp[i - 1] - 1) >= 0 && s[i - dp[i - 1] - 1] == '(') {
                    if ((i - dp[i - 1] - 1) > 0) {
                        dp[i] = dp[i - 1] + dp[i - dp[i - 1] - 2] + 2;
                    }
                    else {
                        dp[i] = dp[i - 1] + 2;
                    }
                }
            }
            if (dp[i] >= result) result = dp[i];
        }
        return result;
    }
};

通过此题我们体会到动态规划问题的一些处理关键：
1.$dp$数组的定义？
2.递归公式的推导？

接着再来尝试一道动态规划的题目：
42. 接雨水
给定$n$个非负整数表示每个宽度为$1$的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
对题目进行分析，接雨水量可以将其分解为三个格子的情况分析
取相邻三个格子$i,i+1,i+2$,只有当$i+1<min(i,i+2)$时格子才能积蓄雨水
如此分析，我们将$dp$数组定义为$dp[i]$是最后一个格子为$i$的区域能接雨水的最大量
那么进行动规五部曲的分析
1.$dp[i]$代表$0-i$格子的接雨水量
2.递归公式

if (height[i - 1] < min(height[i - 2], height[i])) {
	dp[i] = dp[i - 1] + min(height[i - 2], height[i]) - height[i - 1];
}
else {
	dp[i] = dp[i - 1];
}

3.初始化，我们将$dp[i]$初始化为$0$
4.遍历顺序，根据递归公式，显然是$i$递增遍历
5.举例推导$dp$数组
那我们尝试解题：
在推导过程发现自己的错误，自己的递推公式并没有把所有的雨水接住，当$dp[i-2]>dp[i-1]>dp[i]<dp[i+1]<dp[i+2]$时，自己的递推公式显然是错误的
由是我们继续反思此题的真正含义：
可以发现，接住雨水的地方全都是极小值点，即$dp[i-1]>dp[i]<dp[i+1]$
我们能不能这样去理解，题目的目的是将给定的$height$数组通过填充的方式将其变为对于原数组的最大值，左边单调增，右边单调减。
这是否是这道题的数学本质呢？
这么看的话似乎题目的处理变得非常简单了，似乎并不需要$dp$数组的使用
尝试解题：

class Solution {
public:
    int trap(vector<int>& height) {
        int result = 0;
        int maxPla = 0;
        for (int i = 0; i < height.size(); ++i) {
            if (height[i] > height[maxPla]) {
                maxPla = i;
            }
        }
        for (int i = 1; i <= maxPla; ++i) {
            if (height[i] < height[i - 1]) {
                result += height[i - 1] - height[i];
                height[i] = height[i - 1];
            }
        }
        for (int i = height.size() - 2; i >= maxPla; --i) {
            if (height[i] < height[i + 1]) {
                result += height[i + 1] - height[i];
                height[i] = height[i + 1];
            }
        }
        return result;
    }
};

发现自己的想法是正确的，对于题目，将其读懂转化是最重要的，方法是便于我们处理一些特殊问题，没有必要特别去套用某些方法

回溯法