sjsjs11的博客

输入：source = [5,1,2,4,3], target = [1,5,4,2,3], allowedSwaps = [[0,4],[4,2],[1,3],[1,4]]我们定义哈希表sourceCount来记录该集合下source中元素数量。输入：source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]输入：source = [1,2,3,4], target = [1,3,2,4], allowedSwaps = []

解释：我们可以把 A 和 B 中的等价字符分为 [a,o,e,r,s,c], [l,p], [g,t] 和 [d,m] 共 4 组，因此 S 中除了 ‘u’ 和 ‘d’ 之外的所有字母都转化成了 ‘a’，最后答案为 “aauaaaaada”。例如， s1 = “abc” 和 s2 = “cde” 的等价信息和之前的例子一样，那么 baseStr = “eed” , “acd” 或 “aab”，这三个字符串都是等价的，而 “aab” 是 baseStr 的按字典序最小的等价字符串。

那么在计算res的时候，遍历字符串s，i=0所在连通集b是字典序最小字符，那么就将b推入res中，然后i=1所在连通集a是字典序最小的字符，将a推入到res中，再遍历到i=2，此时该连通集的小根堆中只剩下了c，那么只能推入c到res中，最后i=3，此时该连通集中的小根堆只剩下了d，推入d到res中，最后输出：“bacd”。输入：s = “dcab”, pairs = [[0,3],[1,2],[0,2]]输入：s = “cba”, pairs = [[0,1],[1,2]]s 中只含有小写英文字母。

输入：accounts = [[“John”, “johnsmith@mail.com”, “john00@mail.com”], [“John”, “johnnybravo@mail.com”], [“John”, “johnsmith@mail.com”, “john_newyork@mail.com”], [“Mary”, “mary@mail.com”]]接下来再次遍历每个账户的邮箱，我们通过unite函数，将parent中各个email对于的index的父节点都指向他们的代表节点。

