语言细节 vector的长度：
C++：nums.size() Python：len(nums) GO：len(nums) 初始化数组：
C++：array[n]={0} 让所有元素都是0 构造vector:
C++：vector result(长度，元素) Python：res = [float('inf')] * len(nums) GO：=make([]int，n) for循环：
C++：条件小括号+循环体中括号 Python：冒号且不需要小括号包条件 GO：循环体中括号，条件按照C++写但是不需要小括号 数组 二分查找 题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1 2 3 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4
示例 2:
1 2 3 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量 规则
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution :def search (self, nums: List [int ], target: int ) -> int :0 , len (nums) - 1 while left <= right:2 if nums[middle] > target:1 elif nums[middle] < target:1 else :return middle return -1
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class Solution {public :int search (vector<int >& nums, int target) int left=0 ;int right=nums.size ()-1 ;while (left<=right)int middle = left + ((right - left) / 2 );if (nums[middle]>target)-1 ;else if (nums[middle]<target)1 ;else {return middle;return -1 ;
Go版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 func search (nums []int , target int ) int {len (nums)-1 0 for left<=right{2 if nums[middle]<target{1 else if nums[middle]>target{-1 else {return middlereturn -1
移除元素 https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1 2 3 输入：nums = , val = 3
示例 2：
1 2 3 输入：nums = [0,1,2,2 ,3,0,4,2 ], val = 2 5 , nums = [0,1,3,0 ,4 ]5 , 并且 nums 中的前五个元素为 0 , 1 , 3 , 0 , 4 。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组 慢指针：指向更新 新数组下标的位置
C++版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int removeElement (vector<int >& nums, int val) int slowindex=0 ;for (int fastindex = 0 ; fastindex<nums.size ();fastindex++)if (val!=nums[fastindex]){return slowindex;
python版本
1 2 3 4 5 6 7 8 9 10 class Solution (object ):def removeElement (self, nums, val ):0 0 while fastindex<len (nums):if val!=nums[fastindex]:1 1 return slowindex
GO版本：
1 2 3 4 5 6 7 8 9 10 func removeElement (nums []int , val int ) int {0 for i:=0 ;i<len (nums);i++{if nums[i]!=val{return slow
有序数组的平方 https://leetcode.cn/problems/squares-of-a-sorted-array/
题目描述
示例 1：
1 2 3 4 输入：nums = [-4 ,-1,0,3,10 ]0,1,9,16 ,100 ]16,1,0,9 ,100 ]0,1,9,16 ,100 ]
示例 2：
1 2 输入：nums = [-7 ,-3,2,3,11 ]4,9,9,49 ,121 ]
思路
双指针法，首尾遍历比较并存储
双指针遍历存储 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :vector<int > sortedSquares (vector<int >& nums) {vector<int > result (nums.size(),0 ) ;int j = nums.size ()-1 ;int k =j;for (int i = 0 ;i<=j;)if (nums[i]*nums[i]>nums[j]*nums[j]){else {return result;
Python:
1 2 3 4 5 6 7 8 9 10 11 12 class Solution (object ):def sortedSquares (self, nums ):0 , len (nums)-1 , len (nums)-1 float ('inf' )] * len (nums) while l<=r :if nums[l]*nums[l] < nums[r]*nums[r] :else :return
GO:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 func sortedSquares (nums []int ) int {len (nums)0 , n-1 , n-1 make ([]int , n)for i <= j {if lm > rm {else {return ans
长度最小的子数组 https://leetcode.cn/problems/minimum-size-subarray-sum/description/
题目描述
给定一个含有 n 个正整数的数组和一个正整数target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。 如果不存在符合条件的子数组，返回0 。
示例 1：
1 2 3 输入：target = 7, nums =
示例 2：
1 2 输入：target = 4 , nums = [1 ,4 ,4 ]1
示例 3：
1 2 输入：target = 11 , nums = [1,1,1,1 ,1,1,1,1 ]0
思路
滑动窗口法
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
窗口内是什么？ 如何移动窗口的起始位置？ 如何移动窗口的结束位置？ 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :int minSubArrayLen (int s, vector<int >& nums) int result = INT32_MAX;int sum = 0 ; int i = 0 ; int subLength = 0 ; for (int j = 0 ; j < nums.size (); j++) {while (sum >= s) {1 ); return result == INT32_MAX ? 0 : result;
螺旋矩阵 https://leetcode.cn/problems/spiral-matrix-ii/
题目描述
给你一个正整数 n ，生成一个包含 1 到n2 所有元素，且元素按顺时针顺序螺旋排列的n x n 正方形矩阵 matrix
1 2 输入：n = 3 [[1,2,3],[8,9,4],[7,6,5]]
示例 2：
思路：大模拟循环遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 class Solution {public :int >> generateMatrix (int n) {int >> result (n, vector <int >(n,0 ));int is=0 ,ie=n-1 ,js=0 ,je=n-1 ;int k = 1 ;while (is<=ie&&js<=je){for (int j=js;j<=je;j++)for (int i =is;i<=ie;i++)for (int j=je;j>=js;j--)for (int i=ie;i>=is;i--)return result;
哈希表 一般哈希表都是用来快速判断一个元素是否出现集合里
只需要初始化把所有元素都存在哈希表里，在查询的时候通过索引直接就可以知道元素在不在这哈希表里了
建立索引：哈希函数
有效的字母异位词 https://leetcode.cn/problems/valid-anagram/description/
题目描述
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
思路
暴力的方法可能时间复杂度会很高
判断有没有异位词的本质就是查看当前的字母是不是有出现过，那么思路就是选择哈希表
定义一个数组叫做record用来上记录字符串s里字符出现的次数。
需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {public :bool isAnagram (string s, string t) int record[26 ] = {0 };for (int i = 0 ; i < s.size (); i++) {'a' ]++;for (int i = 0 ; i < t.size (); i++) {'a' ]--;for (int i = 0 ; i < 26 ; i++) {if (record[i] != 0 ) {return false ;return true ;
两个数组的交集 https://leetcode.cn/problems/intersection-of-two-arrays/description/
题目描述
示例 1：
1 2 输入：nums1 = , nums2 =
示例 2：
1 2 3 输入：nums1 = , nums2 =
思路
使用哈希表存储，但是用set(unordered_set)
std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :vector<int > intersection (vector<int >& nums1, vector<int >& nums2) {int > result_set; unordered_set<int > nums_set (nums1.begin(), nums1.end()) ;for (int num : nums2) {if (nums_set.find (num) != nums_set.end ()) {insert (num);return vector <int >(result_set.begin (), result_set.end ());
快乐数 https://leetcode.cn/problems/happy-number/description/
题目描述
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true；不是，则返回 false 。
示例 1：
1 2 3 4 5 6 7 输入：n = 19true *2 + 9**2 = 82*2 + 2**2 = 68*2 + 8**2 = 100*2 + 0**2 + 0**2 = 1
思路：
注意，题目中提到一个点是无限循环 ，说明计算的结果sum是有限 的只需要在哈希表中将这部分的结果存储进去，并每次比较是不是出现1 如果是那么就是快乐数，否则就不是快乐数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 class Solution {public :int getSum (int n) int sum=0 ;while (n){10 )*(n%10 );10 ;return sum;bool isHappy (int n) int >sum_set;while (1 ){getSum (n);if (sum_set.find (n)!=sum_set.end ()){return false ;else {insert (n);if (n==1 ){return true ;
两数之和 题目描述
https://leetcode.cn/problems/two-sum/submissions/495021134/
给定一个整数数组 nums 和一个整数目标值target，请你在该数组中找出 和为目标值 target两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现 。
你可以按任意顺序返回答案。
示例 1：
1 2 3 输入：nums = , target = 9
示例 2：
1 2 输入：nums = , target = 6
示例 3：
1 2 输入：nums = , target = 6
思路：
构建一个哈希表，然后遍历一遍就行了在哈希表中找n-a的值是否存在，但是最大的问题是数组中同一个元素在答案里不能重复出现 ，所以不能简单考虑unordered_set
这里提供一种新的思路，就是用unordered_map来存储数组中的数据内容和下标的数值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :vector<int > twoSum (vector<int >& nums, int target) {int ,int > map;for (int i = 0 ; i < nums.size (); i++) {auto iter = map.find (target - nums[i]); if (iter != map.end ()) {return {iter->second, i};insert (pair <int , int >(nums[i], i)); return {};
四数相加 https://leetcode.cn/problems/4sum-ii/description/
给你四个整数数组nums1、nums2、nums3 和nums4 ，数组长度都是 n ，请你计算有多少个元组(i, j, k, l) 能满足：
0 <= i, j, k, l < nnums1[i] + nums2[j] + nums3[k] + nums4[l] == 0示例 1：
1 2 3 4 5 6 输入：nums1 = [1 ,2 ], nums2 = [-2 ,-1 ], nums3 = [-1 ,2 ], nums4 = [0 ,2 ]2 1. -> nums1 [0 ] + nums2 [0 ] + nums3 [0 ] + nums4 [1 ] = 1 + + + 2 = 0 2. -> nums1 [1 ] + nums2 [1 ] + nums3 [0 ] + nums4 [0 ] = 2 + + + 0 = 0
示例 2：
1 2 输入：nums1 = [0 ], nums2 = [0 ], nums3 = [0 ], nums4 = [0 ]1
思路
首先定义 一个unordered_map，key放a和b两数之和，value放a和b两数之和出现的次数 。 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。 在遍历大C和大D数组，找到如果 0-(c+d)在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。 最后返回统计值 count 就可以了 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Solution {public :int fourSumCount (vector<int >& nums1, vector<int >& nums2, vector<int >& nums3, vector<int >& nums4) int ,int >nm;int res=0 ;for (int i=0 ;i<nums1.size ();i++){for (int j=0 ;j<nums2.size ();j++){int s = nums1[i]+nums2[j];for (int i=0 ;i<nums3.size ();i++){for (int j=0 ;j<nums4.size ();j++){if (nm.find (0 -nums3[i]-nums4[j])!=nm.end ()){0 -(nums3[i]+nums4[j])];return res;
赎金信 https://leetcode.cn/problems/ransom-note/description/
给你两个字符串：ransomNote 和 magazine，判断 ransomNote 能不能由 magazine里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote中使用一次。
示例 1：
1 2 输入：ransomNote = "a" , magazine = "b" false
示例 2：
1 2 输入：ransomNote = "aa" , magazine = "ab" false
思路：
用哈希表unordered_map来存储次数，对于ransomNote来减去次数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :bool canConstruct (string ransomNote, string magazine) int ,int >umap;if (ransomNote.size ()>magazine.size ()){return false ;}for (int i=0 ;i<magazine.size ();i++){'a' ]++;for (int i=0 ;i<ransomNote.size ();i++){if (umap.find (ransomNote[i]-'a' )!=umap.end ()){'a' ]--;if (umap[ransomNote[i]-'a' ]<0 ) {return false ;}else {return false ;return true ;
三数之和 https://leetcode.cn/problems/3sum/description/
给你一个整数数组 nums ，判断是否存在三元组[nums[i], nums[j], nums[k]] 满足i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例 1：
1 2 3 4 5 6 7 输入：nums =
思路
其实这道题目使用哈希法并不十分合适 ，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码，而且使用哈希法在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)
这道题可以用双指针法求解
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left定义在i+1的位置上，定义下标right 在数组结尾的位置上 。
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a =nums[i]，b = nums[left]，c = nums[right]。
接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right]> 0 就说明此时三数之和大了 ，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
如果 nums[i] + nums[left] + nums[right] < 0 说明 此时三数之和小了，left就向右移动，才能让三数之和大一些，直到left与right相遇为止 。
还有一个难度就是不能有重复的结果，需要做一次去重的操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 class Solution {public :int >> threeSum (vector<int >& nums) {int >> result;sort (nums.begin (), nums.end ());for (int i = 0 ; i < nums.size (); i++) {if (nums[i] > 0 ) {return result;if (i > 0 && nums[i] == nums[i - 1 ]) {continue ;int left = i + 1 ;int right = nums.size () - 1 ;while (right > left) {if (nums[i] + nums[left] + nums[right] > 0 ) right--;else if (nums[i] + nums[left] + nums[right] < 0 ) left++;else {push_back (vector<int >{nums[i], nums[left], nums[right]});while (right > left && nums[right] == nums[right - 1 ]) right--;while (right > left && nums[left] == nums[left + 1 ]) left++;return result;
双指针 移除元素 https://leetcode.cn/problems/remove-element/description/
示例 1：
1 2 3 输入：nums = , val = 3
示例 2：
1 2 3 输入：nums = [0,1,2,2 ,3,0,4,2 ], val = 2 5 , nums = [0,1,3,0 ,4 ]5 , 并且 nums 中的前五个元素为 0 , 1 , 3 , 0 , 4 。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路：
使用快慢指针来实现两个指针之间的移动，对于找到了和val数值一样的就进行替换
反转字符串 https://leetcode.cn/problems/reverse-string/description/
示例 1：
1 2 输入：s = ["h" ,"e" ,"l" ,"l" ,"o" ]"o" ,"l" ,"l" ,"e" ,"h" ]
示例 2：
1 2 输入：s = ["H" ,"a" ,"n" ,"n" ,"a" ,"h" ]"h" ,"a" ,"n" ,"n" ,"a" ,"H" ]
思路：
采用两个指针之间互相交换，首尾交换
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :void reverseString (vector<char >& s) for (int a=0 , b = s.size ()-1 ;a<b;){char tmp;
反转字符串中的单词 https://leetcode.cn/problems/reverse-words-in-a-string/description/
示例 1：
1 2 输入：s = "the sky is blue" "blue is sky the"
示例 2：
1 2 3 输入：s = " hello world " "world hello"
示例 3：
1 2 3 输入：s = "a good example" "example good a"
思路：
首先对字符串中额外的空格进行删除
字符串进行全局的逆序
再根据空格作为一个单独字母的节点进行分格分别进行逆序
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 class Solution {public :string reverseWords (string s) {for (int i = s.size ()-1 ;i>0 ;i--){if (s[i]==s[i-1 ]&&s[i]==' ' ){erase (s.begin ()+i);if (s.size ()>0 &&s[s.size ()-1 ]==' ' ){erase (s.begin ()+s.size ()-1 );if (s.size ()>0 &&s[0 ]==' ' ){erase (s.begin ());for (int i = 0 , j=s.size ()-1 ;i<j;i++,j--){char tmp;int i=0 ;int j=1 ;while (j<=s.size ()){if (s[j]==' ' ||j==s.size ()){for (int k =i, q =j-1 ;k<q;k++,q--){char tmp;1 ;1 ;else {return s;
反转链表 https://leetcode.cn/problems/reverse-linked-list/description/
1 2 输入：head = [1,2,3,4,5] [5,4,3,2,1]
思路：本质上就是利用了两个链表指针实现对元素的转向
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :ListNode* reverseList (ListNode* head) {nullptr ;while (cur){return pre;
删除链表的倒数第N个结点 https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
1 2 输入：head = [1,2,3,4 ,5 ], n = 2 1,2,3,5 ]
示例 2：
思路：
遍历，用两个指针分别来记录
如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class Solution {public :ListNode* removeNthFromEnd (ListNode* head, int n) {new ListNode (0 );while (n-- && fast != NULL ) {while (fast != NULL ) {return dummyHead->next;
链表相交 给你两个单链表的头节点 headA 和 headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null 。
题目数据 保证 整个链式结构中不存在环。
注意 ，函数返回结果后，链表必须保持其原始结构 。
示例 1：
1 2 3 4 5 输入：intersectVal = 8 , listA = [4,1,8,4 ,5 ], listB = [5,0,1,8 ,4 ,5 ], skipA = 2 , skipB = 3 8 '8 （注意，如果两个链表相交则不能为 0 ）。A 为 [4,1,8,4 ,5 ]，链表 B 为 [5,0,1,8 ,4 ,5 ]。A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
思路：
简单来说，就是求两个链表交点节点的指针 ，注意返回的是结点的指针，不是对应的数值，同时注意这里比较的是相同的指针不是数值相同 ，因此直接比较指针是不是相同就可以了
由于题目说的相交的结构如图所示，如果存在相交的指针位置，只可能出现在后面只需要考虑利用双指针从相差的数值位开始遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 class Solution {public :ListNode *getIntersectionNode (ListNode *headA, ListNode *headB) {int lenA = 0 , lenB = 0 ;while (curA != NULL ){while (curB != NULL ){if (lenB> lenA){swap (lenA,lenB);swap (curA, curB);int gap = lenA - lenB;while (gap--){while (curA!=NULL ){if (curA == curB){return curA;return NULL ;
环形链表 https://leetcode.cn/problems/linked-list-cycle-ii/description/
判断是否是有还存在，如果有那么返回开始入环的第一个节点的下标
1 2 3 输入：head = [3,2,0,-4], pos = 1
思路：
这道题用快慢指针的思路，就是慢指针每次只走一步，快指针每次走两步，如果在到达null之前出现快慢指针指向了同一个地方，说明这个链表有环存在 ，那么怎么判断下标的位置呢？
具体的证明过程：
环形链表 相遇时slow指针走过的节点数为: x + y，fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为 一圈内节点的个数A。
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以fast指针走过的节点数 = slow指针走过的节点数 * 2：
1 (x + y) * 2 = x + y + n (y + z)
两边消掉一个（x+y）: x + y = n (y + z)
因为要找环形的入口，那么要求的是x，因为x表示 头结点到环形入口节点的的距离。
所以要求x ，将x单独放在左面：x = n (y + z) - y ,
再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z注意这里n一定是大于等于1的，因为fast指针至少要多走一圈才能相遇slow指针
所以可以得到的规律是：从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是 环形入口的节点
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Solution {public :ListNode *detectCycle (ListNode *head) {while (fast!=NULL && fast->next!=NULL ){if (slow==fast){while (index1!=index2){return index2;return NULL ;
二叉树 深搜回溯 深度优先搜索的三部曲：
确定搜索函数的返回值以及搜索函数的参数分别是什么 确定每次找到叶子结点的终止条件 确定for单层搜索的逻辑，包含push,backtracking,pop 别忘了最开始的初始化步骤
组合问题 https://leetcode.cn/problems/combinations/description/
给定两个整数 n 和 k，返回范围[1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
1 2 3 4 5 6 7 8 9 10 输入：n = 4, k = 2
示例 2：
1 2 输入：n = 1 , k = 1 [[1]]
思路，使用深度优先搜索算法进行处理
首先要区分private和public这两个部分分别做的内容，private主要就是写出回溯的函数主体并且可能需要的数据结构 public中就对函数进行跳用以及数据结构的使用 第一步就是确定函数的类型和返回，这里用了一个 startindex用来存储下一次进行选择的位置点这样能够避免重复 同时函数的返回类型是二位的向量结构 同时定义终止条件和单层循环的内容 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {private :int >> result;int >path;void backtracking (int n,int k, int startindex) if (path.size ()==k){push_back (path);return ;for (int i = startindex;i<=n;i++){push_back (i);backtracking (n,k,i+1 );pop_back ();public :int >> combine (int n, int k){backtracking (n,k,1 );return result;
组合问题III https://leetcode.cn/problems/combination-sum-iii/submissions/496823507/
思路：简单的深度优先搜索，但需要注意的是可以适当采用减枝操作和必要的时候添加sum变量进行记录
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Solution {private :int >> result;int > path;void backtacking (int k, int n,int startindex, int sum) if (path.size ()==k){if (sum == n) result.push_back (path);return ;for (int i= startindex;i<=9 ;i++){push_back (i);backtacking (k,n,i+1 ,sum);pop_back ();public :int >> combinationSum3 (int k, int n) {backtacking (k,n,1 ,0 );return result;
为了优化可以做一个剪枝操作
1 2 3 if (sum > targetSum) { return ;
电话号码组合问题 给定一个仅包含数字 2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1不对应任何字母。
示例 ：
1 2 输入：digits = "23" "ad" ,"ae" ,"af" ,"bd" ,"be" ,"bf" ,"cd" ,"ce" ,"cf" ]
这道题需要注意的地方是，首先第一步做好map字符的映射
第二步最关键是要写清楚回溯函数的参数可能包含index，就是第几位置的字符，同时需要区分backtracking函数的for循环的内容是相当于横向的遍历，而函数体内部的实现是纵向的遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 class Solution {private :const string letterMap[10 ] = {"" , "" , "abc" , "def" , "ghi" , "jkl" , "mno" , "pqrs" , "tuv" , "wxyz" , void backtracking (const string digits,int index, string s) if (digits.size ()==0 ){return ;if (index==digits.size ()){push_back (s);return ;int digit = digits[index]-'0' ;for (int i= 0 ;i<letters.size ();i++){push_back (letters[i]);backtracking (digits, index+1 , s);pop_back ();public :vector<string> letterCombinations (string digits) {backtracking (digits,0 ,"" );return result;
组合总和 https://leetcode.cn/problems/combination-sum/
给你一个 无重复元素 的整数数组candidates 和一个目标整数 target ，找出candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按任意顺序 返回这些组合。
candidates 中的 同一个 数字可以无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于150 个。
示例 ：
1 2 3 4 5 6 输入：candidates = [2,3,6,7], target = 7 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 = 7 。
思路：
题目最关键的点在于能重复使用元素但是不能重复元素的组合不能被重复输出
因此需要调整startindex的开始的位置是在backtracking(candidates,target,sum,i);注意，这个时候从i开始保证还能用到自己的元素重复使用，还有最重要的sort(candidates.begin(), candidates.end()); // 需要排序
排序之后能够很好的进行剪枝，将一些加了之后元素大于目标的删掉直接跳过
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 class Solution {public :int >> res;int > path;void backtracking (vector<int >&candidates, int target, int sum, int startindex) if (sum==target){push_back (path);return ;for (int i=startindex;i<candidates.size ();i++){if (sum>target){return ;push_back (candidates[i]);backtracking (candidates,target,sum,i);pop_back ();int >> combinationSum (vector<int >& candidates, int target) {sort (candidates.begin (), candidates.end ()); backtracking (candidates, target, 0 ,0 );return res;
组合总和II https://leetcode.cn/problems/combination-sum-ii/description/
给定一个候选人编号的集合 candidates 和一个目标数target ，找出 candidates 中所有可以使数字和为target 的组合。
candidates中的每个数字在每个组合中只能使用 一次 。
注意： 解集不能包含重复的组合。
示例 :
1 2 3 4 5 6 7 8 输入: candidates = , target = 8,
思路：
这个地方最大的困难在于每个数字在每个组合中只能使用一次，同时集合中的元素存在重复的元素，那么这个时候有一个问题是如何才能对元素进行去重处理 呢，就是让每个元素只能被使用一次
去重的操作就在于vector<bool> used(candidates.size(),false); sort(candidates.begin(), candidates.end());
首先需要在backtracking中定一个continue，这个地方是为了筛选不是重复的部分，那么如何区分开是否是同一个数组中重复的元素而不是重复利用的元素呢？
i>0&&candidates[i]==candidates[i-1]这个地方表明了对元素相邻之间进行比较used[i-1]==false如果这个地方是false，那么说明这个元素是同一层的元素(同一个数组中的元素)注意i<candidates.size()&&sum + candidates[i] <= target为了避免出现超出时间限制的情况 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Solution {public :int >> res;int > path;void backtracking (vector<int >& candidates, int target, int sum, int startindex, vector<bool >used) if (sum==target){push_back (path);return ;for (int i= startindex;i<candidates.size ();i++){if (i>0 &&candidates[i]==candidates[i-1 ]&&used[i-1 ]==false ){continue ;true ;push_back (candidates[i]);backtracking (candidates, target, sum, i+1 , used);false ;pop_back ();int >> combinationSum2 (vector<int >& candidates, int target) {vector<bool > used (candidates.size(),false ) ;sort (candidates.begin (), candidates.end ());backtracking (candidates, target, 0 , 0 , used);return res;
分割回文串 https://leetcode.cn/problems/palindrome-partitioning/description/
给你一个字符串 s，请你将 s分割成一些子串，使每个子串都是 回文串 。返回s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例：
1 2 输入：s = "aab" "a" ,"a" ,"b" ],["aa" ,"b" ]]
思路：
首先给出回文字符的判断方法：首尾指针来回比较 回溯算法中最关键的点在于startindex的使用，利用这个来移动s.substr(startindex, i-startindex+1)来截取并筛选出相应的字符串的值进行回文比较 回溯的终止条件是startindex>=s.size()如果超出了范围那么久说明到终点了 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 class Solution {public :bool ishuiwen (string s, int start, int end) for (int i = start,j = end;i<j;i++,j--){if (s[i]!=s[j]){return false ;return true ;void backtracking (string s, int startindex) if (startindex>=s.size ()){push_back (path);return ;for (int i=startindex;i<s.size ();i++){if (ishuiwen (s,startindex,i)){substr (startindex, i-startindex+1 );push_back (str);else {continue ;backtracking (s,i+1 );pop_back ();partition (string s) {backtracking (s,0 );return res;
复原IP地址 https://leetcode.cn/problems/restore-ip-addresses/description/
有效 IP 地址 正好由四个整数（每个整数位于0 到 255 之间组成，且不能含有前导0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和"192.168.1.1" 是有效 IP 地址，但是"0.011.255.245"、"192.168.1.312" 和"192.168@1.1" 是 无效 IP 地址。 给定一个只包含数字的字符串 s ，用以表示一个 IP地址，返回所有可能的有效 IP 地址 ，这些地址可以通过在s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按任何 顺序返回答案。
示例 ：
1 2 输入：s = "25525511135" "255.255.11.135" ,"255.255.111.35" ]
思路：
回溯三部曲第一步：如何确定函数的类型以及参数呢？首先参数肯定包含了s、开始的位置(因为要一直往后移动并选择)、以及一个标记用于是否已经有三个点 写好判断是否合法的函数，这里比较多的陷阱需要注意 注意，当放进去3个点之后别忘了判断最后一位是否满足合法性的要求，容易忽略最后一位的情况 注意字符串的插入 s.inset(n,'.') 和删除s.erase(n) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 class Solution {public :bool isvalid (string s, int start, int end) if (start>end){return false ;if (s[start]=='0' &&start!=end){return false ;int num = 0 ;for (int i=start;i<=end;i++){if (s[i] > '9' || s[i] < '0' ) { return false ;10 +(s[i]-'0' );if (num>255 ){return false ;return true ;void backtracking (string s, int startindex, int pointnum) if (pointnum==3 ){if (isvalid (s, startindex, s.size () - 1 )) {push_back (s);return ;for (int i=startindex;i<s.size ();i++){if (isvalid (s,startindex,i)){insert (s.begin ()+i+1 ,'.' );backtracking (s,i+2 ,pointnum);erase (s.begin ()+i+1 );else break ;vector<string> restoreIpAddresses (string s) {backtracking (s,0 ,0 );return res;
子集 https://leetcode.cn/problems/subsets/description/
给你一个整数数组 nums ，数组中的元素互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按任意顺序 返回解集。
示例：
思路：
这道题比较简单，就是简单的遍历就可以了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums,int startindex) push_back (path);for (int i=startindex;i<nums.size ();i++){push_back (nums[i]);backtracking (nums,i+1 );pop_back ();int >> subsets (vector<int >& nums) {backtracking (nums,0 );return res;
子集II https://leetcode.cn/problems/subsets-ii/description/
给你一个整数数组 nums，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按任意顺序 排列。
示例：
注意：
凡是涉及到去重的操作，都需要优先进行排序操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int > nums, int startindex, vector<bool > used) push_back (path);for (int i=startindex;i<nums.size ();i++){if (i>0 &&nums[i]==nums[i-1 ]&&used[i-1 ]==false ){continue ;push_back (nums[i]);true ;backtracking (nums,i+1 ,used);false ;pop_back ();int >> subsetsWithDup (vector<int >& nums) {vector<bool > used (nums.size(),false ) ;sort (nums.begin (), nums.end ()); backtracking (nums,0 ,used);return res;
非递减子序列 https://leetcode.cn/problems/non-decreasing-subsequences/description/
给你一个整数数组 nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素 。你可以按 任意顺序 返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
示例 1：
示例 2：
1 2 输入：nums = [4 ,4 ,3 ,2 ,1 ][[4,4]]
思路：
首先这道题不需要去重同时也不需要提前进行排序
但是需要对同一层的元素进行去重操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, int startindex) if (path.size ()>1 ){push_back (path);int > uset;for (int i =startindex;i<nums.size ();i++){if ((!path.empty () && nums[i] < path.back ())find (nums[i]) != uset.end ()) {continue ;insert (nums[i]);push_back (nums[i]);backtracking (nums,i+1 );pop_back ();int >> findSubsequences (vector<int >& nums) {backtracking (nums,0 );return res;
全排列 https://leetcode.cn/problems/permutations/description/
给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1：
示例 2：
1 2 输入：nums = [0 ,1 ][[0,1],[1,0]]
思路：
要求解全排列，因此回溯退出的条件是当path的长度和nums的长度一样 的时候就达到了退出的条件
因为这道题没有重复 的元素，求解全排列需要每次都从0开始选择，因此难点在于如何标记出已经选择过 的元素
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, vector<bool >& used) if (path.size ()==nums.size ()){push_back (path);for (int i=0 ;i<nums.size ();i++){if (used[i]==true ){continue ;push_back (nums[i]);true ;backtracking (nums,used);false ;pop_back ();int >> permute (vector<int >& nums) {vector<bool > used (nums.size(),false ) ;backtracking (nums,used);return res;
全排列II https://leetcode.cn/problems/permutations-ii/
给定一个可包含重复数字的序列 nums，按任意顺序
示例 1：
示例 2：
思路：
首先这个全排列有重复的元素，因此需要有去重的操作，既然涉及到去重那需要重新排序，同时需要跳过重复的元素
第二步，既然是全排列，那么需要标记重复选择的元素并选择跳过
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, vector<bool >& used) if (path.size ()==nums.size ()){push_back (path);return ;for (int i=0 ;i<nums.size ();i++){if (i>0 &&nums[i]==nums[i-1 ]&&used[i-1 ]==false ){continue ;if (used[i]==false ){true ;push_back (nums[i]);backtracking (nums, used);pop_back ();false ;int >> permuteUnique (vector<int >& nums) {sort (nums.begin (),nums.end ());vector<bool > used (nums.size(),false ) ;backtracking (nums,used);return res;
重新安排行程 https://leetcode.cn/problems/reconstruct-itinerary/description/
给你一份航线列表 tickets ，其中tickets[i] = [fromi, toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
例如，行程 ["JFK", "LGA"] 与["JFK", "LGB"] 相比就更小，排序更靠前。
思路：
【困难】
首先第一步：确定终止条件，遇到的机场个数，如果达到了（航班数量+1）
记录航班的数量，使用unordered_map<string, map<string, int>> targets;来记录航班的映射关系，我定义为全局变量。
当然把参数放进函数里传进去也是可以的，我是尽量控制函数里参数的长度。参数里还需要ticketNum，表示有多少个航班
回溯的过程中，如何遍历一个机场所对应的所有机场呢？
这里刚刚说过，在选择映射函数的时候，不能选择unordered_map<string, multiset<string>> targets，因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不在讨论了。
可以说本题既要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效 。
所以我选择了unordered_map<string, map<string, int>> targets来做机场之间的映射
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 class Solution {public :int >> targets;bool backtracking (int ticketnum, vector<string>& res) if (res.size ()==ticketnum+1 ){return true ;for (pair<const string, int >& target: targets[res[res.size ()-1 ]]){if (target.second>0 ){push_back (target.first);if (backtracking (ticketnum, res)) return true ;pop_back ();return false ;vector<string> findItinerary (vector<vector<string>>& tickets) {for (const vector<string>& vec: tickets){0 ]][vec[1 ]]++;push_back ("JFK" );backtracking (tickets.size (), res);return res;
N皇后 https://leetcode.cn/problems/n-queens/description/
n 皇后问题 研究的是如何将 n个皇后放置在 n×n的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.'分别代表了皇后和空位。
1 2 3 输入：n = 4 ".Q.." ,"...Q" ,"Q..." ,"..Q." ],["..Q." ,"Q..." ,"...Q" ,".Q.." ]]4 皇后问题存在两个不同的解法。
思路：
这道题关键在于用好数据结构 和写好合法性的判断
关键在于定义好chessboard第二步是把合法性位置判断写好
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 class Solution {public :bool isvalid (int row, int col, vector<string>& chessboard,int n) for (int j=0 ;j<n;j++){if (chessboard[row][j]=='Q' ) return false ;for (int i=0 ;i<n;i++){if (chessboard[i][col]=='Q' ) return false ;for (int i = row - 1 , j = col - 1 ; i >=0 && j >= 0 ; i--, j--) {if (chessboard[i][j] == 'Q' ) {return false ;for (int i = row-1 ,j=col+1 ;i>=0 &&j<n;i--,j++){if (chessboard[i][j]=='Q' ){return false ;return true ;void backtracking (vector<string>& chessboard, int row, int n) if (row==n)push_back (chessboard);return ;for (int col = 0 ;col<n;col++){if (isvalid (row,col,chessboard,n)){'Q' ;backtracking (chessboard,row+1 ,n);'.' ;solveNQueens (int n) {std::vector<std::string> chessboard (n, std::string(n, '.' )) ;backtracking (chessboard,0 ,n);return res;
解数独 编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则 ：
数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 '.' 表示。
1 2 输入：board = [["5" ,"3" ,"." ,"." ,"7" ,"." ,"." ,"." ,"." ],["6" ,"." ,"." ,"1" ,"9" ,"5" ,"." ,"." ,"." ],["." ,"9" ,"8" ,"." ,"." ,"." ,"." ,"6" ,"." ],["8" ,"." ,"." ,"." ,"6" ,"." ,"." ,"." ,"3" ],["4" ,"." ,"." ,"8" ,"." ,"3" ,"." ,"." ,"1" ],["7" ,"." ,"." ,"." ,"2" ,"." ,"." ,"." ,"6" ],["." ,"6" ,"." ,"." ,"." ,"." ,"2" ,"8" ,"." ],["." ,"." ,"." ,"4" ,"1" ,"9" ,"." ,"." ,"5" ],["." ,"." ,"." ,"." ,"8" ,"." ,"." ,"7" ,"9" ]]"5" ,"3" ,"4" ,"6" ,"7" ,"8" ,"9" ,"1" ,"2" ],["6" ,"7" ,"2" ,"1" ,"9" ,"5" ,"3" ,"4" ,"8" ],["1" ,"9" ,"8" ,"3" ,"4" ,"2" ,"5" ,"6" ,"7" ],["8" ,"5" ,"9" ,"7" ,"6" ,"1" ,"4" ,"2" ,"3" ],["4" ,"2" ,"6" ,"8" ,"5" ,"3" ,"7" ,"9" ,"1" ],["7" ,"1" ,"3" ,"9" ,"2" ,"4" ,"8" ,"5" ,"6" ],["9" ,"6" ,"1" ,"5" ,"3" ,"7" ,"2" ,"8" ,"4" ],["2" ,"8" ,"7" ,"4" ,"1" ,"9" ,"6" ,"3" ,"5" ],["3" ,"4" ,"5" ,"2" ,"8" ,"6" ,"1" ,"7" ,"9" ]]
思路：
深度优先搜索，加上合法性判断
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 class Solution {public :bool isvalid (vector<vector<char >>& board, int row, int col, char a) for (int j=0 ;j<9 ;j++){if (board[row][j]==a) return false ;for (int i=0 ;i<9 ;i++){if (board[i][col]==a) return false ;for (int i= (row/3 )*3 ;i<(row/3 )*3 +3 ;i++){for (int j=(col/3 )*3 ; j<(col/3 )*3 +3 ;j++){if (board[i][j]==a) return false ;return true ;bool backtracking (vector<vector<char >>& board) for (int i=0 ;i<board.size ();i++){for (int j=0 ;j<board[0 ].size ();j++){if (board[i][j]=='.' ){for (char a='1' ;a<='9' ;a++){if (isvalid (board,i,j,a)){if (backtracking (board)) return true ;'.' ;return false ;return true ;void solveSudoku (vector<vector<char >>& board) backtracking (board);
贪心算法 分发饼干 https://leetcode.cn/problems/assign-cookies/description/
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸 s[j] 。如果s[j] >= g[i]，我们可以将这个饼干 j分配给孩子 i，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例 :
1 2 3 4 5 6 输入: g = [1,2,3], s = [1,1] 输出: 1 解释:
示例 :
1 2 3 4 5 6 输入: g = [1,2], s = [1,2,3] 输出: 2 解释:
思路：
这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩 。
可以尝试使用贪心策略，先将饼干数组和小孩数组排序。
然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :int findContentChildren (vector<int >& g, vector<int >& s) sort (s.begin (),s.end ());sort (g.begin (),g.end ());int index=s.size ()-1 ;int num= 0 ;for (int i=g.size ()-1 ; i>=0 ;i--){if (index>=0 &&s[index]>=g[i]){return num;
摆动序列 https://leetcode.cn/problems/wiggle-subsequence/description/
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。 第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
例如， [1, 7, 4, 9, 2, 5] 是一个摆动序列 ，因为差值 (6, -3, 5, -7, 3)是正负交替出现的。 给你一个整数数组 nums ，返回 nums 中作为摆动序列 的 最长子序列的长度
示例 ：
1 2 3 输入：nums = [1,7,4,9,2,5]-3 , 5, -7 , 3)
1 2 3 4 输入：nums = [1,17,5,10,13,15,10,5,16,8]-7 , 3, -3 , 6, -8 )
思路：
本题异常情况的本质，就是要考虑平坡 ，平坡分两种，一个是 上下中间有平坡，一个是单调有平坡，如图
同时需要注意的是在判断条件语句的时候，不能简单的用判断相乘法小于0作为判断，因为存在平坡的情况
异常情况需要考虑 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {public :int wiggleMaxLength (vector<int >& nums) if (nums.size ()<=1 ){return nums.size ();int num=1 ;int > differ;for (int i=1 ;i<nums.size ();i++){push_back (nums[i]-nums[i-1 ]);int preDiff=0 ;for (int i=0 ;i<differ.size ();i++){if ((preDiff<=0 && differ[i]>0 )||(differ[i]<0 &&preDiff>=0 )){return num;
最大子数组和 https://leetcode.cn/problems/maximum-subarray/description/
给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例：
1 2 3 输入：nums = [-2 ,1,-3 ,4,-1 ,2,1,-5 ,4]-1 ,2,1] 的和最大，为 6 。
思路：
这道题使用的是局部的最优贪心的思路，如果遇到让总的值小于0，那么久立刻让总的值变成0，那么下一轮就从头开始记了，同时max会每一轮进行判断是否有比当前的最大值大，如果有那么就进行替换
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :int maxSubArray (vector<int >& nums) int res = INT32_MIN;int count = 0 ;for (int i=0 ;i<nums.size ();i++){if (count>res){if (count<=0 ) count = 0 ;return res;
买卖股票的最佳时机 https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/
给你一个整数数组 prices ，其中 prices[i]表示某支股票第 i天的价格。在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
1 2 3 4 5 输入：prices = [7,1,5,3,6,4] 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。 4 + 3 = 7 。
思路：
把利润分解为每天为单位的维度，而不是从 0 天到第 3天整体去考虑！
那么根据 prices可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])
相当于是每天的利润之差和0的比较，只选择为正的值，负数的情况直接忽略
1 2 3 4 5 6 7 8 9 10 class Solution {public :int maxProfit (vector<int >& prices) int res = 0 ;for (int i=1 ;i<prices.size ();i++){max (prices[i]-prices[i-1 ],0 );return res;
动态规划 ]]>语言细节 vector的长度：
C++：nums.size() Python：len(nums) GO：len(nums) 初始化数组：
C++：array[n]={0} 让所有元素都是0 构造vector:
C++：vector result(长度，元素) Python：res = [float('inf')] * len(nums) GO：=make([]int，n) for循环：
C++：条件小括号+循环体中括号 Python：冒号且不需要小括号包条件 GO：循环体中括号，条件按照C++写但是不需要小括号 数组 二分查找 题目描述
链接：https://leetcode.cn/problems/binary-search/description/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回-1。
示例 1:
1 2 3 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4
示例 2:
1 2 3 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解释: 2 不存在 nums 中因此返回 -1
思路
题目表示的是有序数组，而且题目没有重复元素。在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量 规则
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution :def search (self, nums: List [int ], target: int ) -> int :0 , len (nums) - 1 while left <= right:2 if nums[middle] > target:1 elif nums[middle] < target:1 else :return middle return -1
注意这里给出的题解法：当left <= right的时候，以下的条件中全部都不取到等号nums[middle] > target nums[middle] < target
需要注意的是：right=nums.size()-1
C++版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class Solution {public :int search (vector<int >& nums, int target) int left=0 ;int right=nums.size ()-1 ;while (left<=right)int middle = left + ((right - left) / 2 );if (nums[middle]>target)-1 ;else if (nums[middle]<target)1 ;else {return middle;return -1 ;
Go版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 func search (nums []int , target int ) int {len (nums)-1 0 for left<=right{2 if nums[middle]<target{1 else if nums[middle]>target{-1 else {return middlereturn -1
移除元素 https://leetcode.cn/problems/remove-element/description/
题目描述
示例 1：
1 2 3 输入：nums = , val = 3
示例 2：
1 2 3 输入：nums = [0,1,2,2 ,3,0,4,2 ], val = 2 5 , nums = [0,1,3,0 ,4 ]5 , 并且 nums 中的前五个元素为 0 , 1 , 3 , 0 , 4 。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
定义快慢指针
快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组 慢指针：指向更新 新数组下标的位置
C++版本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int removeElement (vector<int >& nums, int val) int slowindex=0 ;for (int fastindex = 0 ; fastindex<nums.size ();fastindex++)if (val!=nums[fastindex]){return slowindex;
python版本
1 2 3 4 5 6 7 8 9 10 class Solution (object ):def removeElement (self, nums, val ):0 0 while fastindex<len (nums):if val!=nums[fastindex]:1 1 return slowindex
GO版本：
1 2 3 4 5 6 7 8 9 10 func removeElement (nums []int , val int ) int {0 for i:=0 ;i<len (nums);i++{if nums[i]!=val{return slow
有序数组的平方 https://leetcode.cn/problems/squares-of-a-sorted-array/
题目描述
示例 1：
1 2 3 4 输入：nums = [-4 ,-1,0,3,10 ]0,1,9,16 ,100 ]16,1,0,9 ,100 ]0,1,9,16 ,100 ]
示例 2：
1 2 输入：nums = [-7 ,-3,2,3,11 ]4,9,9,49 ,121 ]
思路
双指针法，首尾遍历比较并存储
双指针遍历存储 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :vector<int > sortedSquares (vector<int >& nums) {vector<int > result (nums.size(),0 ) ;int j = nums.size ()-1 ;int k =j;for (int i = 0 ;i<=j;)if (nums[i]*nums[i]>nums[j]*nums[j]){else {return result;
Python:
1 2 3 4 5 6 7 8 9 10 11 12 class Solution (object ):def sortedSquares (self, nums ):0 , len (nums)-1 , len (nums)-1 float ('inf' )] * len (nums) while l<=r :if nums[l]*nums[l] < nums[r]*nums[r] :else :return
GO:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 func sortedSquares (nums []int ) int {len (nums)0 , n-1 , n-1 make ([]int , n)for i <= j {if lm > rm {else {return ans
长度最小的子数组 https://leetcode.cn/problems/minimum-size-subarray-sum/description/
题目描述
给定一个含有 n 个正整数的数组和一个正整数target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]，并返回其长度。 如果不存在符合条件的子数组，返回0 。
示例 1：
1 2 3 输入：target = 7, nums =
示例 2：
1 2 输入：target = 4 , nums = [1 ,4 ,4 ]1
示例 3：
1 2 输入：target = 11 , nums = [1,1,1,1 ,1,1,1,1 ]0
思路
滑动窗口法
滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动本题中实现滑动窗口，主要确定如下三点：
窗口内是什么？ 如何移动窗口的起始位置？ 如何移动窗口的结束位置？ 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :int minSubArrayLen (int s, vector<int >& nums) int result = INT32_MAX;int sum = 0 ; int i = 0 ; int subLength = 0 ; for (int j = 0 ; j < nums.size (); j++) {while (sum >= s) {1 ); return result == INT32_MAX ? 0 : result;
螺旋矩阵 https://leetcode.cn/problems/spiral-matrix-ii/
题目描述
给你一个正整数 n ，生成一个包含 1 到n2 所有元素，且元素按顺时针顺序螺旋排列的n x n 正方形矩阵 matrix
1 2 输入：n = 3 [[1,2,3],[8,9,4],[7,6,5]]
示例 2：
思路：大模拟循环遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 class Solution {public :int >> generateMatrix (int n) {int >> result (n, vector <int >(n,0 ));int is=0 ,ie=n-1 ,js=0 ,je=n-1 ;int k = 1 ;while (is<=ie&&js<=je){for (int j=js;j<=je;j++)for (int i =is;i<=ie;i++)for (int j=je;j>=js;j--)for (int i=ie;i>=is;i--)return result;
哈希表 一般哈希表都是用来快速判断一个元素是否出现集合里
只需要初始化把所有元素都存在哈希表里，在查询的时候通过索引直接就可以知道元素在不在这哈希表里了
建立索引：哈希函数
有效的字母异位词 https://leetcode.cn/problems/valid-anagram/description/
题目描述
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
思路
暴力的方法可能时间复杂度会很高
判断有没有异位词的本质就是查看当前的字母是不是有出现过，那么思路就是选择哈希表
定义一个数组叫做record用来上记录字符串s里字符出现的次数。
需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {public :bool isAnagram (string s, string t) int record[26 ] = {0 };for (int i = 0 ; i < s.size (); i++) {'a' ]++;for (int i = 0 ; i < t.size (); i++) {'a' ]--;for (int i = 0 ; i < 26 ; i++) {if (record[i] != 0 ) {return false ;return true ;
两个数组的交集 https://leetcode.cn/problems/intersection-of-two-arrays/description/
题目描述
示例 1：
1 2 输入：nums1 = , nums2 =
示例 2：
1 2 3 输入：nums1 = , nums2 =
思路
使用哈希表存储，但是用set(unordered_set)
std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :vector<int > intersection (vector<int >& nums1, vector<int >& nums2) {int > result_set; unordered_set<int > nums_set (nums1.begin(), nums1.end()) ;for (int num : nums2) {if (nums_set.find (num) != nums_set.end ()) {insert (num);return vector <int >(result_set.begin (), result_set.end ());
快乐数 https://leetcode.cn/problems/happy-number/description/
题目描述
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1，那么这个数就是快乐数。 如果 n 是 快乐数 就返回 true；不是，则返回 false 。
示例 1：
1 2 3 4 5 6 7 输入：n = 19true *2 + 9**2 = 82*2 + 2**2 = 68*2 + 8**2 = 100*2 + 0**2 + 0**2 = 1
思路：
注意，题目中提到一个点是无限循环 ，说明计算的结果sum是有限 的只需要在哈希表中将这部分的结果存储进去，并每次比较是不是出现1 如果是那么就是快乐数，否则就不是快乐数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 class Solution {public :int getSum (int n) int sum=0 ;while (n){10 )*(n%10 );10 ;return sum;bool isHappy (int n) int >sum_set;while (1 ){getSum (n);if (sum_set.find (n)!=sum_set.end ()){return false ;else {insert (n);if (n==1 ){return true ;
两数之和 题目描述
https://leetcode.cn/problems/two-sum/submissions/495021134/
给定一个整数数组 nums 和一个整数目标值target，请你在该数组中找出 和为目标值 target两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现 。
你可以按任意顺序返回答案。
示例 1：
1 2 3 输入：nums = , target = 9
示例 2：
1 2 输入：nums = , target = 6
示例 3：
1 2 输入：nums = , target = 6
思路：
构建一个哈希表，然后遍历一遍就行了在哈希表中找n-a的值是否存在，但是最大的问题是数组中同一个元素在答案里不能重复出现 ，所以不能简单考虑unordered_set
这里提供一种新的思路，就是用unordered_map来存储数组中的数据内容和下标的数值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :vector<int > twoSum (vector<int >& nums, int target) {int ,int > map;for (int i = 0 ; i < nums.size (); i++) {auto iter = map.find (target - nums[i]); if (iter != map.end ()) {return {iter->second, i};insert (pair <int , int >(nums[i], i)); return {};
四数相加 https://leetcode.cn/problems/4sum-ii/description/
给你四个整数数组nums1、nums2、nums3 和nums4 ，数组长度都是 n ，请你计算有多少个元组(i, j, k, l) 能满足：
0 <= i, j, k, l < nnums1[i] + nums2[j] + nums3[k] + nums4[l] == 0示例 1：
1 2 3 4 5 6 输入：nums1 = [1 ,2 ], nums2 = [-2 ,-1 ], nums3 = [-1 ,2 ], nums4 = [0 ,2 ]2 1. -> nums1 [0 ] + nums2 [0 ] + nums3 [0 ] + nums4 [1 ] = 1 + + + 2 = 0 2. -> nums1 [1 ] + nums2 [1 ] + nums3 [0 ] + nums4 [0 ] = 2 + + + 0 = 0
示例 2：
1 2 输入：nums1 = [0 ], nums2 = [0 ], nums3 = [0 ], nums4 = [0 ]1
思路
首先定义 一个unordered_map，key放a和b两数之和，value放a和b两数之和出现的次数 。 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。 在遍历大C和大D数组，找到如果 0-(c+d)在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。 最后返回统计值 count 就可以了 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Solution {public :int fourSumCount (vector<int >& nums1, vector<int >& nums2, vector<int >& nums3, vector<int >& nums4) int ,int >nm;int res=0 ;for (int i=0 ;i<nums1.size ();i++){for (int j=0 ;j<nums2.size ();j++){int s = nums1[i]+nums2[j];for (int i=0 ;i<nums3.size ();i++){for (int j=0 ;j<nums4.size ();j++){if (nm.find (0 -nums3[i]-nums4[j])!=nm.end ()){0 -(nums3[i]+nums4[j])];return res;
赎金信 https://leetcode.cn/problems/ransom-note/description/
给你两个字符串：ransomNote 和 magazine，判断 ransomNote 能不能由 magazine里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote中使用一次。
示例 1：
1 2 输入：ransomNote = "a" , magazine = "b" false
示例 2：
1 2 输入：ransomNote = "aa" , magazine = "ab" false
思路：
用哈希表unordered_map来存储次数，对于ransomNote来减去次数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :bool canConstruct (string ransomNote, string magazine) int ,int >umap;if (ransomNote.size ()>magazine.size ()){return false ;}for (int i=0 ;i<magazine.size ();i++){'a' ]++;for (int i=0 ;i<ransomNote.size ();i++){if (umap.find (ransomNote[i]-'a' )!=umap.end ()){'a' ]--;if (umap[ransomNote[i]-'a' ]<0 ) {return false ;}else {return false ;return true ;
三数之和 https://leetcode.cn/problems/3sum/description/
给你一个整数数组 nums ，判断是否存在三元组[nums[i], nums[j], nums[k]] 满足i != j、i != k 且 j != k，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意： 答案中不可以包含重复的三元组。
示例 1：
1 2 3 4 5 6 7 输入：nums =
思路
其实这道题目使用哈希法并不十分合适 ，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码，而且使用哈希法在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)
这道题可以用双指针法求解
拿这个nums数组来举例，首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left定义在i+1的位置上，定义下标right 在数组结尾的位置上 。
依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a =nums[i]，b = nums[left]，c = nums[right]。
接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right]> 0 就说明此时三数之和大了 ，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
如果 nums[i] + nums[left] + nums[right] < 0 说明 此时三数之和小了，left就向右移动，才能让三数之和大一些，直到left与right相遇为止 。
还有一个难度就是不能有重复的结果，需要做一次去重的操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 class Solution {public :int >> threeSum (vector<int >& nums) {int >> result;sort (nums.begin (), nums.end ());for (int i = 0 ; i < nums.size (); i++) {if (nums[i] > 0 ) {return result;if (i > 0 && nums[i] == nums[i - 1 ]) {continue ;int left = i + 1 ;int right = nums.size () - 1 ;while (right > left) {if (nums[i] + nums[left] + nums[right] > 0 ) right--;else if (nums[i] + nums[left] + nums[right] < 0 ) left++;else {push_back (vector<int >{nums[i], nums[left], nums[right]});while (right > left && nums[right] == nums[right - 1 ]) right--;while (right > left && nums[left] == nums[left + 1 ]) left++;return result;
双指针 移除元素 https://leetcode.cn/problems/remove-element/description/
示例 1：
1 2 3 输入：nums = , val = 3
示例 2：
1 2 3 输入：nums = [0,1,2,2 ,3,0,4,2 ], val = 2 5 , nums = [0,1,3,0 ,4 ]5 , 并且 nums 中的前五个元素为 0 , 1 , 3 , 0 , 4 。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
思路：
使用快慢指针来实现两个指针之间的移动，对于找到了和val数值一样的就进行替换
反转字符串 https://leetcode.cn/problems/reverse-string/description/
示例 1：
1 2 输入：s = ["h" ,"e" ,"l" ,"l" ,"o" ]"o" ,"l" ,"l" ,"e" ,"h" ]
示例 2：
1 2 输入：s = ["H" ,"a" ,"n" ,"n" ,"a" ,"h" ]"h" ,"a" ,"n" ,"n" ,"a" ,"H" ]
思路：
采用两个指针之间互相交换，首尾交换
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :void reverseString (vector<char >& s) for (int a=0 , b = s.size ()-1 ;a<b;){char tmp;
反转字符串中的单词 https://leetcode.cn/problems/reverse-words-in-a-string/description/
示例 1：
1 2 输入：s = "the sky is blue" "blue is sky the"
示例 2：
1 2 3 输入：s = " hello world " "world hello"
示例 3：
1 2 3 输入：s = "a good example" "example good a"
思路：
首先对字符串中额外的空格进行删除
字符串进行全局的逆序
再根据空格作为一个单独字母的节点进行分格分别进行逆序
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 class Solution {public :string reverseWords (string s) {for (int i = s.size ()-1 ;i>0 ;i--){if (s[i]==s[i-1 ]&&s[i]==' ' ){erase (s.begin ()+i);if (s.size ()>0 &&s[s.size ()-1 ]==' ' ){erase (s.begin ()+s.size ()-1 );if (s.size ()>0 &&s[0 ]==' ' ){erase (s.begin ());for (int i = 0 , j=s.size ()-1 ;i<j;i++,j--){char tmp;int i=0 ;int j=1 ;while (j<=s.size ()){if (s[j]==' ' ||j==s.size ()){for (int k =i, q =j-1 ;k<q;k++,q--){char tmp;1 ;1 ;else {return s;
反转链表 https://leetcode.cn/problems/reverse-linked-list/description/
1 2 输入：head = [1,2,3,4,5] [5,4,3,2,1]
思路：本质上就是利用了两个链表指针实现对元素的转向
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :ListNode* reverseList (ListNode* head) {nullptr ;while (cur){return pre;
删除链表的倒数第N个结点 https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
1 2 输入：head = [1,2,3,4 ,5 ], n = 2 1,2,3,5 ]
示例 2：
思路：
遍历，用两个指针分别来记录
如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 class Solution {public :ListNode* removeNthFromEnd (ListNode* head, int n) {new ListNode (0 );while (n-- && fast != NULL ) {while (fast != NULL ) {return dummyHead->next;
链表相交 给你两个单链表的头节点 headA 和 headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null 。
题目数据 保证 整个链式结构中不存在环。
注意 ，函数返回结果后，链表必须保持其原始结构 。
示例 1：
1 2 3 4 5 输入：intersectVal = 8 , listA = [4,1,8,4 ,5 ], listB = [5,0,1,8 ,4 ,5 ], skipA = 2 , skipB = 3 8 '8 （注意，如果两个链表相交则不能为 0 ）。A 为 [4,1,8,4 ,5 ]，链表 B 为 [5,0,1,8 ,4 ,5 ]。A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
思路：
简单来说，就是求两个链表交点节点的指针 ，注意返回的是结点的指针，不是对应的数值，同时注意这里比较的是相同的指针不是数值相同 ，因此直接比较指针是不是相同就可以了
由于题目说的相交的结构如图所示，如果存在相交的指针位置，只可能出现在后面只需要考虑利用双指针从相差的数值位开始遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 class Solution {public :ListNode *getIntersectionNode (ListNode *headA, ListNode *headB) {int lenA = 0 , lenB = 0 ;while (curA != NULL ){while (curB != NULL ){if (lenB> lenA){swap (lenA,lenB);swap (curA, curB);int gap = lenA - lenB;while (gap--){while (curA!=NULL ){if (curA == curB){return curA;return NULL ;
环形链表 https://leetcode.cn/problems/linked-list-cycle-ii/description/
判断是否是有还存在，如果有那么返回开始入环的第一个节点的下标
1 2 3 输入：head = [3,2,0,-4], pos = 1
思路：
这道题用快慢指针的思路，就是慢指针每次只走一步，快指针每次走两步，如果在到达null之前出现快慢指针指向了同一个地方，说明这个链表有环存在 ，那么怎么判断下标的位置呢？
具体的证明过程：
环形链表 相遇时slow指针走过的节点数为: x + y，fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为 一圈内节点的个数A。
因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以fast指针走过的节点数 = slow指针走过的节点数 * 2：
1 (x + y) * 2 = x + y + n (y + z)
两边消掉一个（x+y）: x + y = n (y + z)
因为要找环形的入口，那么要求的是x，因为x表示 头结点到环形入口节点的的距离。
所以要求x ，将x单独放在左面：x = n (y + z) - y ,
再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z注意这里n一定是大于等于1的，因为fast指针至少要多走一圈才能相遇slow指针
所以可以得到的规律是：从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是 环形入口的节点
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 class Solution {public :ListNode *detectCycle (ListNode *head) {while (fast!=NULL && fast->next!=NULL ){if (slow==fast){while (index1!=index2){return index2;return NULL ;
二叉树 深搜回溯 深度优先搜索的三部曲：
确定搜索函数的返回值以及搜索函数的参数分别是什么 确定每次找到叶子结点的终止条件 确定for单层搜索的逻辑，包含push,backtracking,pop 别忘了最开始的初始化步骤
组合问题 https://leetcode.cn/problems/combinations/description/
给定两个整数 n 和 k，返回范围[1, n] 中所有可能的 k 个数的组合。
你可以按 任何顺序 返回答案。
示例 1：
1 2 3 4 5 6 7 8 9 10 输入：n = 4, k = 2
示例 2：
1 2 输入：n = 1 , k = 1 [[1]]
思路，使用深度优先搜索算法进行处理
首先要区分private和public这两个部分分别做的内容，private主要就是写出回溯的函数主体并且可能需要的数据结构 public中就对函数进行跳用以及数据结构的使用 第一步就是确定函数的类型和返回，这里用了一个 startindex用来存储下一次进行选择的位置点这样能够避免重复 同时函数的返回类型是二位的向量结构 同时定义终止条件和单层循环的内容 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {private :int >> result;int >path;void backtracking (int n,int k, int startindex) if (path.size ()==k){push_back (path);return ;for (int i = startindex;i<=n;i++){push_back (i);backtracking (n,k,i+1 );pop_back ();public :int >> combine (int n, int k){backtracking (n,k,1 );return result;
组合问题III https://leetcode.cn/problems/combination-sum-iii/submissions/496823507/
思路：简单的深度优先搜索，但需要注意的是可以适当采用减枝操作和必要的时候添加sum变量进行记录
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 class Solution {private :int >> result;int > path;void backtacking (int k, int n,int startindex, int sum) if (path.size ()==k){if (sum == n) result.push_back (path);return ;for (int i= startindex;i<=9 ;i++){push_back (i);backtacking (k,n,i+1 ,sum);pop_back ();public :int >> combinationSum3 (int k, int n) {backtacking (k,n,1 ,0 );return result;
为了优化可以做一个剪枝操作
1 2 3 if (sum > targetSum) { return ;
电话号码组合问题 给定一个仅包含数字 2-9的字符串，返回所有它能表示的字母组合。答案可以按任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1不对应任何字母。
示例 ：
1 2 输入：digits = "23" "ad" ,"ae" ,"af" ,"bd" ,"be" ,"bf" ,"cd" ,"ce" ,"cf" ]
这道题需要注意的地方是，首先第一步做好map字符的映射
第二步最关键是要写清楚回溯函数的参数可能包含index，就是第几位置的字符，同时需要区分backtracking函数的for循环的内容是相当于横向的遍历，而函数体内部的实现是纵向的遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 class Solution {private :const string letterMap[10 ] = {"" , "" , "abc" , "def" , "ghi" , "jkl" , "mno" , "pqrs" , "tuv" , "wxyz" , void backtracking (const string digits,int index, string s) if (digits.size ()==0 ){return ;if (index==digits.size ()){push_back (s);return ;int digit = digits[index]-'0' ;for (int i= 0 ;i<letters.size ();i++){push_back (letters[i]);backtracking (digits, index+1 , s);pop_back ();public :vector<string> letterCombinations (string digits) {backtracking (digits,0 ,"" );return result;
组合总和 https://leetcode.cn/problems/combination-sum/
给你一个 无重复元素 的整数数组candidates 和一个目标整数 target ，找出candidates 中可以使数字和为目标数 target 的所有 不同组合 ，并以列表形式返回。你可以按任意顺序 返回这些组合。
candidates 中的 同一个 数字可以无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于150 个。
示例 ：
1 2 3 4 5 6 输入：candidates = [2,3,6,7], target = 7 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 = 7 。
思路：
题目最关键的点在于能重复使用元素但是不能重复元素的组合不能被重复输出
因此需要调整startindex的开始的位置是在backtracking(candidates,target,sum,i);注意，这个时候从i开始保证还能用到自己的元素重复使用，还有最重要的sort(candidates.begin(), candidates.end()); // 需要排序
排序之后能够很好的进行剪枝，将一些加了之后元素大于目标的删掉直接跳过
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 class Solution {public :int >> res;int > path;void backtracking (vector<int >&candidates, int target, int sum, int startindex) if (sum==target){push_back (path);return ;for (int i=startindex;i<candidates.size ();i++){if (sum>target){return ;push_back (candidates[i]);backtracking (candidates,target,sum,i);pop_back ();int >> combinationSum (vector<int >& candidates, int target) {sort (candidates.begin (), candidates.end ()); backtracking (candidates, target, 0 ,0 );return res;
组合总和II https://leetcode.cn/problems/combination-sum-ii/description/
给定一个候选人编号的集合 candidates 和一个目标数target ，找出 candidates 中所有可以使数字和为target 的组合。
candidates中的每个数字在每个组合中只能使用 一次 。
注意： 解集不能包含重复的组合。
示例 :
1 2 3 4 5 6 7 8 输入: candidates = , target = 8,
思路：
这个地方最大的困难在于每个数字在每个组合中只能使用一次，同时集合中的元素存在重复的元素，那么这个时候有一个问题是如何才能对元素进行去重处理 呢，就是让每个元素只能被使用一次
去重的操作就在于vector<bool> used(candidates.size(),false); sort(candidates.begin(), candidates.end());
首先需要在backtracking中定一个continue，这个地方是为了筛选不是重复的部分，那么如何区分开是否是同一个数组中重复的元素而不是重复利用的元素呢？
i>0&&candidates[i]==candidates[i-1]这个地方表明了对元素相邻之间进行比较used[i-1]==false如果这个地方是false，那么说明这个元素是同一层的元素(同一个数组中的元素)注意i<candidates.size()&&sum + candidates[i] <= target为了避免出现超出时间限制的情况 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Solution {public :int >> res;int > path;void backtracking (vector<int >& candidates, int target, int sum, int startindex, vector<bool >used) if (sum==target){push_back (path);return ;for (int i= startindex;i<candidates.size ();i++){if (i>0 &&candidates[i]==candidates[i-1 ]&&used[i-1 ]==false ){continue ;true ;push_back (candidates[i]);backtracking (candidates, target, sum, i+1 , used);false ;pop_back ();int >> combinationSum2 (vector<int >& candidates, int target) {vector<bool > used (candidates.size(),false ) ;sort (candidates.begin (), candidates.end ());backtracking (candidates, target, 0 , 0 , used);return res;
分割回文串 https://leetcode.cn/problems/palindrome-partitioning/description/
给你一个字符串 s，请你将 s分割成一些子串，使每个子串都是 回文串 。返回s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例：
1 2 输入：s = "aab" "a" ,"a" ,"b" ],["aa" ,"b" ]]
思路：
首先给出回文字符的判断方法：首尾指针来回比较 回溯算法中最关键的点在于startindex的使用，利用这个来移动s.substr(startindex, i-startindex+1)来截取并筛选出相应的字符串的值进行回文比较 回溯的终止条件是startindex>=s.size()如果超出了范围那么久说明到终点了 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 class Solution {public :bool ishuiwen (string s, int start, int end) for (int i = start,j = end;i<j;i++,j--){if (s[i]!=s[j]){return false ;return true ;void backtracking (string s, int startindex) if (startindex>=s.size ()){push_back (path);return ;for (int i=startindex;i<s.size ();i++){if (ishuiwen (s,startindex,i)){substr (startindex, i-startindex+1 );push_back (str);else {continue ;backtracking (s,i+1 );pop_back ();partition (string s) {backtracking (s,0 );return res;
复原IP地址 https://leetcode.cn/problems/restore-ip-addresses/description/
有效 IP 地址 正好由四个整数（每个整数位于0 到 255 之间组成，且不能含有前导0），整数之间用 '.' 分隔。
例如："0.1.2.201" 和"192.168.1.1" 是有效 IP 地址，但是"0.011.255.245"、"192.168.1.312" 和"192.168@1.1" 是 无效 IP 地址。 给定一个只包含数字的字符串 s ，用以表示一个 IP地址，返回所有可能的有效 IP 地址 ，这些地址可以通过在s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按任何 顺序返回答案。
示例 ：
1 2 输入：s = "25525511135" "255.255.11.135" ,"255.255.111.35" ]
思路：
回溯三部曲第一步：如何确定函数的类型以及参数呢？首先参数肯定包含了s、开始的位置(因为要一直往后移动并选择)、以及一个标记用于是否已经有三个点 写好判断是否合法的函数，这里比较多的陷阱需要注意 注意，当放进去3个点之后别忘了判断最后一位是否满足合法性的要求，容易忽略最后一位的情况 注意字符串的插入 s.inset(n,'.') 和删除s.erase(n) 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 class Solution {public :bool isvalid (string s, int start, int end) if (start>end){return false ;if (s[start]=='0' &&start!=end){return false ;int num = 0 ;for (int i=start;i<=end;i++){if (s[i] > '9' || s[i] < '0' ) { return false ;10 +(s[i]-'0' );if (num>255 ){return false ;return true ;void backtracking (string s, int startindex, int pointnum) if (pointnum==3 ){if (isvalid (s, startindex, s.size () - 1 )) {push_back (s);return ;for (int i=startindex;i<s.size ();i++){if (isvalid (s,startindex,i)){insert (s.begin ()+i+1 ,'.' );backtracking (s,i+2 ,pointnum);erase (s.begin ()+i+1 );else break ;vector<string> restoreIpAddresses (string s) {backtracking (s,0 ,0 );return res;
子集 https://leetcode.cn/problems/subsets/description/
给你一个整数数组 nums ，数组中的元素互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按任意顺序 返回解集。
示例：
思路：
这道题比较简单，就是简单的遍历就可以了
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums,int startindex) push_back (path);for (int i=startindex;i<nums.size ();i++){push_back (nums[i]);backtracking (nums,i+1 );pop_back ();int >> subsets (vector<int >& nums) {backtracking (nums,0 );return res;
子集II https://leetcode.cn/problems/subsets-ii/description/
给你一个整数数组 nums，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按任意顺序 排列。
示例：
注意：
凡是涉及到去重的操作，都需要优先进行排序操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int > nums, int startindex, vector<bool > used) push_back (path);for (int i=startindex;i<nums.size ();i++){if (i>0 &&nums[i]==nums[i-1 ]&&used[i-1 ]==false ){continue ;push_back (nums[i]);true ;backtracking (nums,i+1 ,used);false ;pop_back ();int >> subsetsWithDup (vector<int >& nums) {vector<bool > used (nums.size(),false ) ;sort (nums.begin (), nums.end ()); backtracking (nums,0 ,used);return res;
非递减子序列 https://leetcode.cn/problems/non-decreasing-subsequences/description/
给你一个整数数组 nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素 。你可以按 任意顺序 返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。
示例 1：
示例 2：
1 2 输入：nums = [4 ,4 ,3 ,2 ,1 ][[4,4]]
思路：
首先这道题不需要去重同时也不需要提前进行排序
但是需要对同一层的元素进行去重操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, int startindex) if (path.size ()>1 ){push_back (path);int > uset;for (int i =startindex;i<nums.size ();i++){if ((!path.empty () && nums[i] < path.back ())find (nums[i]) != uset.end ()) {continue ;insert (nums[i]);push_back (nums[i]);backtracking (nums,i+1 );pop_back ();int >> findSubsequences (vector<int >& nums) {backtracking (nums,0 );return res;
全排列 https://leetcode.cn/problems/permutations/description/
给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1：
示例 2：
1 2 输入：nums = [0 ,1 ][[0,1],[1,0]]
思路：
要求解全排列，因此回溯退出的条件是当path的长度和nums的长度一样 的时候就达到了退出的条件
因为这道题没有重复 的元素，求解全排列需要每次都从0开始选择，因此难点在于如何标记出已经选择过 的元素
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, vector<bool >& used) if (path.size ()==nums.size ()){push_back (path);for (int i=0 ;i<nums.size ();i++){if (used[i]==true ){continue ;push_back (nums[i]);true ;backtracking (nums,used);false ;pop_back ();int >> permute (vector<int >& nums) {vector<bool > used (nums.size(),false ) ;backtracking (nums,used);return res;
全排列II https://leetcode.cn/problems/permutations-ii/
给定一个可包含重复数字的序列 nums，按任意顺序
示例 1：
示例 2：
思路：
首先这个全排列有重复的元素，因此需要有去重的操作，既然涉及到去重那需要重新排序，同时需要跳过重复的元素
第二步，既然是全排列，那么需要标记重复选择的元素并选择跳过
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 class Solution {public :int >> res;int > path;void backtracking (vector<int >& nums, vector<bool >& used) if (path.size ()==nums.size ()){push_back (path);return ;for (int i=0 ;i<nums.size ();i++){if (i>0 &&nums[i]==nums[i-1 ]&&used[i-1 ]==false ){continue ;if (used[i]==false ){true ;push_back (nums[i]);backtracking (nums, used);pop_back ();false ;int >> permuteUnique (vector<int >& nums) {sort (nums.begin (),nums.end ());vector<bool > used (nums.size(),false ) ;backtracking (nums,used);return res;
重新安排行程 https://leetcode.cn/problems/reconstruct-itinerary/description/
给你一份航线列表 tickets ，其中tickets[i] = [fromi, toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。
例如，行程 ["JFK", "LGA"] 与["JFK", "LGB"] 相比就更小，排序更靠前。
思路：
【困难】
首先第一步：确定终止条件，遇到的机场个数，如果达到了（航班数量+1）
记录航班的数量，使用unordered_map<string, map<string, int>> targets;来记录航班的映射关系，我定义为全局变量。
当然把参数放进函数里传进去也是可以的，我是尽量控制函数里参数的长度。参数里还需要ticketNum，表示有多少个航班
回溯的过程中，如何遍历一个机场所对应的所有机场呢？
这里刚刚说过，在选择映射函数的时候，不能选择unordered_map<string, multiset<string>> targets，因为一旦有元素增删multiset的迭代器就会失效，当然可能有牛逼的容器删除元素迭代器不会失效，这里就不在讨论了。
可以说本题既要找到一个对数据进行排序的容器，而且还要容易增删元素，迭代器还不能失效 。
所以我选择了unordered_map<string, map<string, int>> targets来做机场之间的映射
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 class Solution {public :int >> targets;bool backtracking (int ticketnum, vector<string>& res) if (res.size ()==ticketnum+1 ){return true ;for (pair<const string, int >& target: targets[res[res.size ()-1 ]]){if (target.second>0 ){push_back (target.first);if (backtracking (ticketnum, res)) return true ;pop_back ();return false ;vector<string> findItinerary (vector<vector<string>>& tickets) {for (const vector<string>& vec: tickets){0 ]][vec[1 ]]++;push_back ("JFK" );backtracking (tickets.size (), res);return res;
N皇后 https://leetcode.cn/problems/n-queens/description/
n 皇后问题 研究的是如何将 n个皇后放置在 n×n的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.'分别代表了皇后和空位。
1 2 3 输入：n = 4 ".Q.." ,"...Q" ,"Q..." ,"..Q." ],["..Q." ,"Q..." ,"...Q" ,".Q.." ]]4 皇后问题存在两个不同的解法。
思路：
这道题关键在于用好数据结构 和写好合法性的判断
关键在于定义好chessboard第二步是把合法性位置判断写好
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 class Solution {public :bool isvalid (int row, int col, vector<string>& chessboard,int n) for (int j=0 ;j<n;j++){if (chessboard[row][j]=='Q' ) return false ;for (int i=0 ;i<n;i++){if (chessboard[i][col]=='Q' ) return false ;for (int i = row - 1 , j = col - 1 ; i >=0 && j >= 0 ; i--, j--) {if (chessboard[i][j] == 'Q' ) {return false ;for (int i = row-1 ,j=col+1 ;i>=0 &&j<n;i--,j++){if (chessboard[i][j]=='Q' ){return false ;return true ;void backtracking (vector<string>& chessboard, int row, int n) if (row==n)push_back (chessboard);return ;for (int col = 0 ;col<n;col++){if (isvalid (row,col,chessboard,n)){'Q' ;backtracking (chessboard,row+1 ,n);'.' ;solveNQueens (int n) {std::vector<std::string> chessboard (n, std::string(n, '.' )) ;backtracking (chessboard,0 ,n);return res;
解数独 编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则 ：
数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3宫内只能出现一次。（请参考示例图） 数独部分空格内已填入了数字，空白格用 '.' 表示。
1 2 输入：board = [["5" ,"3" ,"." ,"." ,"7" ,"." ,"." ,"." ,"." ],["6" ,"." ,"." ,"1" ,"9" ,"5" ,"." ,"." ,"." ],["." ,"9" ,"8" ,"." ,"." ,"." ,"." ,"6" ,"." ],["8" ,"." ,"." ,"." ,"6" ,"." ,"." ,"." ,"3" ],["4" ,"." ,"." ,"8" ,"." ,"3" ,"." ,"." ,"1" ],["7" ,"." ,"." ,"." ,"2" ,"." ,"." ,"." ,"6" ],["." ,"6" ,"." ,"." ,"." ,"." ,"2" ,"8" ,"." ],["." ,"." ,"." ,"4" ,"1" ,"9" ,"." ,"." ,"5" ],["." ,"." ,"." ,"." ,"8" ,"." ,"." ,"7" ,"9" ]]"5" ,"3" ,"4" ,"6" ,"7" ,"8" ,"9" ,"1" ,"2" ],["6" ,"7" ,"2" ,"1" ,"9" ,"5" ,"3" ,"4" ,"8" ],["1" ,"9" ,"8" ,"3" ,"4" ,"2" ,"5" ,"6" ,"7" ],["8" ,"5" ,"9" ,"7" ,"6" ,"1" ,"4" ,"2" ,"3" ],["4" ,"2" ,"6" ,"8" ,"5" ,"3" ,"7" ,"9" ,"1" ],["7" ,"1" ,"3" ,"9" ,"2" ,"4" ,"8" ,"5" ,"6" ],["9" ,"6" ,"1" ,"5" ,"3" ,"7" ,"2" ,"8" ,"4" ],["2" ,"8" ,"7" ,"4" ,"1" ,"9" ,"6" ,"3" ,"5" ],["3" ,"4" ,"5" ,"2" ,"8" ,"6" ,"1" ,"7" ,"9" ]]
思路：
深度优先搜索，加上合法性判断
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 class Solution {public :bool isvalid (vector<vector<char >>& board, int row, int col, char a) for (int j=0 ;j<9 ;j++){if (board[row][j]==a) return false ;for (int i=0 ;i<9 ;i++){if (board[i][col]==a) return false ;for (int i= (row/3 )*3 ;i<(row/3 )*3 +3 ;i++){for (int j=(col/3 )*3 ; j<(col/3 )*3 +3 ;j++){if (board[i][j]==a) return false ;return true ;bool backtracking (vector<vector<char >>& board) for (int i=0 ;i<board.size ();i++){for (int j=0 ;j<board[0 ].size ();j++){if (board[i][j]=='.' ){for (char a='1' ;a<='9' ;a++){if (isvalid (board,i,j,a)){if (backtracking (board)) return true ;'.' ;return false ;return true ;void solveSudoku (vector<vector<char >>& board) backtracking (board);
贪心算法 分发饼干 https://leetcode.cn/problems/assign-cookies/description/
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子i，都有一个胃口值g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干j，都有一个尺寸 s[j] 。如果s[j] >= g[i]，我们可以将这个饼干 j分配给孩子 i，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
示例 :
1 2 3 4 5 6 输入: g = [1,2,3], s = [1,1] 输出: 1 解释:
示例 :
1 2 3 4 5 6 输入: g = [1,2], s = [1,2,3] 输出: 2 解释:
思路：
这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩 。
可以尝试使用贪心策略，先将饼干数组和小孩数组排序。
然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :int findContentChildren (vector<int >& g, vector<int >& s) sort (s.begin (),s.end ());sort (g.begin (),g.end ());int index=s.size ()-1 ;int num= 0 ;for (int i=g.size ()-1 ; i>=0 ;i--){if (index>=0 &&s[index]>=g[i]){return num;
摆动序列 https://leetcode.cn/problems/wiggle-subsequence/description/
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。 第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
例如， [1, 7, 4, 9, 2, 5] 是一个摆动序列 ，因为差值 (6, -3, 5, -7, 3)是正负交替出现的。 给你一个整数数组 nums ，返回 nums 中作为摆动序列 的 最长子序列的长度
示例 ：
1 2 3 输入：nums = [1,7,4,9,2,5]-3 , 5, -7 , 3)
1 2 3 4 输入：nums = [1,17,5,10,13,15,10,5,16,8]-7 , 3, -3 , 6, -8 )
思路：
本题异常情况的本质，就是要考虑平坡 ，平坡分两种，一个是 上下中间有平坡，一个是单调有平坡，如图
同时需要注意的是在判断条件语句的时候，不能简单的用判断相乘法小于0作为判断，因为存在平坡的情况
异常情况需要考虑 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 class Solution {public :int wiggleMaxLength (vector<int >& nums) if (nums.size ()<=1 ){return nums.size ();int num=1 ;int > differ;for (int i=1 ;i<nums.size ();i++){push_back (nums[i]-nums[i-1 ]);int preDiff=0 ;for (int i=0 ;i<differ.size ();i++){if ((preDiff<=0 && differ[i]>0 )||(differ[i]<0 &&preDiff>=0 )){return num;
最大子数组和 https://leetcode.cn/problems/maximum-subarray/description/
给你一个整数数组 nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。
示例：
1 2 3 输入：nums = [-2 ,1,-3 ,4,-1 ,2,1,-5 ,4]-1 ,2,1] 的和最大，为 6 。
思路：
这道题使用的是局部的最优贪心的思路，如果遇到让总的值小于0，那么久立刻让总的值变成0，那么下一轮就从头开始记了，同时max会每一轮进行判断是否有比当前的最大值大，如果有那么就进行替换
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :int maxSubArray (vector<int >& nums) int res = INT32_MIN;int count = 0 ;for (int i=0 ;i<nums.size ();i++){if (count>res){if (count<=0 ) count = 0 ;return res;
买卖股票的最佳时机 https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/description/
给你一个整数数组 prices ，其中 prices[i]表示某支股票第 i天的价格。在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
1 2 3 4 5 输入：prices = [7,1,5,3,6,4] 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。 4 + 3 = 7 。
思路：
把利润分解为每天为单位的维度，而不是从 0 天到第 3天整体去考虑！
那么根据 prices可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])
相当于是每天的利润之差和0的比较，只选择为正的值，负数的情况直接忽略
1 2 3 4 5 6 7 8 9 10 class Solution {public :int maxProfit (vector<int >& prices) int res = 0 ;for (int i=1 ;i<prices.size ();i++){max (prices[i]-prices[i-1 ],0 );return res;
动态规划 状态转移公式（递推公式）是很重要，但动规不仅仅只有递推公式。
对于动态规划问题，我将拆解为如下五步曲，这五步都搞清楚了，才能说把动态规划真的掌握了！
确定dp数组（dp table）以及下标的含义 确定递推公式 dp数组如何初始化 确定遍历顺序 举例推导dp数组 注意：动态规划的问题一般只会输出最后的一个结果，不会输出比如中间的路径等相关的值
斐波那契数列 https://leetcode.cn/problems/fibonacci-number/
斐波那契数 （通常用 F(n)表示）形成的序列称为 斐波那契数列 。该数列由0 和 1开始，后面的每一项数字都是前面两项数字的和。也就是：
1 2 F (0 ) 0 ，F (1 ) = 1 F (n) F (n - 1 ) + F (n - 2 )，其中 n > 1
给定 n ，请计算 F(n) 。
示例：
1 2 3 输入：n = 2 1 F (2 ) = F (1 ) + F (0 ) = 1 + 0 = 1
思路：
因为这道题给出了递推公式：F(n) = F(n - 1) + F(n - 2)
动规五部曲：
这里我们要用一个一维dp数组来保存递归的结果
确定dp数组以及下标的含义：dp[i]的定义为：第i个数的斐波那契数值是dp[i]
确定递推公式F(n) = F(n - 1) + F(n - 2)
dp数组如何初始化
确定遍历顺序
从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i- 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的
举例推导dp数组
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int fib (int n) if (n<=1 ) return n;int >dp (n+1 );0 ]=0 ;1 ]=1 ;for (int i=2 ;i<=n;i++){-1 ]+dp[i-2 ];return dp[n];
爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬1 或 2个台阶。你有多少种不同的方法可以爬到楼顶呢？
示例 1：
1 2 3 4 5 输入：n = 2 1 阶 + 1 阶 2 阶
思路：
动态规划简单题，递推公式：dp[i] = dp[i-2]+dp[i-1];
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int climbStairs (int n) if (n<=2 ) return n;vector<int > dp (n+1 ) ;1 ]=1 ;2 ]=2 ;for (int i=3 ;i<=n;i++){-2 ]+dp[i-1 ];return dp[n];
最小费用爬楼梯 https://leetcode.cn/problems/min-cost-climbing-stairs/description/
给你一个整数数组 cost ，其中 cost[i]是从楼梯第 i个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为0 或下标为 1的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。
示例 1：
1 2 3 4 5 输入：cost = [10,15,20] 1 的台阶开始。 15 ，向上爬两个台阶，到达楼梯顶部。 15 。
思路：
动态规划可以有两个途径得到dp[i]，一个是dp[i-1]一个是dp[i-2] 。
dp[i - 1] 跳到 dp[i] 需要花费dp[i - 1] + cost[i - 1]。
dp[i - 2] 跳到 dp[i] 需要花费dp[i - 2] + cost[i - 2]。
那么究竟是选从dp[i - 1]跳还是从dp[i - 2]跳呢？
一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int minCostClimbingStairs (vector<int >& cost) int n = cost.size ();vector<int > dp (n+1 ) ;0 ]= 0 ;1 ] = 0 ;for (int i=2 ;i<=n;i++){min (dp[i-1 ]+cost[i-1 ], dp[i-2 ]+cost[i-2 ]);return dp[n];
不同路径 一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start”）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish” ）。问总共有多少条不同的路径？
思路：
简单的动态规划问题，只需要保证每次迭代都从上面和左边进行叠加
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Solution {public :int uniquePaths (int m, int n) int >>dp (m, vector <int >(n, 0 ));for (int i=0 ;i<m;i++){0 ]=1 ;for (int i=0 ;i<n;i++){0 ][i]=1 ;for (int i=1 ;i<m;i++){for (int j=1 ;j<n;j++){-1 ][j]+dp[i][j-1 ];return dp[m-1 ][n-1 ];
不同路径II https://leetcode.cn/problems/unique-paths-ii/description/
一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start”）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？网格中的障碍物和空位置分别用1 和 0 来表示。
思路：
和上一题的思路一样，都是需要遍历路径就行，但是这里加入了一个新的数组用来存储有障碍物的位置，因此需要额外进行标记&&obstacleGrid[i][0]==0的信息，同时遇到障碍物就不改变对应的值，直接continue就好
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :int uniquePathsWithObstacles (vector<vector<int >>& obstacleGrid) int >>dp (obstacleGrid.size (), vector <int >(obstacleGrid[0 ].size (), 0 ));for (int i=0 ;i<obstacleGrid.size ()&&obstacleGrid[i][0 ]==0 ;i++) dp[i][0 ]=1 ;for (int i=0 ;i<obstacleGrid[0 ].size ()&&obstacleGrid[0 ][i]==0 ;i++) dp[0 ][i]=1 ;for (int i=1 ;i<obstacleGrid.size ();i++){for (int j=1 ;j<obstacleGrid[0 ].size ();j++){if (obstacleGrid[i][j]==1 ) continue ;-1 ][j]+dp[i][j-1 ];return dp[obstacleGrid.size ()-1 ][obstacleGrid[0 ].size ()-1 ];
