weixin_49332521的博客

注意也要把map里面的key删除，这个key在node里面有（这就是为什么node里面也要存key）。对于获取：先看一下map里面有没有这个key，有的话返回这个node，并把这个。

已知顺序排列，每个链表的node比较再加进结果，用优先队列方便比较node，可以先把每个链表的头结点加进队列，然后队列头出，出来的头还有next，就加进去，这样确保每个链表都有节点放进队列里面了。两两合并链表，逐个击破。

用双指针找到中间点，然后把链表分成两个部分，不断进行这个操作，直到next或当前节点为null。在“上一步”里，把返回的节点接受为自己的左右两段部分的头结点。省去拆分的操作，直接合并相邻的节点。返回当前节点，回到“上一步”然后根据大小进行合并。

不复制在map里，而是直接复制在链表里，相当于插入一个新的node，插入后就会知道原本节点的next，但是不知道random，所以还需要再遍历一次找到random，最后拆分两个链表。利用map，先把val复制到新的node，再把关系复制到node，key是旧的node，value是新的node。

把链表的每一段看成新链表，单独进行反转，然后再放回原链表。关键是截取k个节点、进行反转后，怎么再和原链表链接起来。我们把截取的k个节点叫做旧子链表，反转后是新子链表，可以理解为把原链表的每一段进行反转。

要交换1和2，就需要一个虚拟头节点，把指针定位到虚拟头节点上。示例1中，要交换3和4，应该把指针定位到2，然后执行交换。交换的时候：先连好后面的节点，再变换中间的节点。可以用递归，每次交换两个节点，

最少需要两个节点，所以我们要构建一个虚拟头节点，让slow从这个虚拟头节点开始走，避免一个节点错误。对于只有一个节点的链表：slow.next = slow.next.next显然不成立。所以可以用双指针，slow从头节点开始，fast从n+1个节点开始。尾节点和倒数第n+1个节点的距离是：n+1，这个距离是不会变的。当node.next是null，我们知道这个节点是尾节点。如果要删除倒数第n个，指针应该定位到倒数第n+1个，如示例1，删除4，应该定位到3。

所以，需要一个变量表示进位的数字，两数之和应该是 sum=a+b+进位。这里需要新建节点，所以我们可以在新建节点的时候把val设置好。这样，第一个节点就不是真正的头节点，下一个才是。每一位的数字是：sum%10。每一位的进位是：sum/10。

在这一点，我们能得到两段相等的距离，如果有点从开头走完a，相当于一点走完c并在环里走几圈，如果有两个速度为1的点这样走，它们最后一定会相遇，而且就是在环的入口处相遇。当他们相遇时，快指针已经在环里走了n圈，但是慢指针是第一次进环。如果从相同的起点出发，快指针每次走两步，慢指针走一步，我们知道用快慢指针遍历环形链表，两个指针一定会相遇。相同的时间内，快指针的路程是慢指针的两倍。

链表基础操作集合。

所以，可以先遍历对角线元素，如：找到大于、小于target的对角线元素，target应该在这两个元素之间。所以，可以从大的部分开始遍历，而且也不一定要沿着对角线走，如果比当前的数大，向下走，比当前的数小，向左走。对于行列相等的矩阵这样可以，但是对于行列不相等的，这样只能遍历到较小的数，大的部分就不容易找到。要充分利用矩阵的特征，行递增、列递增，合起来就是对角线递增。如：找20，20应该在17到30之间,

类似于把数组向右移动几位，每一个元素变换位置都能组成一个圈。下面看一圈里面经过的索引，以（0,1）为起始点。循环的边界就是：i<n/2,j<(n+1)/2。只需要把每个圈里面的元素更换位置就行。需要旋转的起始点是1和2。

如果某行、列已经读取过，就把这行、列从矩阵中删除，这里的删除可以通过重新设立矩阵的边界完成。一直进行循环，直到 首行>末行，首列>尾列，边界有4个，首行、末行，首列、尾列，规定每次读取，都要把这行、列读完。

