leetcode好方法记录_回文根-CSDN博客

本文链接：https://blog.csdn.net/weixin_44984682/article/details/104706735

https://leetcode-cn.com/problems/split-array-into-consecutive-subsequences/submissions/剑指offer刷题记录

84 单调栈（85使用了相关的算法解题）
面试题52
https://leetcode-cn.com/problems/liang-ge-lian-biao-de-di-yi-ge-gong-gong-jie-dian-lcof/solution/
双指针法需要面对的问题是两个链表可能不一样长，解决方法：
1.循环，链表拼接。当一个链表到达末端的时候，从另外一个链表头开始遍历。
2.不同时出发，首先分别遍历链表，求出两者长度差，然后长链表先出发。

面试题62
https://leetcode-cn.com/problems/yuan-quan-zhong-zui-hou-sheng-xia-de-shu-zi-lcof/
约瑟夫环问题的简单版本

面试题28
https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/submissions/
树也是一种链表，我们也可以使用双指针。

面试题39
https://leetcode-cn.com/problems/shu-zu-zhong-chu-xian-ci-shu-chao-guo-yi-ban-de-shu-zi-lcof/solution/mian-shi-ti-39-shu-zu-zhong-chu-xian-ci-shu-chao-3/
摩尔投票法

面试题21
https://leetcode-cn.com/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/submissions/
双指针法

面试题33
https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-hou-xu-bian-li-xu-lie-lcof/solution/
二叉搜索树中的单调栈

面试题32|||
https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/
双端队列

面试题41
https://leetcode-cn.com/problems/shu-ju-liu-zhong-de-zhong-wei-shu-lcof/solution/
1.大顶堆小顶堆在中位数中的应用。
2.优先队列的本质上是一个大顶堆或者是小顶堆。
3.插入比查找要简单。insert以及lower_bound的定义。

面试题56
https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/solution/zhi-chu-xian-yi-ci-de-shu-xi-lie-wei-yun-suan-by-a/
1.一个数与自己异或为0.
2.一个数与0异或为自己。
3.异或有交换律。

面试题51
https://leetcode-cn.com/problems/shu-zu-zhong-de-ni-xu-dui-lcof/
1.归并排序，其内涵是二分法。
2.数组逆序的问题。
3.树状数组。
https://blog.csdn.net/m0_38033475/article/details/80330157
https://www.cnblogs.com/saltless/archive/2011/06/01/2065619.html
https://blog.csdn.net/lesileqin/article/details/102420800
https://blog.csdn.net/Small_Orange_glory/article/details/81290634
https://blog.csdn.net/qq_39627843/article/details/81204671

面试题59||
https://leetcode-cn.com/problems/dui-lie-de-zui-da-zhi-lcof/solution/
O(1)复杂度的API设计题

程序员面试金典
面试题17.01
https://leetcode-cn.https://leetcode-cn.com/problems/add-without-plus-lcci/om/problems/add-without-plus-lcci/
不用+号的加法，用^ ^异或被称为半加运算，只进行加法，不进行进位，我们需要模拟进位，这里重要的是只有两个对应的位置上都是1才有可能会进位。

面试题08.14
https://leetcode-cn.com/problems/boolean-evaluation-lcci/
卡特兰数的典型应用
总结：https://www.cnblogs.com/dyhaohaoxuexi/p/10981810.html

面试题08.09
https://leetcode-cn.com/problems/bracket-lcci/
1.第一种方法是用记忆化的方法解决问题。
2.第二种方法是使用回溯法，类似于DFS,(解空间树)
https://www.cnblogs.com/waring/p/4551218.html

面试题16.26
https://leetcode-cn.com/problems/calculator-lcci/submissions/
1.逆波兰表达式，使用stack实现。
2.分两个栈，当Op栈中没有字符的时候或者是当前字符的优先级大于等于栈首字符时，直接加入。
若是全部小于时，取出对应的字符并且计算结果。

面试题17.08
https://leetcode-cn.com/problems/circus-tower-lcci/
确定一个单一的标准，然后按照第二个标准处理。
low_bound(itera,iterb,value)可以求在序列中的小于value的第一个值。但是其输出最好保存为auto，*auto修改对应位置上的值。

