Removes a value from the set. Returns true if the set contained the specified element.

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环直到x为0 2.2 暂存x剩下的值 2.3 每次循环结果为上次循环的10倍，将2.2暂存值加到返回的结果上 3.提交记录 3.1 力扣中耗

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义两个数组分别记录当前元素的上一位置 2.2 倒序遍历字符串，如果当前元素的上一位置对应，更新当前元素的位置，如果不对应，直接返回false 3.提交记录

1.关于复杂度 1.1 时间复杂度为 O(log n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 这个解法基于二分查找 2.2 遍历数组，有两种情况 2.2.1 当前字母小于等于 target，移动左边界 2.2.2 当前字母大于 targ

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 定义一个结果变量，并设值为数组的首字母 2.2 遍历数组，有两个情况 2.2.1 当前字母小于等于 target，跳过 2.2.2 当前字母大于 ta

1.关于复杂度 1.1 时间复杂度为O(n m)(n为硬币数组的长度，m为总金额+1) 1.2 空间负责度为O(m) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 定义一个数组存储计算的结果 2.3 二重循环 2.3.1 外层循环遍历

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 根据.切割字符串 2.2 将所有字串转换成数字对比 3.提交记录 3.1 力扣中耗时3ms,消耗34.1MB内存 3.2 leetcode中耗时1ms,消耗34.2MB内

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于快慢指针 2.2 定义四个指针分别形成两个版本的左右边界 2.3 移动快指针知道快指针上的字符为. 2.4 根据当前的快慢指针切割子串，转换成integer然后对

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义一个数组统计被信任的次数 2.2 定义一个数组标记是否信任其他人 2.3 循环遍历 trust 数组，根据 索引 1 自增 2.1 数组，根据索引 0 标记 2.2 数组

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 因为每个元素在一定范围内，所以可以采用计数排序解题 2.2 循环遍历数组，统计每个元素出现的次数 3.提交记录 3.1 力扣中耗时 1ms,消耗 39.7MB 内存 3.

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为我们需要找到最小值，所以可以使用二分查找 2.2 返回左指针对应的值 3.提交记录 3.1 力扣中耗时1ms,消耗34.4MB内存 3.2

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(n) 2.how I solve 2.1 define a StringBuilder to cache final result

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2. 我的解题思路 2.1 根据空格分割源字符串 2.2 倒序遍历切割数组 2.2.1 如果当前元素不是"",append 2.2.2 当前元素不是最后一个，a

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 过滤出 licensePlate 包含的字母以及统计字母出现的次数 2.2 循环遍历 words 数组，统计字母出现的次数，对比 2.1 的统计数组，如果当前统计数组中元素都小于

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 将k转换成数组 2.2 定义结果数组，长度为两个数组长度较大值加1 2.3 循环两个原始数组相加他们的值 2.4 翻转结果数组转换成 list 返回 3.提交记录 3

1. 关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2. 我的解题思路 2.1 定义三个临时变量分别存储最大值，最小值，以及累加结果 2.2 循环遍历数组，对比交换最大与最小值，累加结果 2.3 用累加的结果减去最大与最小值，除以数组长度 - 2并返

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 根据规则，当 R 的数量与 L 的数量相等，平衡字符串的数量一定等于 R 或 L 的数量 2.2 循环遍历字符串，当前元素为 R，temp 自减，否则 temp 自增，当 tem

1. 关于复杂度 1.1 时间复杂度为 O(mlog(n)) 1.2 空间负责度为 O(1) 2. 我的解题思路 2.1 逐行遍历矩阵 2.2 如果当前行第一个元素为负数，直接将该行的长度添加到结果中 2.3 二分查找每一行，会有三个情况 2.3.1 中间元素为正数，

1.关于复杂度 1.1 时间复杂度为 O(1) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 当 N 为偶数，总是有一个数能与 N 整除，所以我们只需要判断 N 是否为偶数即可 3.提交记录 3.1 力扣中耗时 0ms,消耗 36.2MB 内存 3.2 leetcod

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 根据题意，两个字符串相差一个字符 2.2 循环分别得到两个字符串的相加的值 2.3 返回他们的差值 3.提交记录 3.1 力扣中耗时2ms,消耗34.

Inserts a value to the set. Returns true if the set did not already contain the specified element.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历数组，有如下返回false的情况 2.1.1 num为10，但是没有5块可以找还 2.1.2 num为20，但是没有5块或10块可以找

1.关于复杂度 1.1 时间复杂度为O(n^2) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于滑动窗口 2.2 定义一个左边界 2.3 循环遍历字符串 2.3.1 循环遍历左边界到当前元素，如果发现相同元素，对比resu

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义两个数组，hold用于记录当前持有的花费，profit用于记录当前卖出的利润 2.2 循环遍历数组 2.2.1 对比上一持有花费hold[i-1]

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义一个长度为原数组长度+1的数组 2.2 循环遍历原数组，用原数组的值作为定义数组的索引并赋值为1 2.3 循环遍历定义数组，如果元素为0，则该索引就是缺失

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 因为开始时给定的 numBottles 都盛满了水，所以用 numBottles 初始化结果变量 2.2 循环计算直到 numBottles 小于 numExchange

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于快慢指针 2.2 定义两个指针遍历链表，有两种情况 2.2.1 fast.val=val,移动fast到下一节点，slow的next域指向

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 二分遍历数组查找插入的位置 2.3 返回左指针 3.提交记录 3.1 力扣中耗时1ms,消耗37.1MB内存

1.关于复杂度 1.1 时间复杂度为 O(n^2) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 外层循环 1 到 n-1，内层循环 1 到 n，利用分母取余分子不断减小分母的值，若减小到最后分母为 1，添加到结果集后返回 3.提交记录 3.1 力扣中耗时 28ms,消耗

1.关于复杂度 1.1 时间复杂度为 O(m n) 1.2 空间负责度为 O(m n) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 经过分析，这个题目有两种情况 2.2.1 列为 0 或者行为 0 时，当前变量为 1，因为在当前情况下只可能有一条路径到达当前

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 将传入的pattern和str切割转换成数组 2.2 如果2.1中的两个数组长度不相等，直接返回false 2.3 定义一个HashMap存储映射关系

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 从head到tail遍历两个链表 2.1.1 如果相加结果大于10，将十位数与个位数分离，将十位数加到非空链表上面 2.1.2 如果相加结果小于10，直接将结果添

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 定义长度为 26 位的数组存储杂志字符串含有的字符 2.2 循环遍历杂志字符串填充 2.1 数组 2.3 遍历赎金信字符串 2.3.1 计算并检查当前字符个数是否

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 用numRows为长度定义一个StringBuilder数组 2.2 正序遍历字符串中每一个字符 2.2.1 当前索引除于numRows为偶数，表示当

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 遍历 allowed 数组标记出现的字符 2.2 遍历 words 数组， 遍历 words 元素中每一个字符，若当前字符不在 allowed 数组中，标记当前字符串不一致 3.

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 获取所有起点并放在 hash set 中 2.2 遍历所有路径，若终点城市不在起点的 set 上，返回该城市 3.提交记录 3.1 力扣中耗时 2ms,消耗 38MB 内存

1.关于复杂度   1.1 时间复杂度为O(n)   1.2 空间负责度为O(n) 2.我的解题思路   2.1 这个解法基于备忘录动态规划实现   2.2 因为0 ≤ N ≤ 30,所以我定义了一个长度为30的数组   2.3 定义一个终止条件nums[N]!=0或者N==0|

因为这两个解法原理一样，只是数据结构不一样，所以我将他们的解释合并 1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n^2) 2.我的解题思路 2.1 用哈希表记录字符以及它出现的次数 2.2 用桶/treeMap对哈希表的元素进行排序

