青衫客36的博客

【代码】867. 转置矩阵。

【代码】LeetCode146- LRU 缓存。

从前往后遍历，每次遇到一个数，若cnt=0，则把cnt置为1，把val置为这个数；如果cnt不为0的话，如果当前数nums[i]与val相同，就把cnt++；如果当前数nums[i]与val不同，就把cnt--我们使用两个变量，val表示当前这个数，cnt表示这个数出现了多少次。走到最后时，val存的就是要求的那个数。此算法名为摩尔投票法。

【代码】leetcode-46. 全排列。

stk表示存入这些数据的栈，stk_min表示栈里面前i数中的最小值是多少。

顺时针定义好四个方向（按题目要求为右下左上），首先往右走，走到不能走为止，再往下走，走到不能走为止，再往左走......（一直顺时针转圈的方式走，直到走满n * m步）什么是不能走的情况？要么走出边界了，要么走的格子已经走过了（就这两种情况）

除了根节点都有一个性质，自己对应的节点是相同的，并且左右儿子，左右和右左分别对称。即根节点的左右两棵子树，每一棵都是左右对称的。

遍历树中的所有点，每次遍历完之后把左右儿子swap一下。

从A的树根开始枚举，我们先看树根是不是B的根部，不是的话，然后再看树的左儿子是不是B的树根开始的一部分，不是的话就继续搜，即枚举一遍所有点是不是B的根，如果A的某个节点是B的根，那就再判断B是不是A的子结构，如果是就return true，否则就继续进行。怎么判断B是A的子结构？同时按顺序遍历B和A的分支，对于B的每一个分支，在遍历到叶节点之前，A都有与之对应的节点存在，那么B就是A的一部分。

链表实现的归并排序，创建一个虚拟头结点，最后返回虚拟头结点的next即可。

因为这是单链表，所以我们不能找到一个节点的前驱节点，所以我们要用一个变量来记录前驱节点。使用两个指针，这两个指针一起向前走且间隔为1，然后从前往后遍历，将所有指针的指向都反过来即可。

（1）如果p[j+1]不是通配符'*'，则f[i][j]是真，当且仅当s[i]可以和p[j]匹配，且f[i+1][j+1]是真；这样做的话，我们发现，f[i][j]除了枚举0个p[j]之外，其余的枚举操作都包含在f[i+1][j]中了，所以我们只需判断。最直观的转移方式是这样的：枚举通配符'*'可以匹配多少个p[j]，只要有一种情况可以匹配，则f[i][j]就是真；状态表示：f[i][j]表示p从j开始到结尾，是否能匹配s从i开始到结尾。f[i+1][j]是否为真，以及s[i]是否可以和p[j]匹配即可。

类似于二叉树的前序遍历，左分支代表不转换字母的大小写，右分支代表转换字母的大小写，如果遇到数字就跳过，继续遍历下一个位置，循环的终止条件是扫描到最后一个元素的下一个位置。（如果扫描到最后一个元素就停止的话，那么最后一个元素可能还没有进行大小写转换，所以我们要扫描到最后一个元素的下一个位置，以确保字符串中所有的字母都大小写转换过）

把当前所有数维护成两个集合，第一个集合是一个小根堆，存的是比较大的那部分数，第二个集合是大根堆，存的是比较小的那部分数。每次把新来的数插到大根堆里（数值比较小的集合中），如果发现大根堆的堆顶元素比小根堆的堆顶元素大，说明新来的这个应该属于小根堆（数值比较大的集合），此时交换两个堆的堆顶元素，由于我们每次都往大根堆里面插，会导致大根堆中的元素越来越多，如果下面堆中元素的个数比上面堆中的元素个数多2，那就在下面堆中拿出一个来，插到上面的堆中。（注，上面的堆，下面的堆是依据下图所言）重点是如何维护这两个堆！

类似于快排的思想，i, j分别指向数组起始位置和最终位置，i是从前往后遍历，如果i所指的数为奇数，则继续向后走，否则，如果是偶数，则停下，j是从后向前遍历，如果是偶数，就往前走，奇数就停下，然后交换a[i]，a[j]。

则当 first 走到 b 时，由于 second 比 first 多走一倍的路，所以 second 已经从 b 开始在环上走了 x 步，可能多余1圈，距离 b 还差 y 步（这是因为第一次相遇点在 b 之后 y 步，我们让 first 退回 b 点，则 second 会退 2y 步，也就是距离 b 点还差 y 步）；所以第二次相遇点就是 b 点。证明：如上图所示，a 是起点，b 是环的入口，c 是两个指针的第一次相遇点，ab 之间的距离是 x，bc 之间的距离是 y。本题的做法比较巧妙。