面试题50.04
https://leetcode-cn.com/problems/closed-number-lcci/submissions/
bitset.h头文件中保存有bibset方法，很好，是应对位运算的有效数据容器。
https://www.cnblogs.com/magisk/p/8809922.html

面试题08.11
https://leetcode-cn.com/problems/coin-lcci/
这道题实际上就是背包问题。
如果采取其他方法的思路，会遇到一个问题：重复
先选1后选5，和后面先选5后选1，这两种是一种，后面会把这一种算成两种，问题就是顺序。
采用背包问题的形式求解，dp[i][j]=dp[ i-1][j]+dp[i-1][j-c[i]];
前一个i是硬币的种类，后一个j是当前要处理的价格，dp中存放的是种类。这里我们不需要遍历查找，因为必须要达到确定的价格。
原本的背包问题这里前一个是物品的种类，后一个是背包剩余的空间，dp中存放的值是当前的价值。
原本的背包问题完成之后需要遍历数组，寻找最大的价值。原因在于这里背包可以不装满，我们必须遍历查找。
当然这里依然是无限背包的变体，我们可以将之一维化
int value[4]={1,5,10,25};
vector dp(n+1,1);
这里我们要注意在初始化的时候，将dp中所有的数值全部置为1.
因为不管如何，全部取1总有一种办法，当然我们在后面就不会再考虑取1的情况了。
for(int i=1;i<value.size();i++)
for(int j=value[i];j<n+1;j++)
dp[j]=dp[j]+dp[j-value[i]];
类似的还有PATA1068，这一类题要多加注意。

面试题 04.05
判断一棵树是否是二叉搜索树。
这个问题很重要！！！！！！！！！！
这个问题很重要！！！！！！！！！！
这个问题很重要！！！！！！！！！！
这个问题很重要！！！！！！！！！！
这个问题很重要！！！！！！！！！！
https://leetcode-cn.com/problems/legal-binary-search-tree-lcci/
判断一个树是否是二叉搜索数不能按照通常的思维惯性判断，否则会出事。原因在下
15
10 16
6 17
有两种方法：
1.中序遍历，这样我们可以得到一个单增的序列，判断这个序列是否单增就可以判断是否是二叉搜索树。
2.是设立一个pre，用来存放当前子树的最大值，在左子树的时候判断根节点是否大于这个值，若是大，则更新这个值，用于右子树的判断。若不大，则直接返回false。

面试题17.15
https://leetcode-cn.com/problems/longest-word-lcci/submissions/
1.分治法的例题。
2.auto是自动设置变量类型的关键字。
https://www.cnblogs.com/KunLunSu/p/7861330.html
3.获取字符串的部分使用substr()
https://www.cnblogs.com/xzxl/p/7243490.html

面试题16.10
https://leetcode-cn.com/problems/living-people-lcci/solution/c-qian-zhui-he-de-shi-yong-by-litoneo/
前缀和的应用，说白就是通过a[i]=s[i]-s[i-1];
获得每一个状态的具体的值。
这里有两个基本条件，
首先是之后的状态不影响之前的状态的值，同时在求i的值之前，前面的值全部都已经已知。
所以这样的题目都可以通过树状数组解决。
特别需要注意的是树状数组的下标从1开始，而不是从0开始。

面试题17.32 最大黑方阵
https://leetcode-cn.com/problems/max-black-square-lcci/
这里是原题
主要思想是动态规划，通过从右下角到左上角的枚举可以确定方阵的左上角的位置，然后通过添加第三维确定向右向下的最大长度。
这里是一个二维的问题，所以三维动态规划。
字符串类的是一维的问题，所以二维动态规划。
其他的类似累积的问题用一维就可以直接解决。
https://leetcode-cn.com/problems/maximal-rectangle/
https://leetcode-cn.com/problems/largest-rectangle-in-histogram/solution/zhu-zhuang-tu-zhong-zui-da-de-ju-xing-by-leetcode/
这是相关的两道题，这两道题相关。

面试题17.24
https://leetcode-cn.com/problems/max-submatrix-lcci/
这道题是最大子序列和的演变，从一维变到了二维，所以我们不仅可以升维，同样可以降维。