Inserts a value to the set. Returns true if the set did not already contain the specified element.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历每个元素，若当前元素为1，检查左面以及上面的元素，并分开减2 3.提交记录 3.1 力扣中耗时16ms,消耗70.6MB内存 3.2 leetcode

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环计算较大分组的位置 2.2 对比当前元素以及后两个元素 2.2.1 如果三个元素相等，记录他们的起始与终止位置 3.提交记录 3.1 力扣中耗时 3ms,消耗

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环对比元素 2.2 设置字符串首元素到 lastChar 临时变量 2.3 循环遍历字符串 2.3.1 当前元素等于 lastChar，endIndex++

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n log n) 2.我的解题思路 2.1 定义一个整数保存当前最大长度和一个数组存储当前索引下最大上升序列长度 2.2 遍历数组 2.2.1 初始化辅助数组当前索引的值都为1，代表

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n log n) 2.我的解题思路 2.1 定义一个整数保存当前最大长度和一个数组存储当前最长上升序列 2.2 遍历数组 2.2.1 二分查找大于当前元素的最小元素

1.关于复杂度 1.1 时间复杂度为 O(n^2) 1.2 空间负责度为 O(n^2) 2.我的解题思路 2.1 标记连通城市的道路并计算道路的数量 2.2 循环遍历两个城市，将他们连通的道路数量相加，如果当前两个城市有直接连接的道路，计数减 1 2.3 返回 2.2 计算的最大

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个算法基于动态规划 2.2 循环遍历矩阵，当前元素为1时，对应的array[i+1][j+1] is Math.min(temp[i][j-1],Math.min(

1.关于复杂度 1.1 时间复杂度为 O(1) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 将传入字符串转换为字符数组 2.1.1 根据第二个数字替换第一个数字 2.1.2 根据第一个数字替换第二个数字 2.1.3 尽可能大的替换第三个数

1.关于复杂度 1.1 时间复杂度为 O(m n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 将每个客户的财富相加 2.2 对比与交换最大值 3.提交记录 3.1 力扣中耗时 0ms,消耗 38.3MB 内存 3.2 leetcode 中耗时 0ms,消耗 3

1. 关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2. 我的解题思路 2.1 数组排序 2.2 循环遍历数组，获取数组内最小元素 2.3 循环遍历数组，当当前元素加上最小值等于下一元素，将这两个元素加入到结果中 3. 提交记录 3.1 力扣中耗

1.关于复杂度 1.1 时间复杂度为 O(n^2) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 双重循环遍历数组，主循环为 0 到 数组长度，次循环为 0 到主循环位置，若两个循环当前元素相等，结果变量自增 3.提交记录 3.1 力扣中耗时 1ms,消耗 37.2MB

1.关于复杂度 1.1 时间复杂度为O(n log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于贪心算法 2.2 将数组排序 2.3 双指针遍历数组，记录船数，有两个情况 2.3.1 array[left]+arr

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义一个指针遍历链表，有两种情况 2.2.1 当前的next结点的值等于val，移动指针到这个点的下一结点 2.2.2 其他情况，直接移动指针

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义一个在head前面的结点 2.2 定义指向2.1定义结点的快慢指针 2.3 因为我们需要移除倒数第n个结点，所以先循环让fast与slow有n个结点的距离

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 因为题目表明数组中含有2N个元素，并且N个元素是相同的，所以只有一个元素重复 2.2 使用 HashSet 缓存独特的元素，如果 HashSet 含有当前元素，返回当前元素 3.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 获取链表长度 2.2 定义四个指针 2.2.1 node，链表的头结点 2.2.2 pre，有序区的边界结点 2.2.

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环遍历数组，将当前元素与上一元素相加 3.提交记录 3.1 力扣中耗时 0ms,消耗 39.9MB 内存 3.2 leetcode 中耗时 0ms,消耗 40.3MB 内存

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法参考程序员小灰的微信公众号：https://mp.weixin.qq.com/s/33aOwDGFQ5omE3sHmVLXVA 2.2 关于旋转点以及

1.关于复杂度 1.1 时间复杂度为O(log(n m))(n为矩阵的行数，m为矩阵的列数) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于二分查找 2.2 定义两个指针遍历矩阵，像往常那样获取中间元素 2.3 根据2.2中中间元素的获取

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义两个指针 2.2 二分查找源数组找出给定target的左边界 2.3 标记左边界，二分查找左边界到数组末尾找出给定target的右边界 3.提交记录 3.1 力扣

1. 关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2. 我的解题思路 2.1 依据题目规则预设一个长度为101的数组 2.2 计算各个数字出现在源数组的个数 2.3 计算小于当前数字的个数总和并返回 3. 提交记录 3.1 力扣中耗时1ms,消

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 在调用sumRange前通过sum[i]=sum[i-1]+nums[i]直接计算所有可能的结果 3.提交记录 3.1 力扣中耗

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 这个解法基于双指针 2.2 定义两个指针分别位于中间元素的两侧，定义一个基数 2.3 循环遍历到边界，逐步增大基数并赋值 3.提交记录 3.1 力扣中耗时 0ms,消耗

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于反转链表 2.2 循环获取链表长度 2.3 循环直到链表剩余长度小于2 2.3.1 循环相邻两个结点并调转 2.3

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 定义三个整数缓存三个最大的数 2.2 循环遍历数组，有4种情况 2.2.1 max1==nums[i]||max2==nums[i]||max3==nums[i]

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 因为题目划定了元素大小范围，所以也适用于计数排序 2.2 定义正数与负数的计数数组 2.3 使用 hash 筛选唯一元素 3.提交记录 3.1 力扣中耗时 1ms,消耗

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 循环遍历数组统计元素出现次数到 hash 中 2.2 使用 hash 筛选唯一元素 3.提交记录 3.1 力扣中耗时 2ms,消耗 37.3MB 内存 3.2 leetc

1.关于复杂度 1.1 时间复杂度为O(n log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 根据规律，结果为奇数索引上的值相加 2.2 对数组进行排序 2.3 将奇数索引上的值相加并返回 3.提交记录 3.1 力扣中耗时18ms,消耗39MB内存 3

1. 关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2. 我的解题思路 2.1 使用三个临时变量 2.1.1 cur，记录当前油缸量 2.1.2 total，记录总的消耗以及加油数的运算和 2.1.3

1.About Complexity 1.1 Time Complexity is depend on element in array 1.2 Space Complexity is O(1) 2.how I solve 2.1 use a multiple recursi

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 定义一个整数存储起点 2.2 倒序遍历数组，有两种情况 2.2.1 当前索引加上索引上的值大于缓存值，这表示在当前索引上有可能到达终点，移动缓存值 2.2.2

1.About Complexity 1.1 Time Complexity is O(n) 1.2 Space Complexity is O(1) 2.how I solve 2.1 define a integer to cache result 2.2 cir

1.关于复杂度 1.1 时间复杂度为 O(nlogn) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 排序原始数组 2.2 求出首两个元素差值 2.3 循环遍历数组，如果相邻两个元素差值不等于 2.2 中数值，返回 false 3.提交记录 3.1 力扣中耗时 1

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 定义一个数组暂存计算结果，因为第一个人没有左边的人，初始化temp[0]=1 2.2 循环1到n，对比当前元素以及左边的元素 2.2.1 如果当前元素

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历数组，有三种情况 2.1.1 nums[i]>=nums[i-1],符合题意 2.1.2 nums[i-2]>nums[i],表示nu

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 因为题目要是是超过一个late或者连续超过两个L,所以我们只能逐字符遍历字符串 2.2 从头到尾遍历字符串，主要分为三种情况 2.2.1 当前字符为A

1.关于复杂度 1.1 我不肯定时间复杂度，复杂度依赖于具体数组以及target 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于回溯算法 2.2 排序数组 2.3 递归中将当前循环的num加入缓存list以及更新当前n，如果n<=0,终止循环，如果n=0，加

1.关于复杂度 1.1 时间复杂度为O(n!) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于回溯算法 2.2 递归中将当前循环的num加入缓存list以及更新当前n，如果n<=0,终止循环，如果n=0，加入当前list到目标list中 3.提交记录 3.1

1.关于复杂度 1.1 时间复杂度为O(n k) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于回溯算法 2.2 递归中将当前循环的num加入缓存list以及更新当前n，如果n<=0,终止循环，如果n=0而且缓存list的大小等于k，加入当前li

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 这个解法基于动态规划 2.2 画表得到一个规律：res[current]=res[current&(current-1)]+1 3.提交记录 3.1 力扣中耗

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 遍历数组每一行，获取当前最小边，若当前最小边大于最大边，重置 result，若当前最小边等于当前最大边，结果自增 3.提交记录 3.1 力扣中耗时 2ms,消耗 38.9MB 内

1.关于复杂度 1.1 时间复杂度为 O(n) 1.2 空间负责度为 O(n) 2.我的解题思路 2.1 循环遍历数组计算结果数组的长度 2.2 循环遍历数组，用数组每两个元素计算的结果填充结果数组 3.提交记录 3.1 力扣中耗时 0ms,消耗 39.3MB 内存 3.2

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个算法基于快慢指针实现 2.2 定义一个结点为原链表的头结点 2.3 定义快慢指针，快指针指向原来的头结点head，慢指针指向2.2定义的结点 2.

1.关于复杂度 1.1 时间复杂度为O(n log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 升序排列两个数组 2.2 判断当前cookie是否能满足孩子的需要 3.提交记录 3.1 力扣中耗时20ms,消耗49.2MB内存 3.2

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于二分查找 2.2 对比中间值以及右侧的值，有两种情况 2.2.1 中间值大于右侧值，将右指针改成mid 2.2.2

1.关于复杂度 1.1 时间复杂度为O(log n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 这个解法基于二分查找 2.2 利用当前左右边界计算中间索引，对比中间索引的值以及左右侧的值，有三种情况 2.2.1 mid==0，对比中间值以

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 利用 list1 元素以及索引构建 Hash 2.2 循环遍历 list2，有四种情况 2.2.1 hash 中已经存在当前元素，hash 中的 value 与当前索引相

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(1) 2.我的解题思路 2.1 循环遍历a到z，获取当前字母第一次出现以及最后一次出现的索引 2.1.1 如果begin==-1，表示当前字母不存在于源字符串，跳过 2.1.

1.关于复杂度 1.1 时间复杂度为O(n) 1.2 空间负责度为O(n) 2.我的解题思路 2.1 第一次循环获取源字符串的字母出现次数 2.2 第二次遍历找出第一次出现的唯一字符 3.提交记录 3.1 力扣中耗时55ms,消耗37.6MB内存 3.

1.关于复杂度 1.1 时间复杂度为 O(n^2) 1.2 空间负责度为 O(1) 2.我的解题思路 2.1 循环遍历矩阵的每一行 2.1.1 定义两个从左到右和从右到左的指针 2.1.2 使用 2.1.1 的指针遍历列，交换并反转元素 2.1.