m0_52510770的博客

int(a[:2]) - 1])表示先取a字符串的前两个字符获取月份，由于前面可能会有0，所以int()转换为整数，又由于数组开始下表为0，即days[1]表示的是2月，所以要减一。sum(days[:int(a[:2]) - 1]) + int(a[3:])表示先将days前几个月相加再加上最后一个月呆着的日期即为该日期是该年的第几天。int(a[3:])表示取a字符串第三个之后的字符串，即该月的日期。首先days数组为：提前打好的关于每个月有多少日期的表。

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少？

当重复出现第二次时，会在后面+(1)，但是如果刚好我后面一个是前面加了后缀(1)后一样的，那就是在前面的基础上在加(1)，可能说的不是很清楚，自己看例子很好理解，所以在解决时需要将加入后缀后的情况也加入哈希表中，避免上述例子的特殊情况的出现。哈希表中存在"gta":1、"gta(1)":1。两种情况结果类似，但添加过程不一样。很明显的哈希表，关键在于哈希表该如何去设计，题目要求出现过的文件名需要进行处理，在其文件名后加上后缀以满足条件，所以需要记录这个文件名是否出现过，出现过几次，或者说新的后缀应该加几？

有两个长度相同的字符串 s1 和 s2，且它们其中 只含有 字符 "x" 和 "y"，你需要通过「交换字符」的方式使这两个字符串相同。每次「交换字符」的时候，你都可以在两个字符串中各选一个字符进行交换。交换只能发生在两个不同的字符串之间，绝对不能发生在同一个字符串内部。也就是说，我们可以交换 s1[i] 和 s2[j]，但不能交换 s1[i] 和 s1[j]。最后，请你返回使 s1 和 s2 相同的最小交换次数，如果没有方法能够使得这两个字符串相同，则返回 -1。

给你一个字符串数组 words 和一个字符串 pref。返回 words 中以 pref 作为 前缀 的字符串的数目。字符串 s 的 前缀 就是 s 的任一前导连续字符串。很简单的模拟，遍历words数组，对于数组的每一个字符串，对其和pref进行比对，并判断其是不是前缀，并计数器计数。

给你一个整数数组 nums 和一个整数 x。每一次操作时，你应当移除数组 nums 最左边或最右边的元素，然后从 x 中减去该元素的值。请注意，需要 修改 数组以供接下来的操作使用。如果可以将 x 恰好 减到 0 ，返回 最小操作数；否则，返回 -1。

给你一个正整数 num ，请你统计并返回 小于或等于 num 且各位数字之和为 偶数 的正整数的数目。正整数的 各位数字之和 是其所有位上的对应数字相加的结果。提示：1

【代码】LeetCode:2032. 至少在两个数组中出现的值。

选择前缀 "aa" 和后缀 "a" 并删除它们，得到 s = "bccabb"。- 选择前缀 "c" 和后缀 "c" 并删除它们，得到 s = "abaaba"。- 选择前缀 "a" 和后缀 "a" 并删除它们，得到 s = "baab"。- 选择前缀 "b" 和后缀 "bb" 并删除它们，得到 s = "cca"。- 选择前缀 "b" 和后缀 "b" 并删除它们，得到 s = "aa"。- 选择前缀 "a" 和后缀 "a" 并删除它们，得到 s = ""。输入：s = "ca"

【代码】LeetCode:2011.执行操作后的变量值。

模拟(双重循环)：简单的遍历数组，第一重循环用于确定目的地，第二重循环用于判断长度，移动距离就是每个元素到目的地之间距离之和。很好算看题解知可以用前一个盒子的操作数得到下一个盒子的操作数，先统计该盒子左边(包括自己)的1的个数和右边1的个数，每次向右移的时候左边的加一右边的减一即可，当然首先得把第一个的值给统计出来，同时在移动的过程中需要维护左边和右边的个数，即当移到一个有球的盒子时，计算完后，将左边加一，右边减一即可.

解题思路：最直接的想法：每次移除石子的时候都判断一下三堆石子那两堆较大，从较大的两堆中各移除一个，如果有两个石子堆的数量==0，则循环退出，输出循环次数即可贪心+数学推导：假设a

关于力扣1652题自己编写的思路和过程