其中 n 是 equations 中的方程数量，C 是变量的总数，在本题中变量都是小写字母，即 C≤26。给定一个由表示变量之间关系的字符串方程组成的数组，每个字符串方程 equations[i] 的长度为 4，并采用两种不同的形式之一：“a==b” 或 “a!解释：如果我们指定，a = 1 且 b = 1，那么可以满足第一个方程，但无法满足第二个方程。而函数unite的意义就是，将两个集合的根节点，合并成一个根节点，最后该集合的所有节点使用find都会查找到相同的根节点。输入：[“a==b”,“b!

我们使用贪心的思想，我们要让他异或的值最大，那么就要优先在较高的bit位上找出与nums[j]对应比特位相反数值的路径。也就是说在某个比特位上，nums[j]的该比特位是1，也就是代表树中的right，那么我们就要优先走0，也就是left这条路径。只要与nums[j]某比特位相反的节点存在，那么我们就走该子树的路径，由于该比特位会是异或，所以我们的异或值x就要更新为。输入：nums = [14,70,53,83,49,91,36,80,92,51,66,70]

输出：[[“baggage”,“bags”,“banner”],[“baggage”,“bags”,“banner”],[“baggage”,“bags”],[“bags”]]输入：products = [“mobile”,“mouse”,“moneypot”,“monitor”,“mousepad”], searchWord = “mouse”输出：[[“havana”],[“havana”],[“havana”],[“havana”],[“havana”],[“havana”]]

构造完字典树后，我们从树的根节点开始递归，用longest来记录最长的单词，我们在递归中只有子节点不是空指针，并且子节点的isEnd是true的时候，才会将递归子节点。也就是说，node和wd是在检验没问题后才传入递归函数，而longest需要与当前的单词wd进行比较，如果wd长度更长，则更新longest，如果wd长度等于longest并且字典序更小，也更新longest。输入：words = [“a”, “banana”, “app”, “appl”, “ap”, “apply”, “apple”]

当我们调用sum的时候，会先从字典树的根节点向下寻找到prefix的最后一个字符的节点，如果prefix在字典树中无法查找到，那么就直接返回0。查找到prefix最后一个字符的节点后，我们要开始计算以该节点开始，遍历所有的子节点，当v不为-1的时候，就说明该节点的字符是某个单词的结尾，那么我们就将该单词映射的值v加到search_sum中。int sum(string prefix) 返回所有以该前缀 prefix 开头的键 key 的值的总和。返回具有前缀等于给定字符串的键的值的总和。

接下来我们自定义一个split函数用来将sentence的单词储存到vector的words中，接下来我们定义一个findPrefix函数，将words中的每一个word在字典树中进行查找，看有没有词根，如果有的话就返回词根，否则返回word自身。在英语中，我们有一个叫做 词根(root) 的概念，可以词根 后面 添加其他一些词组成另一个较长的单词——我们称这个词为 衍生词 (derivative)。由于我们最后要返回的是一个句子，那么我们就将ans中的单词中插入空格，储存到res中，最后返回res即可。

接下来我们从字典树的根节点不断向下查找，我们看他有几个子节点，如果有多个子节点，就说明不需要继续添加字符了，因为只有当children的数量为1个的时候，说明是公共前缀。然后我们还要检查我们选择的下一个节点是不是某个word的结尾，如果是的话，就将其添加到res后，停止继续查找添加。输入：strs = [“flower”,“flow”,“flight”]输入：strs = [“dog”,“racecar”,“car”]如果不存在公共前缀，返回空字符串 “”。解释：输入不存在公共前缀。

所以当遇到’.‘的时候，我们就遍历当前节点的所有children，也就是代表’.‘被当成了任意一个字符，然后开始遍历。要注意的是在递归的时候，需要调用child->searchHelper，这是因为child代表的是’.‘代替的字符，这样递归的时候node才能指向正确的位置，如果递归返回的是true，那么说明将’.‘替换成child字符是可行的，如果所有替换成任意child都不可行，那么返回false。bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true；

接下来我们查看insert函数，我们一样把要插入的单词拆成一个个字符，如果我们沿着字典树某个路径找不到某个字符，那么就会new一个node->children[ch]，并且将node移到新开辟的节点，在插入完最后一个字符的时候，会进行一个标记。是否存在，如果该节点存在的话我们就将node移到该节点，然后我们继续遍历prefix的下一个字符，如果prefix所有字符都能依次在字典树沿着某条路径找到，那么他就会返回prefix的最后一个节点的指针。// 返回 True。

但是由于我们的频率一直在变化，我们为了减少对堆的操作，我们只要检验我们当前回合的id的最大频率，和哈希表中的正确频率是否一样，如果不一样的话，就将它从堆中弹出删除，直到检验成功为止，堆顶的元素才是答案。第 1 步操作后，有 3 个 ID 为 2 的元素和 2 个 ID 为 3 的元素，所以 ans[1] = 3。第 3 步操作后，有 2 个 ID 为 3 的元素和 1 个 ID 为 1 的元素，所以 ans[3] = 2。输入：nums = [2,3,2,1], freq = [3,2,-3,1]

我们再定义一个哈希表，可以通过烹饪方式，然后映射到一个堆，pair的first是评分，second是food的名字。我们这个堆要使用最小堆，这是因为在评分一样的时候，最小堆会按字典序来排序food的名字，所以我们的评分在这个哈希表中要加上负号。int find(int number) 返回给定数字 number 在系统中的最小下标。// 数字 10 所在的下标为 1 ，2 ，3 和 5。// 容器中下标为 2 处填入数字 10。// 容器中下标为 1 处填入数字 10。

int find(int number) 返回给定数字 number 在系统中的最小下标。// 容器中下标为 1 处填入数字 20。注意，下标 1 处之前为 10 ，现在被替换为 20。// 数字 10 所在的下标为 1 ，2 ，3 和 5。// 数字 10 所在下标为 2 ，3 和 5。// 容器中下标为 2 处填入数字 10。// 容器中下标为 1 处填入数字 10。// 容器中下标为 3 处填入数字 10。// 容器中下标为 5 处填入数字 10。

我们遍历每个经过的加油站以及终点，我们用curr和prev来记录相邻两个地方之间的距离，如果油够经过这段距离，我们就不用进行操作，只要将当前加油站油的数量加入到优先队列q中即可。如果油不够经过这段距离，那么我们就需要在之前的加油站进行加油，我们优先在有最多油的加油站加油，也就是q.top()，并且记录ans，直到油够经过这段距离位置。输入：target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]地，则返回 -1。

