发现问题，并解决问题，批判性思维

学习总结文章目录学习总结一、时间安排task01 数组task02 链表task03 栈一、时间安排阿里云天池leetcode训练营（二月）。task01 数组2月14日-2月15日最接近的三数之和。task02 链表2月16日-2月17日61旋转链表、剑指 Offer 25. 合并两个排序的链表、剑指 Offer 25. 合并两个排序的链表。task03 栈2月18日-2月19日...

链表（4 天） 、堆栈与深度优先搜索（5 天）、单调栈（1 天）、队列与广度优先搜索（3 天）、优先队列（1 天）

1.申请数组如果数组大小较大（大概10^6）则需要定义在main函数外，否则会使程序异常退出（因为函数内部申请的局部变量来自系统栈，即允许申请的空间较小；而函数外部申请的全局变量来自【静态存储区】，即允许申请的空间较大）。2.scanf的%c和%sscanf的%c格式时可以读入空格和换行\n的；%d的输入则是以空白符（即空格、换行等）作为结束判断标志。字符数组使用%s格式读入时的结束标志：空格、换行符。#include <stdio.h>int main(){ int a;

这样，通过递归和回溯的方法，我们可以找到所有可能的分割方案。（这个路径即当前方案的所有字符组合列表），直到字符串。每次递归调用会传递新的字符串。具体例子和步骤：假设。

（0）读懂题意：题目的“连续”是指位置的连续，而不是说数字的连续，这是个大坑。（1）确定状态：定义两个状态来记录当前子数组的最大乘积、最小乘积。因为在处理负数时，最小乘积乘以负数可能变为最大乘积。`dp_max[i]`表示以`nums[i]`结尾的子数组的最大乘积、`dp_min[i]`表示以`nums[i]`结尾的子数组的最小乘积。（2）状态转移方程：对于每个元素`nums[i]`，我们的`dp_max[i]`和`dp_min[i]`可以从这三个数中确定：- 只包含当前元素 `nums[i]`。

# 二、思路- 先将所有子列表按照`start_pos`进行排序，有利于保持顺序性，每次处理新子列表时，只用和结果列表`ans_lst`的最后一个子列表对比，如果有重合则合并，然后将合并的新子列表插入结果列表- 排序可以使用`lambda`函数，`intervals.sort(key=lambda x: x[0])`- 时间复杂度O(n)，空间复杂度O(n)# 三、代码```pythonclass Solution(object): def merge(self, intervals):

首先将所有烂橘子入队，然后常规BFS遍历，注意while的截止条件除了队列为空，新鲜橘子数量大于0（没新鲜橘子也没必要继续遍历，保证时间计算的正确性），这两者一个不满足就可以停止每分钟进行一次【腐烂扩散】，使用BFS对二维图进行遍历，注意和二叉树的层次遍历不一样（二叉树则是只有一个根节点，这里可能有多个腐烂橘子-根节点）。auto [x, y] = q.front()是C++17引入的新语法，结构化绑定，可以从数组、元组或结构体中一次性解包多个值，并将他们绑定到多个变量上，比如这里就是声明了x和y变量，

二、思路最直观的是层次遍历，然后存入每层第一个元素到结果列表中如果用dfs，（根节点，右子树，左子树）的顺序进行访问节点；按照题目规则只会在每层中抽取最右侧的一个节点，如果当前的深度等于结果数组的size，则这是第一次访问该层，且当前节点满足条件。三、代码

一道使用拓扑排序的LeetCode经典题。题目：每个课程看作一个节点，先修关系为节点的有向边，目标是判断能否根据课程安排关系，成功学完所有课程。- 拓扑排序算法： - 统计每个节点入度 - 将所有入度为0的节点（注意是可以有多个入度节点，如下图）加入队列`que` - 对第二点中的队列`que`，遍历每个入度为0的节点，将其相邻节点的入度减1，如果相邻节点相邻节点 - 重复第三点直到最后`que`队列为空：如果所有节点此时入度为0，则说明课程的学习顺序合理，能够完整学完课程；如果还有节点

加上这种只需要求出【最值】的题目经常使用dp；因为每个房子能刷成三种颜色，即三种状态，加上不同的房子位置这个维度，可以令。有关，所以可以使用【滚动数组】优化计算复杂度，这个滚动数组即大小为颜色种类数。数组的三个数的最小值为按规矩粉刷房子的最小总成本。第0个房子左边木有房子，直接赋值当前房子的三种初值，已知不同房子刷成不同颜色的价格矩阵。个房子的粉刷情况都是符合题意时，这。个房子所需要的最少话费成本。（3）初始状态 + 边界情况。取值为0,1,2）表示：第。计算到最后一个房子时，即。