单链表只能从前往后遍历，所以，我们可以先计算出链表长度，倒数第k个节点相当于正数第n-k+1个节点，然后我们再从头往后找，找到第n-k+1个节点就可以了。

我们使用两个指针，第一个指针p存的是上一个保留段的结尾，q存的是下一段的第一个节点，q指针的作用是扫描下一段，把下一段全部扫描结束，如果下一段的长度为1，p指针向后移动一位，否则，p->next = q，直接跳过下一段。本题可能会把头结点删掉，凡是可能会把头结点删掉的，我们一般来说都定义一个虚拟头结点来简化代码。

本题没有给出前驱节点，所以不能采用让前驱节点的next指针指向当前节点的next指针这种方法，因为当前节点不是最后一个节点，所以下一个节点一定不是空节点，我们可以采用，用下一个节点的值把当前节点的覆盖掉，并且把下一个节点删掉，效果与删除当前节点是一样的，这样的话就不用前驱节点了。

如果是负数（有符号整数），在右移时高位补1，上述程序中的while(n)会陷入死循环，所以要将n转换为无符号整数（数值不变，仅改变解释规则）10000000000000000000000000000000000这样的。计算机中的补数是，两个数加起来等于在二进制里一个非常整的数，比如，加起来等于。负数在计算机中，用其绝对值的补数来表示它。-3在计算机中表示为（即3的补数）

本题可以抽象为整数划分的问题，给我们一个整数，然后我们把它划分为更小的若干个正整数的和，使得划分出来的这些正整数乘积最大。结论：将整数N把它分成尽量多的3，如果最后剩下一个2的话，就拆分出来一个2，如果剩下两个2的话就拆分为两个2。如果N%3==0，那就把它拆分为若干个3，如果N%3==1，先拆出两个2，剩下的全部分成3，如果N%3==2，先拆出一个2，剩下的全部分成3。

本题是一个经典的宽搜问题，我们从左上角开始宽度优先遍历，把所有能走到的格子找出来，（建议使用宽度优先遍历，因为深度优先遍历在数据范围比较大的时候可能会栈溢出，导致runtime error）从（0,0）点开始每次扩展合法且没有遍历过的点到我们的队列里面去，最后我们一共遍历过多少个合法的格子，那么遍历的个数就是我们的答案。时间复杂度为O(m*n)，即所有格子的个数。

时间复杂度分析：单词起点一共有 n^2 个，单词的每个字母一共有上下左右四个方向可以选择，但由于不能走回头路，所以除了单词首字母外，仅有三种选择。所以总时间复杂度是 O(n^2*3^k)。过程中需要将已经使用过的字母改成一个特殊字母，以避免重复使用字符。我们先枚举单词的起点，然后依次枚举单词的每个字母。

将前面某段移动到后面，此时可能会出现最开始某几个数字和结尾的几个数字是相同的，我们把结尾部分（与开始部分相同的数字）去掉后会发现，后半部分所有的数字都比第一个元素小，前半部分所有数字都满足比第一个元素大或相等，那我们就可以二分了，二分出来整个区间第一个比第一个元素小的数，那么这个数就是我们的最小值。

由此可以看出，迭代的效率是远高于递归的。

注意，将栈stk移动到栈cache后，还得移动回来，否则会破坏先进先出的特性。

【代码】LeetCode-二叉树的下一个节点。

我们在初始化时，用哈希表(unordered_map)记录每个值在中序遍历中的位置，这样我们在递归到每个节点时，在中序遍历中查找根节点位置的操作，只需要 O(1) 的时间。此时，创建每个节点需要的时间是 O(1)，所以总时间复杂度是 O(n)。

【代码】LeetCode-从尾到头打印链表。

创建一个新的string，一边遍历原字符串的每一个字符，一边往新的字符串中写入，遇到空格替换为%20即可。

所以，我们从右上角往左下角寻找target，如果当前位置比target要大，就不用在这一列找了，因为这一列往下的数都大于当前位置的数，直接 j - -，从前一列中找；如果当前位置比target要小，就不用在这一行找了，因为这一行之前的数都小于当前位置的数，直接 i + +，从下一行找。由于每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。

当前nums[i]没有放到正确的坑上，并且那个正确的坑上的数与那个坑是不匹配的，那么就要不停地交换，交换到不能交换的时候，就要判断一下，是不是遇到重复的了，如果nums[i]没有放到正确的位置上，并且它要放的那个位置已经有一个数在那待着了，说明nums[i]这个数至少出现了两次了，此时，我们就可以直接返回nums[i]，否则最后返回-1。= 3，nums[3]与nums[0]进行交换，nums[0] = 1，然后继续向后执行，发现判断条件nums[0]!本题也可以用unordered_map。