然后再次遍历，如果某个元素所在位置的首行或首列为0，就把这个元素变为0，这里不能遍历到首列，但是可以遍历到首行，因为首行元素是否变0，要看首列元素里面第一个元素，而且，由于首列的元素被修改成0，还需要看原始首列是否有0，有0的话做个标记，在遍历的时候把首列元素设为0。这里需要注意，因为首行首列做过修改，所以我们再次遍历的时候要从后往前遍历，避免前面修改得到的0干扰。上面是用了两个额外的数组做标记，实际上可以用矩阵本身的行和列做标记，就用第一行和第一列。第一次遍历，找到为0的元素，标注行和列是true。

可以使用Set，把数组元素都放进Set里面，然后查看是否有【1，。，n】这个顺子，缺少哪个就返回哪个，如果都不缺，返回n+1。交换位置，从第一个元素开始遍历，如果第一个元素在正确的顺子范围内【1，。，n】，而且不满足当前元素的位置不是正确的位置，即。等式两边都是代表位置，左边是 元素应该在的位置（理想位置），右边是元素实际在的位置（现实位置）。如果 理想位置处元素 和 现实位置处的元素 相等，那就不需要进行交换，这样就避免进入死循环。而数组里面的元素都是无序的，所以我们要把这些元素放在它们正确的位置上。

所以，可以只有一个数组，初始化全1，然后开始计算。分别从0，n-1开始计算，最后就是对应元素相乘。，然后计算结果，两次for循环。为了减少空间，可以直接使用。

观察例子可以发现：相当于把后面部分的放到前面，就是先把数组倒序，然后从开头、中间开始正序。1会换到3，3会换到5，5会换到1，这是一轮替换：1->3->5->1。可以记录已经处理过的元素个数。综上，可以一轮一轮的替换，

【代码】力扣——合并区间。

这里只需要保存前一个位置的dp就行。

缩小左边就是左指针右移。

PriorityQueue 是 Java 集合框架中的一个类，它实现了优先队列的功能，即队列中的元素会按照一定的优先级进行排序，默认情况下是自然排序（对于可比较的元素）。先看max在不在这个窗口里面，在的话新增数值和max比较，不在的话就窗口外面的从大顶堆排出去，加入新增的。到第二个窗口，先看新增值和这些升序元素哪个大，然后把新排序好的、值最大的、且在第二个窗口内的元素返回。如果新增的比队尾的大，把队尾的出去，放入新增，这样队列里元素就是升序排列。窗口滑动的时候，相邻的窗口会有重合的部分，

子数组有两个边界，可以先固定左边界，然后遍历右边界，一边遍历一边求和。如【1 1 1】，应该是【3-0】，所以要有一个初始的前缀和0。上面的公式类似于求两数之和，可以用map方便查找，key是前缀和，value是前缀和的个数。如【1 1 1】，前缀和【1 2 3】用前缀和，前缀和就是数组累计求和。如果求某个子数组【i，j】的和，，所以只需要看有几个。

给s窗口增加一个字母，这个字母之前在没count里统计过，要看这个字母和p有什么关系，才能看出它对differ的影响。去掉s窗口左边的字母，这个字母之前在count里统计过，要看这个字母在differ里面的贡献是什么，如果count里这个字母的数量是-1，说明它和p里面的某个字母一样，现在要加上它，就是differ–如果count里这个字母的数量是0，说明它贡献了一个相同的字母，现在要去掉它，就是differ++s窗口滑动的时候，去掉左边的字母，新增右边的字母，移动s的窗口，看differ的变化，

【代码】力扣——无重复字符的最长子串。

height[left]或height[right]利用栈，放入索引，因为和元素的位置也有关系，所以放入索引而不是值。这里既用双指针更新最大值，也指代当前位置，利用动态规划分别找到每一个位置处的。只用一次，用数组存储浪费空间。，得到当前值对应的左右最大值。，分别从0和n-1向内滑动。可以用双指针得到每个。

如果使用暴力循环，需要循环3次，不能出现重复的数组，所以在后面的循环里需要跳过与之前数相同的数，所以还需要记录之前遍历过的数，浪费空间，最简单的方法是对原数组。此时数组是递增的，要满足条件，b++后必须有c–，这样才能保证和不变，所以利用双指针就可以一次性遍历b,c。，这样只会出现(a,b,c)，不会出现(b,c,a)，可以先固定a，寻找b和c，