解题思路：哈希表，将所有字符放入哈希表haxi中，<string, int>从左往右一个一个字符计算，对于每一个字符，判断其和后一个字符所对应的数字数值大小，大于则加，小于则减。C++:class Solution {public: int romanToInt(string s) { unordered_map<char, int> haxi = { {'I', 1}, {'V', 5},

解题思路：使用辅助栈，一个正常栈的操作，另一个栈用于存最小值。对于辅助栈：push：因为要始终保证辅助栈的栈顶元素为最小值，所以入栈的时候比较入栈元素和栈顶元素（原本栈里的最小值），然后将较小的值入栈，来确保栈顶元素始终为栈的正常栈里的最小值 pop：与正常栈同步，双方同时pop即可，去掉了双方都去掉了栈顶元素，即相当于返回上一步，两个栈保持同步，既可以保证辅助栈的栈顶依旧可以保证功能C++:class MinStack { stack<int> x_stack;

解题思路：哈希表，遍历每一个数字，将每一个数字的每一位放入哈希表中<int(出现的数字)，int(出现的次数)>，遍历哈希表，如果有出现两次的数字，跳过，若没有，计数器加一。优化：更新哈希表的同时就判断若大于等于2，就可以直接跳出循环，不必继续运行，降低时间复杂度。想法很古板，依旧是模拟，说实话时间复杂度很高，不是一个好解法 官方题解： 当n = 0的时候，只有一个数字0，返回1 当n = 1的时候，有10个数字0~9，返回10 当n > 1时候，比如说，n = 2，则第一位数

解题思路：模拟：从left到right遍历每一个数字，每次用while循环取每一位的数字，分别区域，若其中有一个取余不为0，则return false。代码：class Solution {public: vector<int> selfDividingNumbers(int left, int right) { vector<int> ans; for (int i = left; i <= right; ++i) {

解题思路：笑拉了，看了半天题目都没有看懂，没明白这个pos是什么意思，怎么确定环，直至看来题解，原来与pos没有关系， 对于官方给的题解，个人会比较喜欢哈希表来解决，感觉快慢指针跟哈希比属于是节省空间，而哈希的话则节省时间 哈希表很简单，就将每一个遍历过的结点存入哈希表中，每次next的时候count一下哈希表，如果说发现存在，则表示又环形链表 快慢链表的话就是指一个走两步，一个走一步，如果存在环形链表的话，则都会进入链表中，若快指针等于的慢指针的话接可以确定存在环形链表。代码：/**

解题思路：模拟，分别便利两个数组，将数字提取出来，再相加，最后得出的数字再转化为链表 创建链表，算一个建一个结点，指针向后遍历一位，模拟十进制算法即可代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) :

解题思路：模拟，分别便利两个数组，将数字提取出来，再相加，最后得出的数字再转化为链表 创建链表，算一个建一个结点，指针向后遍历一位，模拟十进制算法即可代码：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) :

解题思路：在前序遍历的基础上增加了一些步骤，分3个情况无左右子树 无左子树，又右子树 有左子树无右子树 同时具有左右子树对于每个情况，只需根据题意再各个地方加上括号即可，这里2、4为一种情况，同样处理即可，3得情况可以无需考虑右子树的情况。代码：C++:/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * Tree..

解题思路:有利润的情况肯定是从小的开始，向上增加，记录即可，同时特别i情况，后面出现了更小的值，此时有两种情况， 1、后面的增率很小，小于前面出现的maxprice，那么maxprice依旧是前面的那个高一点的天投入获得的最大利润 2、后面增率很大，差值超过了前面的，那就更不用看了，就是没分情况之前的代码：C++:class Solution {public: int maxProfit(vector<int>& prices) { in

解题思路：双重循环，每个可能都遍历一次，将索引和最小的放入ans数组中 哈希表，{string: int}，前面放字符串，后面放字符串对应的索引下标代码：错误：class Solution {public: vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) { unordered_map<string, i

解题思路：后序遍历代码：/*// Definition for a Node.class Node {public: int val; vector<Node*> children; Node() {} Node(int _val) { val = _val; } Node(int _val, vector<Node*> _children) { val = _val;

解题思路：每次判断其是否大于10，大于10通过循环将每一位数加起来，直至该数字小于10，退出循环，输出。 对于题目中的进阶问题，是否可以不用循环或递归来解决问题，即时间复杂度为：，只有可能看成是数学问题，想不出来。。。。代码：第一遍：981/1101，没通过案例：10class Solution {public: int addDigits(int num) { int ans; while (num > 10) {

解题思路：进制转换，先判断正负，之后对数字进行除7取余，若为负，则在最后加个负号，最后字符串反转。代码：C++:class Solution {public: string convertToBase7(int num) { if (num==0) return "0"; string ans; int temp = abs(num); while (temp > 0) { ans=to_

解题思路：模拟：双重循环，从下标为time的开始遍历，到下标length-time-1结束，对每一次循环都对应两个循环，一个往前走，一个往后走，满足条件，则将下标加入到ans数组中。 对于上述方法，缺点为有重复判断，类似于BF和KMP的区别。解决办法，用动态规划，算出ni数组(以i结尾的最长下降子数组)和zh数组（以i结尾的最长上升子数组），该数组用于存储以下标结尾的最长子字符串长度，遍历时只需同时满足n[i]>time和zh[i]>time两个条件即可。（ps：吼吼吼吼吼吼吼吼吼吼吼吼吼

解题思路：动态规划，一维数组一行一行向下算。错误：class Solution {public: vector<int> getRow(int rowIndex) { if (rowIndex==0) return {1}; else if (rowIndex==1) return {1, 1}; vector<int> ans(rowIndex+1); ans[0] = 1, ans[1] =

解题想法：前后指针，前指针往后，后指针往前，都是字母时反转，不是字母是往里走，俩指针重合，遍历结束。没想法了 哈希表，int: string(字母)，。。。。好像也需要用双指针。。。不好。代码：出错：超时 class Solution {public: string reverseOnlyLetters(string s) { int n = s.size(); int l = 0, r = n-1; while (true) {

解题思路：递归，当==nullptr的时候返回0，maxdepth（根节点）= 左右两个子树的深度的较大值+1代码：class Solution {public: int maxDepth(TreeNode* root) { if (root == nullptr) return 0; return max(maxDepth(root->left), maxDepth(root->right))+1; }};...

解题思路：类似于对称的树，俩个指针，分别从根结点出发，用递归遍历，一直相同则可确认为相同的树。 判断条件：都为空，返回true；一空一有，返回false；值相同，返回true出错：在下面代码中的第三个判断else if (p->val != q->val) return false;写成了else if (p->val == q->val) return true;导致出现了一个很严重的问题，即当这俩个根节点拥有一制的子树（这里是指都有左子树或都有右子树或左右子树都有）.

解题思路：递归 奇数则numberOfSteps(num)=1+numberOfSteps(num-1) 偶数则numberOfSteps(num)=1+numberOfSteps(num//2)代码：python： class Solution: def numberOfSteps(self, num: int) -> int: if num <= 3: return num elif num % 2 == 1:

解题思路：对俩个字符串用哈希表进行统计，最后遍历，输出只出现一次的单词。 就是很简单的单词词频统计代码（python）：class Solution: def uncommonFromSentences(self, s1: str, s2: str) -> List[str]: d = {} l = [] s = s1.split() + s2.split() for i in s :

中序遍历就是访问左子树，根结点，右子树的顺序来遍历代码：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), lef

解题思路：感觉这是一个栈，广搜，除去第一位，最后为0则对称很好，很幼稚的想法。。。。很明显是错的递归，怎么判断两边的子树对称呢？，两个指针，从根结点开始，一个左移另一个右移，一直相反向下走，分别遍历俩个子树，如完全一样，则可以判断这是一个对称二叉树。代码：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode

解题思路：数学方法，等比数列求和，公比为2，不知道怎么求要几个回合，所以打算打个表，奇数加1。。。。。试着试着推公式呢，结果突然发现就是n-1.。。。编译了一下是对的。。。。就一整个挺无语的。。。。代码：class Solution: def numberOfMatches(self, n: int) -> int: return n-1...

解题思路：很简单的遍历，若前后不相等，删除这个节点即可。解题时存在问题：循环时一直在判断p->next->next存不存在，就潜意识里认为不存在怎么等？看了题解后才想起来，不存在就直接等于nullptr，而下次循环刚好p->next不存在推出循环。 while里的if有问题，前后相等时删了后面一个结点，但不相等时既满足题目要求时没有变化，导致结点指针p会一直停留在原地不动，无限循环，超时，讲真的，看了半天，是被自己蠢哭的一个早上[doge].这里是被自己蠢哭的代码：c

解题思路;减而治之或者分而治之都好像不行。。突然想到最长上升子序列，可以定义一个长度为n的数组，每一个用于记录以该下标为起点的序列，遍历到最后，记录下最大的序列和，最后遍历数组，找到最大的进行输出。时间复杂度大概是，目前就这一种想法。。。。。人傻了哟，超时了，看了一下测试超时的测试用例，密密麻麻的一片数字，无语住了。。。但是试了一下，思路细节都是OK的，还是挺高兴的。咋这应该不算枚举吧，嘶，虽然好像确实是把所有情况都测过了，不管先把代码放这，咋去看题解！class Solution

解题思路：思路一：双指针，一前一后 前指针往后遍历，找到val则停止 后指针若该数不为val，则交换，若为val，向前遍历 前后指针相等的时候，退出循环。思路二：先排序，后遍历寻找（可以用二分查找找到），找到后删了，将后免得元素往前挪。问题：思路一在写的过程中有问题，即只有一个数字的时候，while循环会直接跳出，begin=0，又或者[3,3] 3， [2],3 [1],1 的时候也会出问题。正常情况下是可以的，很烦。看题解吧，之后在改错误代码：class S...

解题思路：正常就是顺序遍历，找到索引位置输出即可 本题要求时间复杂度为,所以需要用(⊙﹏⊙)二分查找即可细节考虑：写的时候考虑到有可能返回值为length（即数组长度），所以可以添加特殊判断，及判断tatget是不是大于数组最大的值，是的话返回length，接下来就是正常的二分查找。后来看了一些题解，发现他们直接将right改为了length，当时就考虑到这不会溢出越界吗？但奇怪的是编译通过了，后来想了想应该是因为C++里vector的原因，python用的是list，估计也可以吧，但放到C