中等题库
二分答案法
https://blog.csdn.net/rigeman__ZHN/article/details/81637623

回溯
https://leetcode-cn.com/problems/power-set-lcci/

树状数组
https://leetcode-cn.com/problems/queries-on-a-permutation-with-key/
树状数组适用于求从前到后的差值的情况，计数可以在使用将对应的位置置1，其他置0来处理。

双向插入即双向队列 deque
https://leetcode-cn.com/problems/reveal-cards-in-increasing-order/

搜索范围特别大，所以需要换成检索障碍物。
1.整个过程是循环的，我们可以通过除法把最终终点转换到单一循环中。
2.我们可以将所有的障碍物设置为目标点，采取与终点同样的操作。
3.终点一定要过，障碍物一定不过。
https://leetcode-cn.com/problems/programmable-robot/solution/cpo-su-fang-an-4ms-by-mr_cai/

不使用相关运算符的加减乘除法。
加：
对每一位进行异或，异或又称半加，之后在逐位处理进位。
减：
对被减数取反加一（只是对int加上-，而已），然后就是加法。
乘：
将乘数位移.temp=被乘数。
如果乘数的最低位为1，就加上temp，然后temp<<1;
如果乘数的最低位为0，temp<<1，不必加上。
除：
在下述连接中有
https://leetcode-cn.com/problems/divide-two-integers/solution/zhi-xing-yong-shi-ji-bai-liao-10000-de-yong-hu-n-3/

倒叙法
https://leetcode-cn.com/problems/decoded-string-at-index/solution/xian-ji-suan-zi-chuan-zhan-kai-zong-chang-du-zai-y/

两例不易发现的二分法实例
https://leetcode-cn.com/problems/ugly-number-iii/
范围很大，如果直接查找找不出来，所以采取二分的方法。
前提是我们知道一个数为第几个丑数。
x/a是能被a整除的丑数的个数，对称的x/b是能被b整除的丑数的个数，x/c是能被c整除的丑数的个数.当然，直接加肯定不行，因为有重叠的，比如同时被ab整除。
所以number=x/a+x/b+x/c-x?ab-x/bc-x/ac+x/abc;
ab为ab的最小公倍数，abc为a,b,c的最小公倍数。

下界为0，上届为n*min(a,b,c)
在二分的时候，根据number二分。问题在于一个数可能不会被3个中的任何一个整除，我们可以通过-x%a,-x%b,-x%c来解决，当然我们希望调整的幅度较小，所以实际上减去的值为三者中的最小值。

https://leetcode-cn.com/problems/ju-qing-hong-fa-shi-jian/solution/c-er-fen-cha-zhao-gou-jian-shu-xing-di-zeng-xu-lie/
这里有两种想法，第一种是三个属性相互独立，我们拆成三个独立的属性，然后最后的结果为t=max(d(a),d(b),d©).
第二种想法，同样是二分法，直接考虑全部的属性。但不过二分的不是requires序列，因为这个是无序的。我们针对每一request 二分属性序列，然后修改对应的值。

https://leetcode-cn.com/problems/find-the-longest-substring-containing-vowels-in-even-counts/solution/mei-ge-yuan-yin-bao-han-ou-shu-ci-de-zui-chang-z-2/
前缀和的高级使用方式
前缀和加hashmap可以解决O(n^2)的时间复杂度。

https://leetcode-cn.com/problems/contains-duplicate-iii/solution/cfang-fa-xiao-zong-jie-by-rt-huang/
low_bound()函数的相关知识。
https://blog.csdn.net/sdz20172133/article/details/80101838
滑动窗口

单调栈
https://www.jianshu.com/p/6bbd3653a57f

char a[1000];
string s=a;
这样是可以的，可以使用string的函数，而不用被char束缚住。
https://www.cnblogs.com/houchen/p/8984164.html
sprintf,sscanf.

滑动窗口
https://zhuanlan.zhihu.com/p/61564531
https://blog.csdn.net/chinanfsk/article/details/95045048

单调栈
https://blog.csdn.net/qy724728631/article/details/82350682
https://zhuanlan.zhihu.com/p/26465701
https://blog.csdn.net/qq_17550379/article/details/86519771