那么在上一个课程中，m + n是小于上一个课程的结束时间的，由于我们将m替换成比m小的当前课程的天数，而当前课程的结束时间又大于上一个课程的结束时间，所以替换后，一定可以保证不会超过当前课程的结束天数。输入：courses = [[100, 200], [200, 1300], [1000, 1250], [2000, 3200]]第二，修第 3 门课，耗费 1000 天，在第 1100 天完成，在第 1101 天开始下门课程。你的学期从第 1 天开始。输入：courses = [[3,2],[4,3]]

我们模拟从建筑1向建筑n移动，当出现前面建筑更高的时候，就将deltaH放到最小堆q中，如果最小堆里元素数量大于梯子数量，那么我们就弹出最小高差来使用砖块，以保证最高差都是用梯子。输入：heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2。输入：heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1。你从建筑物 0 开始旅程，不断向后面的建筑物移动，期间可能会用到砖块或梯子。

如果当前房间是怪物房间，则将它放到堆中，我们如果受到当前房间效果后生命值不为正，那么就说明我们要将之前的最大怪物伤害的房间放到末尾，所以我们就将最小堆堆顶的值加到hp上，并且ans++代表我们进行了一次调整，然后用delay来储存我们调整到末尾的伤害是多少。当遍历完成后，如果hp += delay不为正数，那么返回-1，否则返回ans。假定小扣原计划按房间编号升序访问所有房间补血/打怪，为保证血量始终为正值，小扣需对房间访问顺序进行调整，每次仅能将一个怪物房间（负数的房间）调整至访问顺序末尾。

nums1[0] + nums2[0]是两个数组元素和的最小值，组成二分下界，nums1[m-1] + nums2[n-1]组成二分上界。由于我们最终要返回的是前k小的所有的数组对。请找到和最小的 k 个数对 (u1,v1), (u2,v2) …输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3。输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2。输出: [1,2],[1,4],[1,6]输出: [1,1],[1,1]

我们可以统计左上部分小于等于8的数的数量，看8在排序后是第几小的数（因为图片有多个8，所以返回的是8是第几小的数的最大情况，即升序排列中最右边的8的位置）。所以在二分查找中，我们从取left + right除以2的值为mid，如果在check函数中得出来左上部分的数量大于等于我们所期待的k，那么就说明我们的取的mid大于等于实际元素，这时候我们就将right = mid，缩小他的上界。输入：matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8。

我们可以使用堆来模拟丑数的情况，我们定义一个堆，堆顶是最小的数，这个时候我们让堆顶的数乘以factors的三个不同因子的情况，继续加入到堆中，然后将堆顶元素弹出，这个时候堆顶元素就是第二小的数（包含已弹出的最小数），也就是第二个丑数，然后不断继续将堆顶元素乘以factors中顶三个不同因子，得到更多丑数。这时候我们要将他们正确插入到dp中，这时候就找其中最小的数也就是2放到dp[2]中，dp[2]中放的是1x2。那么三者中3最小，所以dp[3]中存放的是1x3=3，这个时候令p3++指向2。

场景1：m-1>n，即没有足够多的其他任务填充aaaa中的空，所以反过来考虑，将n个其他任务平铺，bbccdd，最多可以在其中插入n+1（左右端点都可以插入）个任务a，由m-1>n知，m>n+1，可以完成目标，此时花费的时间是n+n+1；一旦所有项目中的全部阶段任务都完成，或者执行仅剩的一个阶段任务将会导致你违反上面的规则，你将 停止工作。对于场景2中的情况，我们优先使用阶段最多的任务与阶段第二多的任务交替进行，然后两个任务的阶段数量不断缩减，当。每周，你将会完成 某一个 项目中的 恰好一个 阶段任务。

接着当s中某个字符的个数大于字符串s长度的一半的时候（s长度如果是奇数则向上取整），那么则无法有重构字符串。接着我们使用贪心的思路，我们每次取出字符数量最多的两个字符，将他们加入到重构字符串new_s中。我们要比较字符数量最多的数量，可以用最大堆来做，cmp是我们自己写的比较函数。每次将最多数量的字符加入到new_s后，将他们数量都减去1，当他们数量还大于0的时候，才将它们继续加入到q中。给定一个字符串s，检查是否能重新排布其中的字母，使得两相邻的字符不同。当q中只剩下一种字符，就加入new_s中。

有一棵特殊的苹果树，一连n天，每天都可以长出若干个苹果。在第i天，树上会长出apples[i]个苹果，这些苹果将会在days[i]天后（也就是说，第i+days[i]天时）腐烂，变得无法食用。接着我们将新长的苹果加到q中，最后模拟吃掉苹果，将ans加一，然后将q的队头的苹果减少1代表苹果被吃掉。输入：apples=[3,0,0,0,0,2],days=[3,0,0,0,0,2]输入：apples=[1,2,3,5,2],days=[3,2,1,4,2]

接下来我们进行k次投资遍历，我们知道投资的项目后推入大根堆q中，堆顶就是我们所需要的能投资的最大利润项目，然后进行投资，利润加到w中。这道题我们可以用贪心的思想，当我们有w资本的时候，能完成某些项目的投资，那么由于我们投资的次数有限制，并且投资利润高的项目能使w更大以便能有投资更多项目的权限。总而言之，从给定项目中选择 最多 k 个不同项目的列表，以 最大化最终资本 ，并输出最终可获得的最多资本。输入：k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]

这道题是关于链表的题，题目要求合并k个升序链表，实际上我们就可以有这么一个思路：我们将每个链表的元素都丢入小根堆中，然后将小根堆的元素依次组成一个新的链表。由于题目中已经升序排列好每个链表，也就是说每个链表的头节点的val是链表中最小的。：考虑优先队列中的元素不超过 k 个，那么插入和删除的时间代价为 O(logk)，这里最多有 kn 个点，对于每个点都被插入删除各一次，故总的时间代价即渐进时间复杂度为 O(kn×logk)。输入：lists = [[1,4,5],[1,3,4],[2,6]]

也就是我们在计算dfs(i,j)的时候，我们不断猜测k，我们既要计算出此时选择k的最大支付金额的路径（即运气最差的时候）。我们定义一个ans来记录dfs中最小能保证获胜的支付金额，首先我们先在i到j的范围内不断猜测数字k是多少，然后定义一个cost来代表选择k的时候可能最坏情况，而ans用来表示我们应该选取哪个k可以保证最小的最大支付金额。递推的边界情况是i >= j，因为这个时候i=j，我们可以猜对数字，所以这个时候的开销是0。每当你猜了数字 x 并且猜错了的时候，你需要支付金额为 x 的现金。

我们观察题目可以发现，题目中最多有三种分数，他们取决于第一次操作采用哪一种方式。也就是说如果我们采用回溯的方式，那么我们可以根据第一次操作的方式来分别进行回溯，因为这样子就知道后面回溯的分数要等于多少。我们定义dfs(i,j)表示下标i到j的nums的相同分数的最大操作数目是多少，也就是说当我们知道我们要使分数为target，那么假设有一种方式。我们回溯的界限是当i >= j当时候，返回0，因为已经无法进行任何操作。输入：nums = [3,2,1,2,3,4]输入：nums = [3,2,6,1,4]

我们要求子序列构造的最长回文串长度，实际上就是将word1和word2合成一个字符串，然后求最长回文串长度，由于题目要求word1和word2都要有字符构成回文串。当s[i] = s[j]的时候，dp[i][j]一定包含s[i]和s[j]，那么我们就可以判断i如果在word1范围内，j在word2范围内，就说明该dp[i][j]记录的最长回文串长度一定有word1和word2贡献的字符。解释：从 word1 中选出 “ab” ，从 word2 中选出 “cba” ，得到回文串 “abcba”。