假设两个指针分别指向一个长线和一个短线，向内移动其中任何一个，他们的距离会变小。利用双指针，分别指向开头和末尾，然后向内移动，要找到最大的面积，每次只移动短线，面积主要看短线和两线之间的距离。

所以，如果right不为0，两个指针一起移动，为0，只要right移动，此时left指向0，当right不为0时，进行交换。双指针，left指向第一个0，right指向第一个非零的数，然后交换。注意 先交换后移动，避免指针异常。

【代码】力扣——最长连续序列。

如果用map存储相同字母的异位词，key应该是这些相同字母的组合，value是这些异位词，而且是放在List里面的。思路不难，重点是数据格式。

如果把数据全部放入map，再进行查找，会慢一点且可能浪费空间。，用map查找更快，而且可以一边把数据放入map，一边查找。

可以把数组 nums 看作一个特殊的链表，由于数组中存在重复数字，那么在这个链表中必然会形成一个环，而重复的数字就是环的入口。索引 4 指向 nums[4] = 2，这里就形成了一个环。每个数，既是索引又是元素值。慢指针每次移动一步，快指针每次移动两步。索引 0 指向 nums[0] = 1。索引 1 指向 nums[1] = 3。索引 3 指向 nums[3] = 2。索引 2 指向 nums[2] = 4。Floyd 判圈算法。

需要找到前面小的，放在后面的位置，再把 比这个小的 稍微大一点的数 放在前面。的，说明现在就是最大了，只需要把全部排列成升序就行。降序变成升序，直接使用双指针交换位置就行。找出下一个排序，递增的，比如12。4321，下一个是12。

就是把【h】变成【ho】,【r】变成【ro】，不需要执行额外的操作，遍历到这里就行，dp和之前的。，在计算dp(i,j) 的时候我们不需要考虑前面的部分，只考虑。类似于 最长公共子序列， 这里需要找到子串最小变换次数。，需要把【ho】变成【hor】,只要增加一个就行。，就是把【h】变成【ho】,只要增加一个就行。，分别是变换的最小次数，说明两个word。，思路更简单，直接修改/增加就行，

由于这个公共字符在text1和text2中都有，为了避免重复遍历，重复+1，我们需要找到text1和text2第一次同时遍历这个公共字符的情况，如果公共字符的位置是i,j，那么text1和text2中他上一个字符分别是i-1,j-1。可以发现字符不相等的情况下，当前的最大长度，不仅和 当前字符的前一个字符(同一行，前一列) 的最大长度有关，还和上一次 当前字符(上一行，同一列)的最大长度有关。比如下面这种情况，再次遇到b，应该用[a]和[abc]的长度+1，而不是[ab]和[abc]

只用一个行向量是无法表示全部dp情况的，所以需要一个矩阵[i,j]，i<=j，是一个上三角矩阵。表示字串是否为回文串，是则为true，否则为false，字串的长度为。由这两种情况不断向外扩展就行，只要两边的字母相等，就是回文串。

类似于冒泡排序，遍历一次nums，把0都放在前面，然后再遍历一次，把1放在0后面，剩下的就都是。上面用一个指针遍历了两次，可以用两个指针只遍历一次。令P0之前的都为0，P1之前的都为1。

出发点的dp就是本身。

注意在边界上：第一行和第一列，dp值都为1（因为只能向右或下走，所以到达同一行或同一列只有一条路）位置只和本行和上一行的有关，所以只记一行就行。条，由于只能向右或下走，所以。

对应的和有很多个，如【1 2 3 4】，3对应的和有1 2 3 4 5 6，如果根据。时候的值，就是后面的值，注意这里要从后向前（从大到小）更新，避免用更新后的值计算。（表格里没写列数为0，列数为0说明不挑选数字，所以0列的值都是true）的时候，这一行前面和上一行前面的值相同，所以我们只需要更新。分割为两个和相等的子集，说明有一个子集的和是总和的一半，对应的和的数值可以是多少 来遍历 ，假设。对应的 和 的数值 有哪些，列数是。，说明一定是之前的数得到的，则。对应的 和 的数值 =对应的 和 的数值 =