状态转移
https://leetcode-cn.com/problems/swap-adjacent-in-lr-string/

当有一些范围，这些范围互相相交，问最多叠加了几层？
正确的做法是将区间进行拆分，拆成（起点，1）（终点，-1）。
然后按照时间点的先后进行排序，计算结果的累加值，累加值的最大为最大的叠加数。
https://leetcode-cn.com/problems/minimum-number-of-frogs-croaking/

topK

https://leetcode-cn.com/problems/top-k-frequent-elements/submissions/

差分数组
https://leetcode-cn.com/problems/minimum-moves-to-make-array-complementary/

https://blog.csdn.net/qq_44786250/article/details/100056975

回文数的生成
假设有一个回文串 XX，下一个回文串是什么？

每个 dd 长度的回文串都有一个回文根，回文根为前 $\frac{d+1}{2}$ ,则 $k = 2 d + 1$ 个数字。下一个回文串一定是由下一个回文根组成的。

举个例子，如果 123123 是 1232112321 的回文根，那么下一个回文串 1242112421 的回文根就是 124124。

需要注意一个回文根可能对应两个回文串，例如 123321123321，1232112321 的回文根就都是 123123。

知识点：
偶数长度的回文数”中只有11是素数，其他的都可以被11整除。

https://leetcode-cn.com/problems/prime-palindrome/solution/hui-wen-su-shu-by-leetcode/

前缀和+hash表
1：
https://leetcode-cn.com/problems/make-sum-divisible-by-p/submissions/
https://leetcode-cn.com/problems/subarray-sums-divisible-by-k/
2：
https://leetcode-cn.com/problems/minimum-operations-to-reduce-x-to-zero/

hash-map+min heap or greedy
https://leetcode-cn.com/problems/split-array-into-consecutive-subsequences/submissions/
堆heapq模块
https://blog.csdn.net/jamfiy/article/details/88185512
collections.defaultdict()的使用https://blog.csdn.net/yangsong95/article/details/82319675

bfs/DFS
这里需要注意的是，我们并不能使用动态规划，因为有向后移动的操作，在计算的时候，没有办法确定当前状态。
同时，作为BFS/DFS需要注意的问题是，如果前进到过某一点，在后退的时候，就不能再到这个点，否则是环路，可以整个舍去。
https://leetcode-cn.com/problems/minimum-jumps-to-reach-home/solution/python3-bfs-he-dfsjie-fa-by-captaintec/

贪心 + 二分查找
https://leetcode-cn.com/problems/sell-diminishing-valued-colored-balls/comments/

利用优先队列加速的迪杰斯特拉
这里加的负号是为了将优先队列反向
https://leetcode-cn.com/problems/path-with-maximum-probability

标准的处理模板，分析每一次操作的结果，只关心相关的部分（长度）。
https://leetcode-cn.com/problems/find-latest-group-of-size-m/solution/on-de-jie-jue-fang-fa-by-time-limit/

动态规划记录以当前位置结尾的，最长正书序列长度。
https://leetcode-cn.com/problems/maximum-length-of-subarray-with-positive-product/submissions/

DFS
这里我们只需要找到一条路径就可以了，并不需要找到全部的路径。当一个点完成遍历后，并不需要将其的flag复位，因为从这个点出发已经确定找不到对应的结果通路。
https://leetcode-cn.com/problems/word-transformer-lcci/submissions/

本题实际上即为：

将每个格子抽象成图中的一个点；

将每两个相邻的格子之间连接一条边，长度为这两个格子本身权值的差的绝对值；

需要找到一条从左上角到右下角的「最短路径」，其中路径的长度定义为路径上所有边的权值的最大值。

这也是一道比较经典的题目了，常用的方法有如下几种：

「二分答案」：我们可以对最短路径的长度进行二分。当我们二分枚举到的长度为 xx 时，我们只保留所有长度 \leq x≤x 的边。随后从左上角开始进行搜索（深度优先搜索、广度优先搜索）均可，只需要判断是否能够到达右下角即可。

如果能够到达右下角，我们就可以减小 xx 的值，反之增大 xx 的值。