我们定义一个三维数组dp[k][i][j]来表示在i到j范围内并且以k开头的回文子序列的总数。当s[I] = s[j]的时候，那么i+1到j-1中的回文子序列加上两边的x都是以x为开头的回文子序列，并且字符c可以构成c或者cc两个回文子序列，所以有状态转移方程。因此，当前子串 s[i…j] 中以 c 为边界的回文子序列，与子串 s[i…解释：6 个不同的非空回文子字符序列分别为：‘b’, ‘c’, ‘bb’, ‘cc’, ‘bcb’, ‘bccb’。s[i] 仅包含 ‘a’, ‘b’, ‘c’ 或 ‘d’

这是我一开始的方法，我们不断寻找最合适的班级来插入聪明的学生，然后我每一轮插入前就先比较classes的增长如何，然后找到会有最大的增长的班级插入聪明的学生。但是这就出现了一个问题，我们计算插入聪明学生的增长，只需要对修改过的classes计算就行，而在该方法中我对每一个classes都进行了运算，其中这部分有大多数计算会是多余的。平均通过率 是所有班级的通过率之和除以班级数目。输入：classes = [[2,4],[3,9],[4,5],[2,10]], extraStudents = 4。

其中 tasks[i] = [enqueueTimei, processingTimei] 意味着第 i​​​​​​​​​​ 项任务将会于 enqueueTimei 时进入任务队列，需要 processingTimei 的时长完成执行。当cpu处理任务的时候，可以认为中间不进行任何操作，当处理完后，时间轴来到了t，那么就要将时间小于t的所有任务加入到q中，然后我们q的队头就是执行时间最短的任务，将它丢到cpu中执行。输入：tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]

当我们从小根堆中找到最小代价的时候，我们可以通过索引去找到他是在左边的区间还是右边的区间，然后找到对应的区间后，我们就移动其区间的指针，使最前面区间和最后面区间的范围都是candidates。比方说，costs = [3,2,7,7,1,2] 且 candidates = 2 ，第一轮雇佣中，我们选择第 4 位工人，因为他的代价最小 [3,2,7,7,1,2]。第二轮雇佣，我们选择第 1 位工人，因为他们的代价与第 4 位工人一样都是最小代价，而且下标更小，[3,2,7,7,2]。

反之亦然，如果该订单是一笔销售订单 sell ，则可以查看积压订单中价格 最高 的采购订单 buy。如果该采购订单 buy 的价格 高于或等于 当前销售订单 sell 的价格，则匹配并执行这两笔订单，并将采购订单 buy 从积压订单中删除。如果该销售订单 sell 的价格 低于或等于 当前采购订单 buy 的价格，则匹配并执行这两笔订单，并将销售订单 sell 从积压订单中删除。输入：orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]

我们遍历arrival，也就是到达时间，然后我们在处理到达之前，需要先对离开的人进行处理，我们定义一个指针j，所有离开时间小于到达时间的座位都应该被释放，所以我们要将占据的座位加入到q中供arrival选择。给你一个下标从 0 开始的二维整数数组 times ，其中 times[i] = [arrivali, leavingi] 表示第 i 个朋友到达和离开的时刻，同时给你一个整数 targetFriend。比方说，当一个朋友到达时，如果椅子 0 ，1 和 5 被占据了，那么他会占据 2 号椅子。

这个示例中只有一个工人，所以答案是 workerTimes[0] + workerTimes[0] * 2 + workerTimes[0] * 3 + workerTimes[0] * 4 + workerTimes[0] * 5 = 15 秒。工人 2 将高度降低 3，花费 workerTimes[2] + workerTimes[2] * 2 + workerTimes[2] * 3 = 12 秒。工人 2 将高度降低 1，花费 workerTimes[2] = 1 秒。

这是因为i是向左遍历的，如果f[i]小于队头元素，并且队头元素会比f[i]先被弹出，也就是说f[i]会始终小于q的队头元素，那么此时比f[i]大的队头元素便没有存在的必要。当你购买了水果i，由于我们要购买所有的水果，那么我们下一个可以购买的水果就是[i+1, 2i+1]，这时候定义一个变量k来储存这个范围内f[j]的最小值，那么f[i]也就可以从k加上当前prices[i-1]转移而来。用 prices[2] = 6 个金币购买第 3 个水果，你可以免费获得第 4，5，6（接下来的三个）水果。

如果发现差大于limit，那么我们此时要做的就是移动left，我们移动left的目的是看nums[left]是否是queMax中的队首或者queMin中的队首，也就是滑块中的最大值或最小值，如果nums[left]的值等于滑块的最大值，那么就弹出queMax的队首，并且继续将left向右移动，继续判断接下来的新的滑块范围的最大值减最小值是否大于limit。输入：nums = [4,2,2,2,4,4,2,2], limit = 0。输入：nums = [10,1,2,4,7,2], limit = 5。