编辑距离可以通过以下三种操作进行计算：插入一个字符、删除一个字符、替换一个字符。初始条件：也只有两个字符串都相同或者都是空时编辑距离才为0，先全都将。根据状态转移方程，下标大的dp值都能从下标小的dp值计算得到，所以。边界：如果word1和word2其中一个没字母，即。个单词，变换到word2中前。个字符，最少需要的动作次数。，即一路加到底和一路减到底。（3）边界+初始条件。是边界情况，值分别为。

如果最多订单数只有一个客户，那就可以直接粗暴的分组后计算每组个数，然后排序求第一个。但如果是有并列客户同时最多订单数，则先找出最大订单数的数值，然后用`Having`子查询求众数。

基础题，二叉树版本的两数之和，dfs遍历这棵二叉搜索树，比如当前节点数值为val，那么就查哈希表key为k - val的键值对是否存在，如果存在则显然说明存在题目说的两个节点，如果不存在不能直接说明没这样的节点（因为可能这对节点才刚出现一个），而是存入该哈希表后继续遍历二叉树。实现中可以用集合set代替哈希表HashMap，速度会快一丢丢。

可以先将数组元素逐个转为字符串后，直接通过java中的`a.compareTo(b)`方法进行比较，它会从头到尾根据ASCII码比较字符的大小；- 在`Array.sort()`中如果使用自定义比较器`Comparator`，这里我们并不是`compareTo()`方法进行重写，而是说这里的排序按照`compareTo()`这个方法的规则，使得拼接后的数越大越好，比如`[3, 30, 34]`排序成为`[34, 3, 30]`数组。

最简单的方法是哈希表，分别统计2个数组的哈希表，key为对应的元素，value为元素的个数，然后比较两个哈希表的key是公共时，取对应的最小value。

因为是要演员和导演合作的 也就是actor_id和director_id必须都相同才满足条件 所以要加两个分组条件进行groupby。 因为如果分组条件不加director_id 那么COUNT(*)计数的是该演员和所有导演的合作次数 而不是和各个导演的合作次数 在测试的第四个例子就会出错。用GROUP BY分组后可以用HAVING取出想要的组。SQL在使用 HAVING 子句时 SELECT 语句的顺序为：FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER

一、题目二、思路dfs遍历二叉树，其实可以直接用前序遍历，注意为了找到最早出现的最深的左节点，所以需要先遍历左子树，再遍历右子树。为了满足“最深”的条件，需要比较当前depth和maxdepth值，进行更新maxdepth。其实题目要求找到最底层的最左边的节点，没指定一定是左孩子哈哈，如果没有左孩子，只有右孩子，那该右孩子也是最左边的节点。三、代码/** * Definition for a binary tree node. * struct TreeNode { * i

文章目录一、题目二、思路三、代码一、题目二、思路(a & b) << 1能够计算a和b的所有进位值；a ^ b则是计算a和b的各位相加（不管进位值）因为不能使用加法运算符，所以上面两项的结果也不能用加法，只能循环上面的步骤计算。三、代码class Solution {public: int add(int temp_sum, int jinwei) { //不能使用+号，所以求出异或部分和进位部分后依然不能使用+号 //所以只

文章目录一、题目二、思路方法一：迭代法方法二：递归一、题目二、思路求两个节点的最近公共祖先的题目我们做过，但是这题是二叉搜索树BST，并且本题中所有节点的数值都是不同的，所以可以根据BST的数值特点进行判断，即左子树的所有节点都比当前节点小，右子树的所有节点都比当前节点数值大。若 root 是 p,q 的 最近公共祖先 ，则只可能为以下情况之一：p 和 q 在 root 的子树中，且分列 root 的 异侧（即分别在左、右子树中）；p = root，且 q 在 root 的左或右子树中；

文章目录一、题目二、思路三、代码一、题目二、思路可以使用递归方法：递归终止条件：链表中没有节点，或者只剩下一个节点（不能进行交换了）。递归体：首先用head保存原始链表的头节点，newhead保存新链表的头节点（即head->next），则原始链表的其他节点开始是newhead->next。解决递归需要清楚递推公式含义：这里递推公式swapPairs()指将给定的链表中的相邻节点两两交换后返回，返回的是交换完成的链表的头节点。所以假设我们已经将head->next后的节点都

文章目录一、题目二、思路三、代码一、题目二、思路递归参数： 当前字符在矩阵 board 中的行索引 i 和列索引 j ，当前目标字符（匹配的）在目标字符串 word 中的索引 k 。终止条件：返回 false ： (1) 行索引或列索引越界 (2) 当前矩阵字符与目标字符不同；返回 true ： 当前目标字符（匹配的）在目标字符串 word 中的索引 k = len(word) - 1 ，即目标字符串 word 已全部匹配；递归过程：标记访问过字符： 将 board[i][j] 修改为 ‘/

文章目录一、题目二、思路三、代码一、题目二、思路基础题。拿到题目，“最大价值”、路线问题，可以发现和以前做的【LeetCode62】不同路径（dp）是一个思路的，都是规定从左上角，每次只能向右or向下移动一格，于是那题从当前状态考虑时，需要将上方格子的dp值和左方的dp值相加（因为那里是求路径方法数），但是本题是取max（因为这里是求一条路径，该路径使得礼物价值最大）。（1）确定状态状态f(i,j)f(i, j)f(i,j)表示到达当前(i,j)(i, j)(i,j)坐标位置时能够拿到的礼物最大

文章目录一、题目二、思路三、代码一、题目提示：树中节点总数在范围 [0, 5000] 内-1000 <= Node.val <= 1000-1000 <= targetSum <= 1000二、思路回溯思想，dfs首先将当前的元素加入，然后判断到目前为止的temp数组是否满足sum=target的一种情况，如果不满足则继续递归遍历左子树和右子树。注意！！！当左子树和右子树都为空时，即当前节点为叶子结点了，到底的判断完了！！就把temp数组刚才存的最后一个（叶子）节

一、题目二、思路因为找的是连续子序列（并且题目的原序列是从小到大元素排列）的和为target，所以使用滑动窗口，如果加上当前元素后sum满足条件则push_back，如果加上当前元素后sum过大了，则需要从该滑动窗口中，减去最前面的元素（最小元素），减着减着可能就找到新一种情况，如果减到sum还比target小了，那没必要继续减了，继续扩大滑动窗口的右侧边界。三、代码class Solution {public: vector<vector<int>> findC

文章目录一、题目二、思路三、代码一、题目限制：0 <= 节点个数 <= 10000二、思路题目判断的是B是否为A树的【子结构】，而不判断是【子树】。直观的思路：从A的每个节点开始逐个（递归）遍历，（假设当前的节点为K）；然后判断B树，是否为当前以K节点为头结点的子结构。上面第二步，对应下面代码的issame部分：如果B树为空（先遍历完了），则是子结构；如果B树不空，A树为空（A树先遍历完了），则不是子结构；AB树当前节点都不空了，但是val不相同，也不是子结构了；

一、题目二、思路从左到右，从上到下，两条路径都是数值从小到大排列，为了确定target是否存在，可以换个起点开始，如从右上角（其实从左下角开始也行），这时候就很神奇了：如果当前值比target大，就不能继续往下走（只会越来越大），而往左边走，值会变小，进一步靠近可能的target；如果当前值比target小，就不能往左边走了（只会越来越小），而往下面走，值会变大，进一步靠近可能的target。另外注意细节，一开始判断matrix二维数组是否为空，如果为空则matrix.size() == 0

文章目录一、题目二、思路三、代码一、题目二、思路单纯根据后序遍历序列，不阔能确定一棵二叉树，但是事先说明是二叉搜索树BST了，BST树的特点是中序遍历序列，是有序序列，而且根结点val大于左孩子val，小于右孩子val。而且题目给出后序遍历序列，最后一个节点是根结点，我们就能从头遍历数组，找到第一个比根结点大的节点位置（分界点），在此前面的部分，都是根结点的左子树部分；分界点后面部分理应是右子树部分，所以val也理应该大于根结点。所以基于这点，我们只要判断分界点后的结点值，是否有小于根结点的这种异

一、题目二、思路从左往右，从上往下遍历给定的二维数组board，然后遍历到当前元素board[i][j]时，需要判断是否满足题目的3个条件，这里可以分别用3个哈希表实现：在第 i 个行中是否出现过：使用row[9][10]，注意第二维度是装的数字，即哈希表的key为数字（1-9范围内），value为是否出现过，出现过则为1（此时就直接返回false了），没出现过即保持为0（事后要置为1）。在第 j 个列中是否出现过：使用col[9][10]在第 j/3 + (i/3)*3个box中是否出现

一、题目二、思路和代码哈希。mp[i]=j表示数字i在原数组的下标。一次遍历判断即可。PS：unordered_map的mp.find(value)返回的是value对应的key值。一开始这样提交，发现下面的方法有3个测试用例没过，比如[1, 0, 1, 1] k = 1这种情况，发现正确应该是返回true的，但是这样的方法会只判断了第0个1和第2个1这两个位置（没有判断最后两个1的情况），是因为没有更新哈希表中value对应的key的最新值导致的。class Solution {public

一、题目二、思路（1）确定状态dp[i]dp[i]dp[i]表示nums中以nums[i]结尾的最大子序和。（2）状态转移方程（描述子问题之间的联系）假设数组nums[i]值全部严格大于0，则一定有：dp[i]=max(dp[i−1]+nums[i],nums[i])dp[i] = max(dp[i-1]+nums[i],nums[i])dp[i]=max(dp[i−1]+nums[i],nums[i])但是dp[i-1]可能是负数的，分类讨论：如果dp[i-1]大于0，可以把nums[

一、题目二、思路看似一道很常规的排序题目，但是如果使用以前的快速排序模板（如下），会发现超时了！如下的Quicksort函数（递归）和划分枢轴的函数Partition。class Solution {public: void Quicksort(vector<int>& nums, int low, int high){ if(low < high){ //partition划分操作，将原表划分成2表

一、题目二、思路审题nums[i]都在int范围内（32位二进制），对于每个num[i]的二进制数，对于第j个位置的元素都相加，并且最后对结果的二进制数，其第j个位置的元素依次进行余3操作。关键：对于数组中的每一个元素 x，我们使用位运算 (x>>i)(x >> i)(x>>i) & 111 得到 x 的第 i 个二进制位。注意计算2的i次方可以使用1 << i。举栗子：如果输入是：nums = [2,2,3,2]，那么它的各个元素对

文章目录一、题目二、思路三、代码一、题目二、思路要是2的幂，可以回想二进制数中，什么样的二进制数对应的十进制是2的幂呢，就是在二进制数中，只有一个1，其余都是0。所以我们只需要判断给定的数的二进制数，如果只有一个1则返回true了。位运算的技巧：n & (n - 1)可以将n的二进制位的最低位1移除。如1000和0111做与运算后得到0000，即将1000的最低位的1移除了，然后再判断其余位是否都是0。所以我们可以n > 0 && (n & (n -

一、题目二、思路如果我们把数组分成两个子数组，每个数组都满足「恰好有一个元素只出现一次，其余所有元素均出现两次」，就可以按照之前的方法直接解决了。（1）直接遍历一遍数组并逐一【异或】一定可以得到那两个不同元素的异或。如数组[2,2,1,1,3,4]。这个数组的异或值最终是3 与 4 的异或值为 div = 0011 ^ 0100 = 0111。（2）取最低位置的 ‘1’来进行对 a 与 b 的分组div &= -div;-div = 1000 + 0001 = 1001 （将div所有

一、题目二、思路题目要求BST二叉搜索树的中序遍历迭代器，所以只需要对BST先进行中序遍历，得到这个中序遍历数组，然后对该数组进行next操作和havenext操作即可。在实现过程中，注意引用、构造函数的初始化列表等细节。三、代码/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; *

一、题目二、思路给定的升序数组，其实就是BST的中序遍历数组，只是给定一棵二叉树的中序遍历数组，并不能确定一棵二叉树，但是题目要求是严格平衡的二叉搜索树，所以可以选择升序序列的中间元素作为当前的根结点元素。三、代码/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode()

一、题目二、思路一般的进制转换题目，只需要对num进行%运算，取得最后一位，然后对num进行/运算（将已经取到的位数去掉），循环直到num为0。一般的进制转换题目都是x在[0, x)，即从0开始，满x进一。但是这题是从1开始，所以在进制转换操作前，需要对num进行减1操作，整体偏移，事实上如果漏了减1：class Solution {public: string convertToTitle(int columnNumber) { string ans;

一、题目二、思路审题看清楚，，题目问的不是回文子串，不是子串！！！暴力解法会超时，可以使用双指针：如果当前左右指针指向的元素不相等，可以试着判断删除掉左元素或者右元素后的字符串是否为回文字符串，注意此时i左边和j右边是已经判断完了（再重复一次！判断的不是回文子串）；如果当前左右指针指向的元素相等，则左指针向右一格，右指针向左一格。每次两指针表示的字符判断相等，则该部分就符合回文串，贪心思想。三、代码class Solution {public: bool validPalin

一、题目提示：1 <= s.length, t.length <= 200s 和 t 只含有小写字母以及字符 ‘#’进阶：可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？二、法一：双栈法如果不考虑用O(1)O(1)O(1)的空间复杂度，很容易想到这种添加，删除的步骤，可以用到栈的入栈和出栈，所以可以用2个栈模拟2条字符串的退格运算：class Solution {public: bool backspaceCompare(string s, s

一、题目二、思路（1）使用哨兵节点，省去首个元素的逻辑判断，最后返回dummy->next。（2）比较cur.next与cur.next.next对应的元素是否相同。（3）因为给定的链表已经是排好序了，我们只需要一次遍历即可（不需要遍历2次，用哈希）。三、代码/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNod