语言细节 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 ;
接雨水 给定 n 个非负整数表示每个宽度为 1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：
接雨水 1 2 3 输入：height = [0,1,0,2 ,1,0,1,3 ,2,1,2,1 ]6 0,1,0,2 ,1,0,1,3 ,2,1,2,1 ] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：
1 2 输入：height = [4,2,0,3,2,5] 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 class Solution {public :int trap (vector<int >& height) if (height.size ()<=2 ) return 0 ;vector<int > maxLeft (height.size(), 0 ) ;vector<int > maxRight (height.size(), 0 ) ;int size = maxRight.size ();0 ] = height[0 ];for (int i=1 ;i<size;i++){max (height[i],maxLeft[i-1 ]);-1 ] = height[size-1 ];for (int i=size-2 ;i>=0 ;i--){max (height[i],maxRight[i+1 ]);int sum=0 ;for (int i=0 ;i<size;i++){int count = min (maxLeft[i], maxRight[i])-height[i];if (count > 0 ) sum+=count;return sum;
柱形图中的最大矩形 https://leetcode.cn/problems/largest-rectangle-in-histogram/description/
1 2 3 输入：heights = [2,1,5,6,2,3] 10 10
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 largestRectangleArea (vector<int >& heights) vector<int > minLeft (heights.size()) ;vector<int > minRight (heights.size()) ;int size = heights.size ();0 ] = -1 ;for (int i=1 ;i<size;i++){int t= i-1 ;while (t>=0 &&heights[t]>=heights[i]) t=minLeft[t];-1 ]=size;for (int i=size -2 ;i>=0 ;i--){int t=i+1 ;while (t<size&&heights[t]>=heights[i]) t=minRight[t];int res=0 ;for (int i=0 ;i<size;i++){int sum=heights[i]*(minRight[i]-minLeft[i]-1 );max (sum,res);return res;
二叉树 深搜回溯 深度优先搜索的三部曲：
确定搜索函数的返回值以及搜索函数的参数分别是什么 确定每次找到叶子结点的终止条件 确定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/
找出所有相加之和为 n 的 k个数的组合，且满足下列条件：
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例:
1 2 3 4 5 输入: k = 3 , n = 7 [[1,2,4]] 1 + 2 + 4 = 7
思路：简单的深度优先搜索，但需要注意的是可以适当采用减枝操作和必要的时候添加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 ];
整数拆分 https://leetcode.cn/problems/integer-break/description/
给定一个正整数 n ，将其拆分为 k 个正整数 的和（ k >= 2），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。
示例 :
1 2 3 输入: n = 2 2 = 1 + 1, 1 × 1 = 1。
思路：
给出递推公式一个是j * (i - j)直接相乘。一个是j * dp[i - j]，相当于是拆分(i - j)，在遍历j的过程中其实都计算过了。那么从1遍历j，比较(i - j) * j和dp[i - j] * j取最大的。递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j))；
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int integerBreak (int n) vector<int > dp (n + 1 ) ;2 ] = 1 ;for (int i = 3 ; i <= n ; i++) {for (int j = 1 ; j <= i / 2 ; j++) {max (dp[i], max ((i - j) * j, dp[i - j] * j));return dp[n];
背包问题解题框架 背包问题的基本分类关系 0-1背包 dp[j]为容量为j的背包所背的最大价值，那么如何推导dp[j]呢？dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。
dp[j - weight[i]] + value[i] 表示 容量为 j- 物品i重量 的背包 加上物品i的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）
此时dp[j]有两个选择，一个是取自己dp[j] 相当于二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值，
递推公式：
1 dp[j] = max (dp[j], dp[j - weight[i]] + value[i]);
初始化：
全部初始化为0
遍历顺序：
1 2 3 4 5 for (int i = 0 ; i < weight.size (); i++) { for (int j = bagWeight; j >= weight[i]; j--) { max (dp[j], dp[j - weight[i]] + value[i]);
整体的代码结构是 ：
1 2 3 4 5 6 7 8 9 10 11 12 13 void test_1_wei_bag_problem () int > weight = {1 , 3 , 4 };int > value = {15 , 20 , 30 };int bagWeight = 4 ;vector<int > dp (bagWeight + 1 , 0 ) ;for (int i = 0 ; i < weight.size (); i++) { for (int j = bagWeight; j >= weight[i]; j--) { max (dp[j], dp[j - weight[i]] + value[i]);
完全背包问题 有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i]。每件物品都有无限个（也就是可以放入背包多次） ，求解将哪些物品装入背包里物品价值总和最大。
完全背包和01背包问题唯一不同的地方就是，每种物品有无限件 。
在代码层面的区别在于背包遍历的时候是从头开始到尾遍历，int j = weight[i]; j <= bagWeight; j++，因为所有的背包内部都是无限的
1、先遍历物品再遍历背包
1 2 3 4 5 6 7 8 9 10 11 12 void test_CompletePack () int > weight = {1 , 3 , 4 };int > value = {15 , 20 , 30 };int bagWeight = 4 ;vector<int > dp (bagWeight + 1 , 0 ) ;for (int i = 0 ; i < weight.size (); i++) { for (int j = weight[i]; j <= bagWeight; j++) { max (dp[j], dp[j - weight[i]] + value[i]);
2、先遍历背包再遍历物品
1 2 3 4 5 6 for (int j = 0 ; j <= bagWeight; j++) { for (int i = 0 ; i < weight.size (); i++) { if (j - weight[i] >= 0 ) dp[j] = max (dp[j], dp[j - weight[i]] + value[i]);
分割等和子集 https://leetcode.cn/problems/partition-equal-subset-sum/description/
给你一个只包含正整数 的非空 数组nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等示例：
1 2 3 输入：nums =
1 2 3 输入：nums = [1 ,2 ,3 ,5 ]false
思路：因为这个地方只需要写出是否能够划分，而不是具体的划分结果，因此可以考虑利用动态规划的方法来进行写，可以利用背包法来进行求解，具体步骤：
首先判断数组的和是否为偶数，是的话那么背包的大小就是总和取一半，不是的话就直接返回false 0-1背包问题，大小是总和的一半，每个物品的价值是数的大小 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 :bool canPartition (vector<int >& nums) int sum =0 ;vector<int > dp (10001 , 0 ) ;for (int i =0 ;i< nums.size ();i++){if (sum%2 ==1 ) return false ;int target = sum/2 ;for (int i=0 ;i<nums.size ();i++){for (int j=target; j>=nums[i];j--){max (dp[j],dp[j-nums[i]]+nums[i]);if (dp[target]==target) return true ;return false ;
最后一块石头的重量 https://leetcode.cn/problems/last-stone-weight-ii/description/
有一堆石头，用整数数组 stones 表示。其中stones[i] 表示第 i块石头的重量。每一回合，从中选出任意两块石头 ，然后将它们一起粉碎。假设石头的重量分别为x 和 y，且x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎； 如果 x != y，那么重量为 x的石头将会完全粉碎，而重量为 y 的石头新重量为y-x。 最后，最多只会剩下一块 石头。返回此石头最小的可能重量 。如果没有石头剩下，就返回0。
1 2 3 4 5 6 7 输入：stones =
思路：
本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了 本题物品的重量为stones[i]，物品的价值也为stones[i]。对应着01背包里的物品重量weight[i]和物品价值value[i]。
这道题的关键在于如何将这堆石头尽可能平均的划分成两堆 （只有这样才能让剩下的石头的重量最小），大小就是总和除以2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Solution {public :int lastStoneWeightII (vector<int >& stones) vector<int > dp (15001 , 0 ) ;int sum = 0 ;for (int i =0 ; i<stones.size ();i++){int target = sum/2 ;for (int i = 0 ;i<stones.size ();i++){for (int j= target;j>=stones[i];j--){max (dp[j], dp[j-stones[i]]+stones[i]);return sum - dp[target]- dp[target];
目标和 https://leetcode.cn/problems/target-sum/description/
给你一个非负整数数组 nums 和一个整数 target。
向数组中的每个整数前添加 '+' 或 '-'，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加'+' ，在 1 之前添加 '-'，然后串联起来得到表达式 "+2-1" 。 返回可以通过上述方法构造的、运算结果等于 target 的不同表达式 的数目。
1 2 3 4 5 6 7 8 输入：nums = [1,1,1,1,1], target = 3 5 种方法让最终目标和为 3 。 1 + 1 + 1 + 1 = 3 1 + 1 + 1 + 1 = 3 1 - 1 + 1 + 1 = 3 1 + 1 - 1 + 1 = 3 1 + 1 + 1 - 1 = 3
假设加法的总和为x，那么减法对应的总和就是sum - x。
所以我们要求的是 x - (sum - x) = target
x = (target + sum) / 2
此时问题就转化为，装满容量为x的背包，有几种方法 。
这里的x，就是bagSize，也就是我们后面要求的背包容量。
大家看到(target + sum) / 2 应该担心计算的过程中向下取整有没有影响
动态规划：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Solution {public :int findTargetSumWays (vector<int >& nums, int target) int sum = 0 ;for (int i=0 ;i<nums.size ();i++) sum+=nums[i];if (abs (target)>sum) return 0 ;if ((target+sum)%2 == 1 ) return 0 ;int bagsize = (target+sum)/2 ;vector<int > dp (bagsize+1 ,0 ) ;0 ]=1 ;for (int i=0 ;i<nums.size ();i++){for (int j=bagsize;j>=nums[i];j--){return dp[bagsize];
一和零 https://leetcode.cn/problems/ones-and-zeroes/description/
给你一个二进制字符串数组 strs 和两个整数 m和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中最多 有 m 个 0 和n 个 1 。
如果 x 的所有元素也是 y 的元素，集合x 是集合 y 的 子集 。
1 2 3 4 输入：strs = ["10" , "0001" , "111001" , "1" , "0" ], m = 5 , n = 3 4 5 个 0 和 3 个 1 的最大子集是 {"10" ,"0001" ,"1" ,"0" } ，因此答案是 4 。"0001" ,"1" } 和 {"10" ,"1" ,"0" } 。{"111001" } 不满足题意，因为它含 4 个 1 ，大于 n 的值 3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :int findMaxForm (vector<string>& strs, int m, int n) int >> dp (m+1 , vector <int >(n+1 , 0 ));for (string str: strs){int onenum=0 , zeronum=0 ;for (char c :str){if (c=='0' )zeronum++;else onenum++;for (int i=m;i>=zeronum;i--){for (int j=n; j>=onenum; j--){max (dp[i][j], dp[i-zeronum][j- onenum]+1 );return dp[m][n];
零钱兑换II https://leetcode.cn/problems/coin-change-ii/description/
给你一个整数数组 coins 表示不同面额的硬币，另给一个整数amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回0 。
假设每一种面额的硬币有无限个。
1 2 3 4 5 6 7 输入：amount = 5, coins = [1, 2, 5]+2 +1 +1 +1 +1 +1 +1 +1 +1
思路：
完全背包问题
注意在用完全背包问题的时候，遍历背包这个地方是从++开始，就是从coins[i]开始遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int change (int amount, vector<int >& coins) vector<int > dp (amount+1 , 0 ) ;0 ]=1 ;for (int i=0 ;i<coins.size ();i++){for (int j = coins[i];j<=amount;j++){ return dp[amount];
组合总结IV https://leetcode.cn/problems/combination-sum-iv/description/
给你一个由 不同 整数组成的数组 nums，和一个目标整数 target 。请你从 nums中找出并返回总和为 target 的元素组合的个数。
题目数据保证答案符合 32 位整数范围。
1 2 3 4 5 6 7 8 9 10 11 12 输入：nums = [1 ,2 ,3 ], target = 4 7 1 , 1 , 1 , 1 )1 , 1 , 2 )1 , 2 , 1 )1 , 3 )2 , 1 , 1 )2 , 2 )3 , 1 )
思路：
题目中说这个问题每个元素可以被用好多次，因此想到完全背包问题
如果求组合数就是外层for循环遍历物品，内层for遍历背包 。
如果求排列数就是外层for遍历背包，内层for循环遍历物品 。
本题中的结果是需要考虑到不同数字之间的排列顺序的，所以这个地方要用到排列，先背包再物品
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :int combinationSum4 (vector<int >& nums, int target) vector<int > dp (target+1 , 0 ) ;0 ] = 1 ;for (int i=0 ;i<=target;i++){for (int j = 0 ;j<nums.size ();j++){if (i-nums[j]>=0 && dp[i]<INT_MAX-dp[i-nums[j]]){return dp[target];
零钱兑换 https://leetcode.cn/problems/coin-change/description/
给你一个整数数组 coins，表示不同面额的硬币；以及一个整数 amount，表示总金额。计算并返回可以凑成总金额所需的最少的硬币个数 如果没有任何一种硬币组合能组成总金额，返回 -1
你可以认为每种硬币的数量是无限的。
1 2 3 输入：coins = [1, 2, 5], amount = 11 5 + 5 + 1
确定dp数组以及下标的含义，dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
确定递推公式，凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）
所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。
递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
完全背包问题，且不是排列问题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :int coinChange (vector<int >& coins, int amount) vector<int > dp (amount + 1 , INT_MAX) ;0 ]=0 ;for (int i=0 ;i<coins.size ();i++){for (int j =coins[i];j< amount;j++){if (dp[j-coins[i]]!=INT_MAX){min (dp[j], dp[j-coins[i]]+1 );if (dp[amount]==INT_MAX) return -1 ;return dp[amount];
完全平方数 https://leetcode.cn/problems/perfect-squares/
给你一个整数 n ，返回 和为 n的完全平方数的最少数量 。
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9和 16 都是完全平方数，而 3 和 11不是。
1 2 3 输入：n = 12 4 + 4 + 4
思路：
完全背包问题，注意这个地方求解的是最小数量，因此初始化的时候是用INT_MAX来进行初始化
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int numSquares (int n) vector<int > dp (n+1 , INT_MAX) ;0 ] = 0 ;for (int i=1 ;i*i<=n;i++){ for (int j=i*i; j<=n; j++){min (dp[j], dp[j-i*i]+1 );return dp[n];
打家劫舍 https://leetcode.cn/problems/house-robber/description/
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
1 2 3 4 输入：[1,2,3,1] 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 1 + 3 = 4 。
思路：
当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。
递推公式为：dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i -1]);
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int rob (vector<int >& nums) if (nums.size ()==0 ) return 0 ;if (nums.size ()==1 ) return nums[0 ];vector<int > dp (nums.size()) ;0 ] = nums[0 ];1 ] = max (nums[1 ],nums[0 ]);for (int i=2 ;i<nums.size ();i++){max (dp[i-2 ]+nums[i], dp[i-1 ]);return dp[nums.size ()-1 ];
打家劫舍II https://leetcode.cn/problems/house-robber-ii/description/
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
1 2 3 输入：nums = [2,3,2] 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
思路：
如果是一个环的情况，那么需要考虑的是如何转换，既然是首尾相连的情况，那么注意的是分成两种情况，第一种是指考虑开头和倒数第二个，第二种是指考虑第二个到最后一个
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :int rob (vector<int >& nums) if (nums.size ()==0 ) return 0 ;if (nums.size ()==1 ) return nums[0 ];int res1 = robrange (nums, 0 , nums.size ()-2 );int res2 = robrange (nums, 1 , nums.size ()-1 );return max (res1, res2);int robrange (vector<int >& nums, int start, int end) if (end==start) return nums[start];vector<int > dp (nums.size()) ;1 ] = max (nums[start], nums[start+1 ]);for (int i =start+2 ;i<=end;i++){max (dp[i-2 ]+nums[i], dp[i-1 ]);return dp[end];
买卖股票的最佳时机 https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/
给定一个数组 prices ，它的第 i 个元素prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回0 。
1 2 3 4 输入：[7,1,5,3,6,4] 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
思路：
贪心
1 2 3 4 5 6 7 8 9 10 11 12 class Solution {public :int maxProfit (vector<int >& prices) int low = INT_MAX;int res = 0 ;for (int i =0 ;i<prices.size (); i++){min (low, prices[i]);max (res, prices[i]-low);return res;
动态规划
栈&队列&单调栈 有效括号 https://leetcode.cn/problems/valid-parentheses/description/
给定一个只包括'('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 每个右括号都有一个对应的相同类型的左括号。 示例 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 class Solution {public :bool ismatch (char a, char b) if ((a==')' &&b=='(' )||(a=='}' &&b=='{' )||(a==']' &&b=='[' )){return true ;else {return false ;bool isValid (string s) char >st;if (s.size ()%2 !=0 ) return false ;for (int i=0 ;i<s.size ();i++){if (s[i]==')' ||s[i]=='}' ||s[i]==']' ){if (!st.empty ()&&ismatch (s[i],st.top ())){pop ();else {return false ;else {push (s[i]);return st.empty ();
删除相邻重复 示例：
1 2 3 4 输入："abbaca" "ca" "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca" ，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca" 。
https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/description/
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :string removeDuplicates (string s) {char >st;for (char c:s){if (st.empty ()||c!=st.top ()){push (c);else {pop ();"" ;while (!st.empty ()){top ();pop ();reverse (res.begin (), res.end ()); return res;
逆波兰表达式求值 https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。
示例 1：
1 2 3 输入：tokens = ["2" ,"1" ,"+" ,"3" ,"*" ]9 2 + 1 ) * 3 ) = 9
示例 2：
1 2 3 输入：tokens = ["4" ,"13" ,"5" ,"/" ,"+" ]6 4 + (13 / 5 )) = 6
思路：
利用栈的思想模拟运算的过程，按照tokens的顺序将数字放进栈中，遇到运算符那么就拿出栈中的数字，运算结束之后再放进栈中
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 evalRPN (vector<string>& tokens) int >st;for (int i=0 ;i<tokens.size ();i++){if (tokens[i]!="/" &&tokens[i]!="+" &&tokens[i]!="-" &&tokens[i]!="*" ){push (stoi (tokens[i]));else {int num1 = st.top ();pop ();int num2 = st.top ();pop ();if (tokens[i] == "+" ) st.push (num2 + num1);if (tokens[i] == "-" ) st.push (num2 - num1);if (tokens[i] == "*" ) st.push (num2 * num1);if (tokens[i] == "/" ) st.push (num2 / num1);int result = st.top ();return result;
前K个高频元素 https://leetcode.cn/problems/top-k-frequent-elements/description/
给你一个整数数组 nums 和一个整数 k，请你返回其中出现频率前 k 高的元素。你可以按任意顺序 返回答案。
示例 1:
这道题目主要涉及到如下三块内容：
要统计元素出现频率 对频率排序 找出前K个高频元素 首先统计元素出现的频率，这一类的问题可以使用map来进行统计。
然后是对频率进行排序，这里我们可以使用一种容器适配器就是优先级队列
优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？
缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的completebinary tree（完全二叉树）
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 :class mycomparison {public :bool operator () (const pair<int , int >& lhs, const pair<int , int >& rhs) return lhs.second > rhs.second;vector<int > topKFrequent (vector<int >& nums, int k) {int , int >map;for (int i=0 ;i<nums.size ();i++){int ,int >, vector<pair<int , int >>, mycomparison> pri_que;for (unordered_map<int , int >::iterator it=map.begin (); it!=map.end (); it++){push (*it);if (pri_que.size ()>k){pop ();vector<int > res (k) ;for (int i=k-1 ;i>=0 ;i--){top ().first;pop ();return res;
每日温度 给定一个整数数组 temperatures，表示每天的温度，返回一个数组 answer ，其中answer[i] 是指对于第 i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0 来代替。
示例 1:
1 2 输入: temperatures = [73,74,75,71 ,69,72,76,73 ]1,1,4,2 ,1,1,0,0 ]
思路：
可以选择使用单调栈的方法 来求解，具体的思路是设置一个栈，遍历数组的时候和栈顶元素进行比较，小于栈顶元素的时候就需要将当前元素放入栈中
首先这道题必须有一个向量数组来存储对应位置的元素的值，vector<int> res(temperatures.size(),0)方便修改对应的元素
如果大于当前的栈顶元素的值，那么就要进行比较while循环，只要还是大于当前栈顶的元素都需要对栈顶的元素进行pop()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :vector<int > dailyTemperatures (vector<int >& temperatures) {int > st;vector<int > res (temperatures.size(),0 ) ;push (0 );for (int i=1 ;i<temperatures.size ();i++){if (temperatures[i]<=temperatures[st.top ()]){push (i);else {while (!st.empty ()&& temperatures[i]>temperatures[st.top ()]){top ()]=i-st.top ();pop ();push (i);return res;
图论 深度优先搜索理论 深度优先搜索和回溯的思路大体上是一样的
搜索方向，是认准一个方向搜，直到碰壁之后再换方向 换方向是撤销原路径，改为节点链接的下一个路径，回溯的过程。 就地递归函数的下面，例如如下代码：
1 2 3 4 5 void dfs (参数) dfs (图，选择的节点);
可以看到回溯操作就在递归函数的下面，递归和回溯是相辅相成的
深度优先搜索的三部曲：
确认递归函数，参数
深搜需要二维数组数组结构保存所有路径，需要一维数组保存单一路径，这种保存结果的数组，我们可以定义一个全局变量，避免让我们的函数参数过多。
确认终止条件
1 2 3 4 if (终止条件) {return ;
终止添加不仅是结束本层递归，同时也是我们收获结果的时候。
处理目前搜索节点出发的路径
一般这里就是一个for循环的操作，去遍历 目前搜索节点所能到的所有节点。
1 2 3 4 5 for (选择：本节点所连接的其他节点) {dfs (图，选择的节点);
回溯，撤销处理的结果 广度优先搜索理论 广搜的搜索方式就适合于解决两个点之间的最短路径问题。
因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
广度优先搜索代码模版：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) int , int >>que;push ({x,y});true ;while (!que.empty ()){int , int > cur = que.front (); pop (); int curx = cur.first;int cury = cur.second;for (int i=0 ;i<4 ;i++){int nextx = curx+dir[i][0 ];int nexty = cury+dir[i][1 ];if (nextx<0 || nextx>=grid.size () ||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]){push ({nextx,nexty});true ;
所有可能的路径 https://leetcode.cn/problems/all-paths-from-source-to-target/description/
给你一个有 n 个节点的有向无环图（DAG） ，请你找出所有从节点 0到节点 n-1的路径并输出（不要求按特定顺序 ） graph[i]是一个从节点 i 可以访问的所有节点的列表（即从节点i 到节点 graph[i][j]存在一条有向边）。
1 2 3 输入：graph = [[1,2],[3],[3],[]] [[0,1,3],[0,2,3]] 0 -> 1 -> 3 和 0 -> 2 -> 3
思路：
深度优先搜索
注意在用dfs做题的时候需要初始化path.push_back(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 >> res;int > path;void dfs (vector<vector<int >>& graph, int x) if (x == graph.size ()-1 ){push_back (path);return ;for (int i=0 ;i<graph[x].size ();i++){push_back (graph[x][i]);dfs (graph,graph[x][i]);pop_back ();int >> allPathsSourceTarget (vector<vector<int >>& graph) {push_back (0 );dfs (graph, 0 );return res;
岛屿数量 https://leetcode.cn/problems/number-of-islands/description/
给你一个由 '1'（陆地）和'0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
示例 ：
1 2 3 4 5 6 7 输入：grid = ["1" ,"1" ,"1" ,"1" ,"0" ],"1" ,"1" ,"0" ,"1" ,"0" ],"1" ,"1" ,"0" ,"0" ,"0" ],"0" ,"0" ,"0" ,"0" ,"0" ]1
深度优先搜索版本：
思路在于利用dfs来对岛屿中的数量进行标记是否能visited，必须是联通的才能继续标记为res++
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 dir[4 ][2 ] ={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) for (int i =0 ; i<4 ;i++){int nextx = x +dir[i][0 ];int nexty = y +dir[i][1 ];if (nextx<0 ||nexty>grid.size ()||nexty<0 ||nexty>grid[0 ].size) continue ;if (!visited[nextx][nexty] && grid[nextx][nexty]=='1' ){true ;dfs (grid, visited, nextx, nexty);int numIslands (vector<vector<char >>& grid) int n = grid.size (), m = grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i< n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&grid[i][j]=='1' ){true ;dfs (grid, visited, i, j);return res;
广度优先搜索版本
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 {public :int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) int , int >>que;push ({x,y});true ;while (!que.empty ()){int , int > cur = que.front ();pop ();int curx = cur.first;int cury = cur.second;for (int i =0 ;i<4 ;i++){int nextx = curx+dir[i][0 ];int nexty = cury+dir[i][1 ];if (nextx<0 ||nextx>grid.size ()||nexty<0 ||nextt>grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&&grid[nextx][nexty]=='1' ){push ({nextx,nexty});true ;int numIslands (vector<vector<char >>& grid) int n = grid.size (), m = grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&gird[i][j]=='1' ){bfs (grid, visited, i, j);return res;
岛屿的最大面积 https://leetcode.cn/problems/max-area-of-island/description/
给你一个大小为 m x n 的二进制矩阵 grid。
岛屿 是由一些相邻的 1 (代表土地)构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直的四个方向上 相邻。你可以假设grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 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 28 29 30 31 32 33 class Solution {public :int count;int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>& grid, vector<vector<bool >>& visited, int x, int y) for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&& grid[nextx][nexty]==1 ){true ;dfs (grid, visited, nextx, nexty);int maxAreaOfIsland (vector<vector<int >>& grid) int n = grid.size (), m=grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i = 0 ; i < n; i++) {for (int j = 0 ; j < m; j++) {if (!visited[i][j] && grid[i][j] == 1 ) {1 ;true ;dfs (grid, visited, i, j);max (res, count);return res;
广度优先搜索
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 class Solution {public :int count = 0 ;int dir[4 ][2 ] = {0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<int >>& grid, vector<vector<bool >>& visited, int x, int y) int > que;push (x);push (y);true ;while (!que.empty ()){int xx = que.front ();que.pop ();int yy = que.front ();que.pop ();for (int i=0 ;i<4 ;i++){int nextx = xx+dir[i][0 ];int nexty = yy+dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&& grid[nextx][nexty]==1 ){true ;push (nextx);push (nexty);int maxAreaOfIsland (vector<vector<int >>& grid) int n= grid.size (), m=grid[0 ].size ();bool >>visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&grid[i][j]==1 ){0 ;bfs (grid, visited, i, j);max (res , count);return res;
飞地的数量 https://leetcode.cn/problems/number-of-enclaves/description/
给你一个大小为 m x n 的二进制矩阵 grid，其中 0 表示一个海洋单元格、1表示一个陆地单元格。一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右 ）的陆地单元格或跨过grid 的边界。返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。
思路：
利用dfs或者是bfs的方法先把边界周围的岛屿全部去除为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 26 27 28 29 30 31 32 33 34 35 36 class Solution {public :int dir[4 ][2 ] = {0 , 1 , 1 , 0 , -1 , 0 , 0 , -1 };int count;void dfs (vector<vector<int >>& grid, int x, int y) 0 ;for (int i= 0 ;i<4 ;i++){int nextx = x +dir[i][0 ];int nexty = y +dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (grid[nextx][nexty]==0 ) continue ;dfs (grid, nextx, nexty);int numEnclaves (vector<vector<int >>& grid) int n = grid.size (), m=grid[0 ].size ();for (int i=0 ;i<n;i++){if (grid[i][0 ]==1 ) dfs (grid, i, 0 );if (grid[i][m-1 ]==1 ) dfs (grid, i, m-1 );for (int j=0 ;j<m;j++){if (grid[0 ][j]==1 ) dfs (grid, 0 , j);if (grid[n-1 ][j]==1 ) dfs (grid, n-1 , j);0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (grid[i][j]==1 ) dfs (grid, i, j);return count;
被围绕的区域 https://leetcode.cn/problems/surrounded-regions/description/
给你一个 m x n 的矩阵 board ，由若干字符'X' 和 'O' ，找到所有被 'X'围绕的区域，并将这些区域里所有的 'O' 用 'X'填充。
思路：
利用深度优先搜索的方法先将边界的联通区域全部设置为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 class Solution {public :int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<char >>& board, int x, int y) 'A' ;for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=board.size ()||nexty<0 ||nexty>=board[0 ].size ()) continue ;if (board[nextx][nexty]=='X' ||board[nextx][nexty]=='A' ) continue ;dfs (board, nextx, nexty);return ;void solve (vector<vector<char >>& board) int n= board.size (), m=board[0 ].size ();for (int i=0 ;i<n;i++){if (board[i][0 ]=='O' ) dfs (board, i,0 );if (board[i][m-1 ]=='O' ) dfs (board, i, m-1 );for (int j=0 ;j<m;j++){if (board[0 ][j]=='O' ) dfs (board, 0 , j);if (board[n-1 ][j]=='O' ) dfs (board, n-1 , j);for (int i =0 ; i<n ;i++){for (int j=0 ;j<m;j++){if (board[i][j]=='O' ) board[i][j]='X' ;;if (board[i][j]=='A' ) board[i][j]='O' ;
太平洋大西洋水流问题 https://leetcode.cn/problems/pacific-atlantic-water-flow/description/
有一个 m × n 的矩形岛屿，与 太平洋 和大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。
这个岛被分割成一个由若干方形单元格组成的网格。给定一个m x n 的整数矩阵 heights ，heights[r][c] 表示坐标 (r, c) 上单元格高于海平面的高度 。
岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
返回网格坐标 result 的 2D 列表 ，其中result[i] = [ri, ci] 表示雨水从单元格 (ri, ci)流动 既可流向太平洋也可流向大西洋 。
思路：
这道题本质上是在考虑连通图能不能到太平洋和大西洋，给出两个函数，dfs是对每一个点能够到的位置进行标记，isResult是遍历每一个节点是不是能够通过联通到达太平洋和大西洋
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 class Solution {public :int dir[4 ][2 ] = {0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>& heights, vector<vector<bool >>& visited, int x, int y) if (visited[x][y]) return ;true ;for (int i =0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=heights.size ()||nexty<0 ||nexty>=heights[0 ].size ()) continue ;if (heights[x][y] < heights[nextx][nexty]) continue ;dfs (heights, visited, nextx, nexty);bool isResult (vector<vector<int >>& heights, int x, int y) bool >> visited =vector<vector<bool >>(heights.size (), vector <bool >(heights[0 ].size (), false ));dfs (heights, visited, x, y);bool isPacific = false ;bool isAtlantic = false ; for (int j=0 ;j<heights[0 ].size ();j++){if (visited[0 ][j]){true ;break ;for (int i=0 ;i<heights.size ();i++){if (visited[i][0 ]){true ;break ;for (int j=0 ;j<heights[0 ].size ();j++){if (visited[heights.size ()-1 ][j]){true ;break ;for (int i =0 ;i<heights.size ();i++){if (visited[i][heights[0 ].size ()-1 ]){true ;break ;if (isAtlantic && isPacific) return true ;return false ;int >> pacificAtlantic (vector<vector<int >>& heights) {int >> result;for (int i = 0 ; i < heights.size (); i++) {for (int j = 0 ; j < heights[0 ].size (); j++) {if (isResult (heights, i, j)) result.push_back ({i, j});return result;
最大人工岛 https://leetcode.cn/problems/making-a-large-island/description/
给你一个大小为 n x n 二进制矩阵 grid。最多 只能将一格 0 变成 1。
返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿 由一组上、下、左、右四个方向相连的1 形成。
示例 1:
1 2 3 输入: grid = [[1, 0], [0, 1]] 3 0 变成1 ，最终连通两个小岛得到面积为 3 的岛屿。
示例 2:
1 2 3 输入: grid = [[1, 1], [1, 0]] 4 0 变成1 ，岛屿的面积扩大为 4 。
示例 3:
1 2 3 输入: grid = [[1, 1], [1, 1]] 4 0 可以让我们变成1 ，面积依然为 4 。
思路：
最大人工岛编号 当完成编号之后，第二步骤就是对每个没有编号的节点进行相邻岛屿的面积遍历增加
注意这一步完成之后要对每个不同岛屿的面积数量进行记录，这个地方可以用map来进行记录
最大人工岛第二步遍历节点 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 48 49 50 51 52 53 54 55 56 57 58 59 class Solution {public :int count;int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>&grid, vector<vector<bool >>& visited, int x, int y, int mark) if (visited[x][y]||grid[x][y]==0 ) return ;true ;for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y + dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;dfs (grid, visited, nextx, nexty, mark);int largestIsland (vector<vector<int >>& grid) int n =grid.size (), m=grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int , int >gridNum;int mark = 2 ; bool isALLgrid = true ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (grid[i][j]==0 ) isALLgrid = false ;if (!visited[i][j]&&grid[i][j]==1 ){0 ;dfs (grid, visited, i, j, mark);if (isALLgrid) return n*m; int res = 0 ;int > visitedGrid; for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){int count =1 ;clear (); if (grid[i][j]==0 ){for (int k=0 ;k<4 ;k++){int neari = i+dir[k][0 ];int nearj = j+dir[k][1 ];if (neari<0 ||nearj<0 ||neari>=grid.size ()||nearj>=grid[0 ].size ()) continue ;if (visitedGrid.count (grid[neari][nearj])) continue ;insert (grid[neari][nearj]);max (res, count);return res;
单词接龙 https://leetcode.cn/problems/word-ladder/description/
字典 wordList 中从单词 beginWord 和endWord 的 转换序列 是一个按下述规格形成的序列beginWord -> s1 -> s2 -> ... -> sk：
每一对相邻的单词只差一个字母。 对于 1 <= i <= k 时，每个 si 都在wordList 中。注意， beginWord 不需要在wordList 中。 sk == endWord给你两个单词 beginWord 和 endWord和一个字典 wordList ，返回 从 beginWord 到endWord 的 最短转换序列 中的单词数目 。如果不存在这样的转换序列，返回0 。
示例 1：
1 2 3 输入：beginWord = "hit" , endWord = "cog" , wordList = ["hot" ,"dot" ,"dog" ,"lot" ,"log" ,"cog" ]5 "hit" -> "hot" -> "dot" -> "dog" -> "cog" , 返回它的长度 5 。
示例 2：
1 2 3 输入：begin Word = "hit" , end Word = "cog" , wordList = ["hot" ,"dot" ,"dog" ,"lot" ,"log" ]0 end Word "cog" 不在字典中，所以无法进行转换。
思路：
这道题要解决两个问题：
首先题目中并没有给出点与点之间的连线，而是要我们自己去连，条件是字符只能差一个，所以判断点与点之间的关系，要自己判断是不是差一个字符，如果差一个字符，那就是有链接。
然后就是求起点和终点的最短路径长度，这里无向图求最短路，广搜最为合适，广搜只要搜到了终点，那么一定是最短的路径 。因为广搜就是以起点中心向四周扩散的搜索。
本题如果用深搜，会比较麻烦，要在到达终点的不同路径中选则一条最短路 。而广搜只要达到终点，一定是最短路。
广度优先搜索一定是能找到最短路径
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 :int ladderLength (string beginWord, string endWord, vector<string>& wordList) unordered_set<string> wordSet (wordList.begin(), wordList.end()) ;if (wordSet.find (endWord)==wordSet.end ()) return 0 ;int >visitMap;push (beginWord);insert (pair <string, int >(beginWord, 1 )); while (!que.empty ()){front ();pop ();int path = visitMap[word]; for (int i=0 ;i<word.size ();i++){for (int j=0 ;j<26 ;j++){'a' ;if (newWord ==endWord) return path+1 ;if (wordSet.find (newWord)!=wordSet.end ()&& visitMap.find (newWord)==visitMap.end ()){insert (pair <string, int >(newWord, path+1 ));push (newWord);return 0 ;
钥匙和房间 https://leetcode.cn/problems/keys-and-rooms/description/
有 n 个房间，房间按从 0 到n - 1 编号。最初，除 0号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。
当你进入一个房间，你可能会在里面找到一套不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。
给你一个数组 rooms 其中 rooms[i] 是你进入i 号房间可以获得的钥匙集合。如果能进入所有 房间返回 true，否则返回false。
示例 1：
1 2 3 4 5 6 7 8 输入：rooms = [[1],[2],[3],[]] true 0 号房间开始，拿到钥匙 1 。1 号房间，拿到钥匙 2 。2 号房间，拿到钥匙 3 。3 号房间。true 。
示例 2：
1 2 3 输入：rooms = [[1,3],[3,0,1],[2],[0]] false 2 号房间。
思路：
这是在找一个有向图，如果出现有孤立的问题那么就不能开门进入，一定要全部连通，除此之外还需要注意的是这个是一个有向图的问题，还需要注意方向
因此需要用DFS来求解
其实本质上就是在利用深度优先搜索来进行遍历查找，如果能找到的话那么就进行标记，最后再进行筛选
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :void dfs (const vector<vector<int >>& rooms, int key, vector<bool >& visited) if (visited[key]) return ;true ;int > keys = rooms[key];for (int key :keys){dfs (rooms, key, visited);bool canVisitAllRooms (vector<vector<int >>& rooms) vector<bool > visited (rooms.size(),false ) ;dfs (rooms, 0 , visited);for (int i:visited){if (i==false ) return false ;return true ;
岛屿的周长 https://leetcode.cn/problems/island-perimeter/description/
给定一个 row x col 的二维网格地图 grid，其中：grid[i][j] = 1 表示陆地，grid[i][j] = 0 表示水域。网格中的格子水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖”指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1的正方形。网格为长方形，且宽度和高度均不超过 100。计算这个岛屿的周长。
思路：
遍历每一个空格，遇到岛屿，计算其上下左右的情况，遇到水域或者出界的情况，就可以计算边了。
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 dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };int islandPerimeter (vector<vector<int >>& grid) int res = 0 ;for (int i=0 ;i<grid.size ();i++){for (int j=0 ;j<grid[0 ].size ();j++){if (grid[i][j]==1 ){for (int k=0 ;k<4 ;k++){int x= i+dir[k][0 ];int y = j+dir[k][1 ];if (x<0 ||y<0 ||x>=grid.size ()||y>=grid[0 ].size ()||grid[x][y]==0 ){return res;
并查集理论基础 并查集常用来解决连通性问题。当我们需要判断两个元素是否在同一个集合里的时候，我们就要想到用并查集，并查集主要有两个功能：
将两个元素添加到一个集合中。 判断两个元素在不在同一个集合 基础理论知识 将两条边加入并查集
1 2 3 4 5 6 7 void join (int u, int v) find (u); find (v); if (u == v) return ;
判断两个边是不是在同一个集合中寻根
给出A元素，就可以通过 father[A] = B，father[B] = C，找到根为 C。
给出B元素，就可以通过 father[B] = C，找到根也为为 C，说明 A 和 B是在同一个集合里。大家会想第一段代码里find函数是如何实现的呢？其实就是通过数组下标找到数组元素，一层一层寻根过程，代码如下：
1 2 3 4 5 int find (int u) if (u == father[u]) return u; else return find (father[u]);
1 2 3 4 5 6 void init () for (int i = 0 ; i < n; ++i) {
最后我们如何判断两个元素是否在同一个集合里，如果通过 find函数 找到两个元素属于同一个根的话，那么这两个元素就是同一个集合，代码如下：
1 2 3 4 5 6 bool isSame (int u, int v) find (u);find (v);return u == v;
路径压缩就一行代码：
1 2 3 4 5 int find (int u) if (u == father[u]) return u;else return father[u] = find (father[u]);
以上代码在C++中，可以用三元表达式来精简一下，代码如下：
1 2 3 int find (int u) return u == father[u] ? u : father[u] = find (father[u]);
join 函数里的这段代码：
1 2 3 u = find (u); find (v); if (u == v) return ;
与 isSame 函数的实现是不是重复了？ 如果抽象一下呢，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 bool isSame (int u, int v) find (u);find (v);return u == v;void join (int u, int v) if (isSame) return ;
这样写可以吗？ 好像看出去没问题，而且代码更精简了。
其实这么写是有问题的 ，在join函数中 我们需要寻找 u 和v 的根，然后再进行连线在一起，而不是直接 用 u 和 v 连线在一起。
整体代码模版 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 int n =1005 ;int > father = vector <int >(n, 0 );void init () for (int i=0 ;i<n;i++){int find (int u) return u == father[u]? u:father[u]=find (father[u]);bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u);find (v);if (u==v) return ;
寻找图中是否存在路径 https://leetcode.cn/problems/find-if-path-exists-in-graph/description/
有一个具有 n 个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含0 和 n - 1）。图中的边用一个二维整数数组edges 表示，其中 edges[i] = [ui, vi] 表示顶点ui 和顶点 vi 之间的双向边。 每个顶点对由最多一条 边连接，并且没有顶点存在与自身相连的边。
请你确定是否存在从顶点 source 开始，到顶点destination 结束的 有效路径 。给你数组edges 和整数 n、source 和destination，如果从 source 到destination 存在 有效路径 ，则返回true，否则返回 false 。
思路：
简单的并查集实践，一般这种只需要你返回是否能连通的就可以用并查集来求解
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 class Solution {public :int n=200005 ;int > father = vector <int >(n,0 );void init () for (int i=0 ;i<n;i++){int find (int u) if (u==father[u]) return u;else return father[u] = find ((father[u]));bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u); find (v); if (u == v) return ; bool validPath (int n, vector<vector<int >>& edges, int source, int destination) init ();for (int i=0 ;i<edges.size ();i++){join (edges[i][0 ],edges[i][1 ]);return isSame (source, destination);
冗余连接 https://leetcode.cn/problems/redundant-connection/description/
树可以看成是一个连通且 无环 的 无向 图。
给定往一棵 n 个节点 (节点值 1～n)的树中添加一条边后的图。添加的边的两个顶点包含在 1 到n中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为n 的二维数组 edges，edges[i] = [ai, bi] 表示图中在 ai 和bi 之间存在一条边。
请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n个节点的树。如果有多个答案，则返回数组 edges中最后出现的那个。
思路：
那么我们就可以从前向后遍历每一条边（因为优先让前面的边连上），边的两个节点如果不在同一个集合，就加入集合（即：同一个根节点）。
如果边的两个节点已经出现在同一个集合里，说明着边的两个节点已经连在一起了，再加入这条边一定就出现环了
已经判断 节点A 和 节点B 在在同一个集合（同一个根），如果将 节点A 和节点B 连在一起就一定会出现环。
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 :int n =1005 ;int > father = vector <int >(n, 0 );void init () for (int i=0 ;i<n;i++){int find (int u) if (u==father[u]) return u;else return father[u] = find (father[u]);bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u);find (v);if (u==v) return ;vector<int > findRedundantConnection (vector<vector<int >>& edges) {init ();for (int i=0 ;i<edges.size ();i++){if (isSame (edges[i][0 ], edges[i][1 ])) return edges[i];else (join (edges[i][0 ], edges[i][1 ]));return {};
冗余连接II https://leetcode.cn/problems/redundant-connection-ii/description/
在本问题中，有根树指满足以下条件的 有向 图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。
输入一个有向图，该图由一个有着 n个节点（节点值不重复，从 1 到n）的树及一条附加的有向边构成。附加的边包含在1 到 n中的两个不同顶点间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组 edges 。 每个元素是一对[ui, vi]，用以表示 有向 图中连接顶点ui 和顶点 vi 的边，其中 ui 是vi 的一个父节点。
返回一条能删除的边，使得剩下的图是有 n个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。
思路：
题目中的表述中提到该图由一个有着N个节点 (节点值不重复1, 2,..., N)的树及一条附加的边构成。附加的边的两个顶点包含在1到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 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 class Solution {public :static const int N =1010 ;int father[N];int n;void init () for (int i =1 ;i<=n;i++){int find (int u) if (father[u]==u) return u;else return father[u]=find (father[u]);void join (int u, int v) find (u);find (v);if (u==v) return ;else father[v] = u;bool same (int u, int v) find (u);find (v);return u==v;vector<int > getRemoveEdge (const vector<vector<int >>& edges) {init ();for (int i =0 ;i<n;i++){if (same (edges[i][0 ], edges[i][1 ])){ return edges[i];join (edges[i][0 ], edges[i][1 ]);return {};bool isTree (const vector<vector<int >>& edges, int deleteEdges) init ();for (int i=0 ;i<n;i++){if (i==deleteEdges) continue ;if (same (edges[i][0 ], edges[i][1 ])) return false ; join (edges[i][0 ], edges[i][1 ]);return true ;vector<int > findRedundantDirectedConnection (vector<vector<int >>& edges) {int inDegree[N]={0 };size ();for (int i=0 ;i<n;i++){1 ]]++;int > vec; for (int i=n-1 ;i>=0 ;i--){if (inDegree[edges[i][1 ]]==2 ){push_back (i);if (vec.size ()>0 ){if (isTree (edges, vec[0 ])){return edges[vec[0 ]];else {return edges[vec[1 ]];return getRemoveEdge (edges);
语言细节 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 ;
接雨水 给定 n 个非负整数表示每个宽度为 1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
示例 1：
接雨水 1 2 3 输入：height = [0,1,0,2 ,1,0,1,3 ,2,1,2,1 ]6 0,1,0,2 ,1,0,1,3 ,2,1,2,1 ] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。
示例 2：
1 2 输入：height = [4,2,0,3,2,5] 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 class Solution {public :int trap (vector<int >& height) if (height.size ()<=2 ) return 0 ;vector<int > maxLeft (height.size(), 0 ) ;vector<int > maxRight (height.size(), 0 ) ;int size = maxRight.size ();0 ] = height[0 ];for (int i=1 ;i<size;i++){max (height[i],maxLeft[i-1 ]);-1 ] = height[size-1 ];for (int i=size-2 ;i>=0 ;i--){max (height[i],maxRight[i+1 ]);int sum=0 ;for (int i=0 ;i<size;i++){int count = min (maxLeft[i], maxRight[i])-height[i];if (count > 0 ) sum+=count;return sum;
柱形图中的最大矩形 https://leetcode.cn/problems/largest-rectangle-in-histogram/description/
1 2 3 输入：heights = [2,1,5,6,2,3] 10 10
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 largestRectangleArea (vector<int >& heights) vector<int > minLeft (heights.size()) ;vector<int > minRight (heights.size()) ;int size = heights.size ();0 ] = -1 ;for (int i=1 ;i<size;i++){int t= i-1 ;while (t>=0 &&heights[t]>=heights[i]) t=minLeft[t];-1 ]=size;for (int i=size -2 ;i>=0 ;i--){int t=i+1 ;while (t<size&&heights[t]>=heights[i]) t=minRight[t];int res=0 ;for (int i=0 ;i<size;i++){int sum=heights[i]*(minRight[i]-minLeft[i]-1 );max (sum,res);return res;
二叉树 构建二叉搜索树并中序遍历 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 #include <iostream> #include <vector> using namespace std;struct TreeNode {int val;TreeNode (): val (0 ), left (nullptr ), right (nullptr ){}TreeNode (int val): val (val), left (nullptr ), right (nullptr )()TreeNode* search (vector<int > nums) {new TreeNode (nums[0 ]);for (int i=0 ;i<nums.size ();i++){new TreeNode (nums[i]);while (cur!=nullptr ){if (nums[i]<cur->val){if (cur->left==nullptr ){cur->left = n; break ;}else (cur = cur->left;)else {if (cur->right==nullptr ){cur->right = n; break ;}else (cur = cur->right;)return root;void inorder (TreeNode* root) if (root == nullptr ) return ;inorder (root->left);printf ("%d " ,root->val);inorder (root->right);int main () int > nums=({2 ,3 ,4 ,5 ,2 ,1 });search (nums);inorder (root);return 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 > nums;void inorder (TreeNode* root) if (root == nullptr ){return ;inorder (root->left);push_back (root->val);inorder (root->right);bool isValidBST (TreeNode* root) inorder (root);for (int i = 1 ; i < nums.size (); i++){if (nums[i] <= nums[i - 1 ]){return false ;return true ;
二叉搜索树中第K小的元素 思路：一样的思路，将二叉搜索树进行存储进一个一维的数组中，然后输出第k-1个元素
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :int > nums;void inorder (TreeNode* root) if (root == nullptr ){return ;inorder (root->left);push_back (root->val);inorder (root->right);int kthSmallest (TreeNode* root, int k) inorder (root);return nums[k-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 class Solution {public :TreeNode* build (vector<int >& preorder, vector<int >& inorder, int ps, int pe, int is, int ie) {if (ps >= pe || is >= ie){return nullptr ;new TreeNode (preorder[ps]);int i;for (i = is; i < ie; i++){if (inorder[i] == preorder[ps]){break ;build (preorder, inorder, ps + 1 , ps + 1 + (i - is), is, i);build (preorder, inorder, ps + 1 + i - is, pe, i + 1 , ie);return r;TreeNode* buildTree (vector<int >& preorder, vector<int >& inorder) {return build (preorder, inorder, 0 , preorder.size (), 0 , inorder.size ());
深搜回溯 深度优先搜索的三部曲：
确定搜索函数的返回值以及搜索函数的参数分别是什么 确定每次找到叶子结点的终止条件 确定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/
找出所有相加之和为 n 的 k个数的组合，且满足下列条件：
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例:
1 2 3 4 5 输入: k = 3 , n = 7 [[1,2,4]] 1 + 2 + 4 = 7
思路：简单的深度优先搜索，但需要注意的是可以适当采用减枝操作和必要的时候添加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 ];
整数拆分 https://leetcode.cn/problems/integer-break/description/
给定一个正整数 n ，将其拆分为 k 个正整数 的和（ k >= 2），并使这些整数的乘积最大化。返回 你可以获得的最大乘积 。
示例 :
1 2 3 输入: n = 2 2 = 1 + 1, 1 × 1 = 1。
思路：
给出递推公式一个是j * (i - j)直接相乘。一个是j * dp[i - j]，相当于是拆分(i - j)，在遍历j的过程中其实都计算过了。那么从1遍历j，比较(i - j) * j和dp[i - j] * j取最大的。递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j))；
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int integerBreak (int n) vector<int > dp (n + 1 ) ;2 ] = 1 ;for (int i = 3 ; i <= n ; i++) {for (int j = 1 ; j <= i / 2 ; j++) {max (dp[i], max ((i - j) * j, dp[i - j] * j));return dp[n];
背包问题解题框架 背包问题的基本分类关系 0-1背包 dp[j]为容量为j的背包所背的最大价值，那么如何推导dp[j]呢？dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。
dp[j - weight[i]] + value[i] 表示 容量为 j- 物品i重量 的背包 加上物品i的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）
此时dp[j]有两个选择，一个是取自己dp[j] 相当于二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值，
递推公式：
1 dp[j] = max (dp[j], dp[j - weight[i]] + value[i]);
初始化：
全部初始化为0
遍历顺序：
1 2 3 4 5 for (int i = 0 ; i < weight.size (); i++) { for (int j = bagWeight; j >= weight[i]; j--) { max (dp[j], dp[j - weight[i]] + value[i]);
整体的代码结构是 ：
1 2 3 4 5 6 7 8 9 10 11 12 13 void test_1_wei_bag_problem () int > weight = {1 , 3 , 4 };int > value = {15 , 20 , 30 };int bagWeight = 4 ;vector<int > dp (bagWeight + 1 , 0 ) ;for (int i = 0 ; i < weight.size (); i++) { for (int j = bagWeight; j >= weight[i]; j--) { max (dp[j], dp[j - weight[i]] + value[i]);
完全背包问题 有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i]。每件物品都有无限个（也就是可以放入背包多次） ，求解将哪些物品装入背包里物品价值总和最大。
完全背包和01背包问题唯一不同的地方就是，每种物品有无限件 。
在代码层面的区别在于背包遍历的时候是从头开始到尾遍历，int j = weight[i]; j <= bagWeight; j++，因为所有的背包内部都是无限的
1、先遍历物品再遍历背包
1 2 3 4 5 6 7 8 9 10 11 12 void test_CompletePack () int > weight = {1 , 3 , 4 };int > value = {15 , 20 , 30 };int bagWeight = 4 ;vector<int > dp (bagWeight + 1 , 0 ) ;for (int i = 0 ; i < weight.size (); i++) { for (int j = weight[i]; j <= bagWeight; j++) { max (dp[j], dp[j - weight[i]] + value[i]);
2、先遍历背包再遍历物品
1 2 3 4 5 6 for (int j = 0 ; j <= bagWeight; j++) { for (int i = 0 ; i < weight.size (); i++) { if (j - weight[i] >= 0 ) dp[j] = max (dp[j], dp[j - weight[i]] + value[i]);
分割等和子集 https://leetcode.cn/problems/partition-equal-subset-sum/description/
给你一个只包含正整数 的非空 数组nums。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等示例：
1 2 3 输入：nums =
1 2 3 输入：nums = [1 ,2 ,3 ,5 ]false
思路：因为这个地方只需要写出是否能够划分，而不是具体的划分结果，因此可以考虑利用动态规划的方法来进行写，可以利用背包法来进行求解，具体步骤：
首先判断数组的和是否为偶数，是的话那么背包的大小就是总和取一半，不是的话就直接返回false 0-1背包问题，大小是总和的一半，每个物品的价值是数的大小 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 :bool canPartition (vector<int >& nums) int sum =0 ;vector<int > dp (10001 , 0 ) ;for (int i =0 ;i< nums.size ();i++){if (sum%2 ==1 ) return false ;int target = sum/2 ;for (int i=0 ;i<nums.size ();i++){for (int j=target; j>=nums[i];j--){max (dp[j],dp[j-nums[i]]+nums[i]);if (dp[target]==target) return true ;return false ;
最后一块石头的重量 https://leetcode.cn/problems/last-stone-weight-ii/description/
有一堆石头，用整数数组 stones 表示。其中stones[i] 表示第 i块石头的重量。每一回合，从中选出任意两块石头 ，然后将它们一起粉碎。假设石头的重量分别为x 和 y，且x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎； 如果 x != y，那么重量为 x的石头将会完全粉碎，而重量为 y 的石头新重量为y-x。 最后，最多只会剩下一块 石头。返回此石头最小的可能重量 。如果没有石头剩下，就返回0。
1 2 3 4 5 6 7 输入：stones =
思路：
本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了 本题物品的重量为stones[i]，物品的价值也为stones[i]。对应着01背包里的物品重量weight[i]和物品价值value[i]。
这道题的关键在于如何将这堆石头尽可能平均的划分成两堆 （只有这样才能让剩下的石头的重量最小），大小就是总和除以2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class Solution {public :int lastStoneWeightII (vector<int >& stones) vector<int > dp (15001 , 0 ) ;int sum = 0 ;for (int i =0 ; i<stones.size ();i++){int target = sum/2 ;for (int i = 0 ;i<stones.size ();i++){for (int j= target;j>=stones[i];j--){max (dp[j], dp[j-stones[i]]+stones[i]);return sum - dp[target]- dp[target];
目标和 https://leetcode.cn/problems/target-sum/description/
给你一个非负整数数组 nums 和一个整数 target。
向数组中的每个整数前添加 '+' 或 '-'，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加'+' ，在 1 之前添加 '-'，然后串联起来得到表达式 "+2-1" 。 返回可以通过上述方法构造的、运算结果等于 target 的不同表达式 的数目。
1 2 3 4 5 6 7 8 输入：nums = [1,1,1,1,1], target = 3 5 种方法让最终目标和为 3 。 1 + 1 + 1 + 1 = 3 1 + 1 + 1 + 1 = 3 1 - 1 + 1 + 1 = 3 1 + 1 - 1 + 1 = 3 1 + 1 + 1 - 1 = 3
假设加法的总和为x，那么减法对应的总和就是sum - x。
所以我们要求的是 x - (sum - x) = target
x = (target + sum) / 2
此时问题就转化为，装满容量为x的背包，有几种方法 。
这里的x，就是bagSize，也就是我们后面要求的背包容量。
大家看到(target + sum) / 2 应该担心计算的过程中向下取整有没有影响
动态规划：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 class Solution {public :int findTargetSumWays (vector<int >& nums, int target) int sum = 0 ;for (int i=0 ;i<nums.size ();i++) sum+=nums[i];if (abs (target)>sum) return 0 ;if ((target+sum)%2 == 1 ) return 0 ;int bagsize = (target+sum)/2 ;vector<int > dp (bagsize+1 ,0 ) ;0 ]=1 ;for (int i=0 ;i<nums.size ();i++){for (int j=bagsize;j>=nums[i];j--){return dp[bagsize];
一和零 https://leetcode.cn/problems/ones-and-zeroes/description/
给你一个二进制字符串数组 strs 和两个整数 m和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中最多 有 m 个 0 和n 个 1 。
如果 x 的所有元素也是 y 的元素，集合x 是集合 y 的 子集 。
1 2 3 4 输入：strs = ["10" , "0001" , "111001" , "1" , "0" ], m = 5 , n = 3 4 5 个 0 和 3 个 1 的最大子集是 {"10" ,"0001" ,"1" ,"0" } ，因此答案是 4 。"0001" ,"1" } 和 {"10" ,"1" ,"0" } 。{"111001" } 不满足题意，因为它含 4 个 1 ，大于 n 的值 3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :int findMaxForm (vector<string>& strs, int m, int n) int >> dp (m+1 , vector <int >(n+1 , 0 ));for (string str: strs){int onenum=0 , zeronum=0 ;for (char c :str){if (c=='0' )zeronum++;else onenum++;for (int i=m;i>=zeronum;i--){for (int j=n; j>=onenum; j--){max (dp[i][j], dp[i-zeronum][j- onenum]+1 );return dp[m][n];
零钱兑换II https://leetcode.cn/problems/coin-change-ii/description/
给你一个整数数组 coins 表示不同面额的硬币，另给一个整数amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回0 。
假设每一种面额的硬币有无限个。
1 2 3 4 5 6 7 输入：amount = 5, coins = [1, 2, 5]+2 +1 +1 +1 +1 +1 +1 +1 +1
思路：
完全背包问题
注意在用完全背包问题的时候，遍历背包这个地方是从++开始，就是从coins[i]开始遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int change (int amount, vector<int >& coins) vector<int > dp (amount+1 , 0 ) ;0 ]=1 ;for (int i=0 ;i<coins.size ();i++){for (int j = coins[i];j<=amount;j++){ return dp[amount];
组合总结IV https://leetcode.cn/problems/combination-sum-iv/description/
给你一个由 不同 整数组成的数组 nums，和一个目标整数 target 。请你从 nums中找出并返回总和为 target 的元素组合的个数。
题目数据保证答案符合 32 位整数范围。
1 2 3 4 5 6 7 8 9 10 11 12 输入：nums = [1 ,2 ,3 ], target = 4 7 1 , 1 , 1 , 1 )1 , 1 , 2 )1 , 2 , 1 )1 , 3 )2 , 1 , 1 )2 , 2 )3 , 1 )
思路：
题目中说这个问题每个元素可以被用好多次，因此想到完全背包问题
如果求组合数就是外层for循环遍历物品，内层for遍历背包 。
如果求排列数就是外层for遍历背包，内层for循环遍历物品 。
本题中的结果是需要考虑到不同数字之间的排列顺序的，所以这个地方要用到排列，先背包再物品
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class Solution {public :int combinationSum4 (vector<int >& nums, int target) vector<int > dp (target+1 , 0 ) ;0 ] = 1 ;for (int i=0 ;i<=target;i++){for (int j = 0 ;j<nums.size ();j++){if (i-nums[j]>=0 && dp[i]<INT_MAX-dp[i-nums[j]]){return dp[target];
零钱兑换 https://leetcode.cn/problems/coin-change/description/
给你一个整数数组 coins，表示不同面额的硬币；以及一个整数 amount，表示总金额。计算并返回可以凑成总金额所需的最少的硬币个数 如果没有任何一种硬币组合能组成总金额，返回 -1
你可以认为每种硬币的数量是无限的。
1 2 3 输入：coins = [1, 2, 5], amount = 11 5 + 5 + 1
确定dp数组以及下标的含义，dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
确定递推公式，凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）
所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。
递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
完全背包问题，且不是排列问题
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class Solution {public :int coinChange (vector<int >& coins, int amount) vector<int > dp (amount + 1 , INT_MAX) ;0 ]=0 ;for (int i=0 ;i<coins.size ();i++){for (int j =coins[i];j< amount;j++){if (dp[j-coins[i]]!=INT_MAX){min (dp[j], dp[j-coins[i]]+1 );if (dp[amount]==INT_MAX) return -1 ;return dp[amount];
完全平方数 https://leetcode.cn/problems/perfect-squares/
给你一个整数 n ，返回 和为 n的完全平方数的最少数量 。
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9和 16 都是完全平方数，而 3 和 11不是。
1 2 3 输入：n = 12 4 + 4 + 4
思路：
完全背包问题，注意这个地方求解的是最小数量，因此初始化的时候是用INT_MAX来进行初始化
1 2 3 4 5 6 7 8 9 10 11 12 13 class Solution {public :int numSquares (int n) vector<int > dp (n+1 , INT_MAX) ;0 ] = 0 ;for (int i=1 ;i*i<=n;i++){ for (int j=i*i; j<=n; j++){min (dp[j], dp[j-i*i]+1 );return dp[n];
打家劫舍 https://leetcode.cn/problems/house-robber/description/
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
1 2 3 4 输入：[1,2,3,1] 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 1 + 3 = 4 。
思路：
当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。
递推公式为：dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i -1]);
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int rob (vector<int >& nums) if (nums.size ()==0 ) return 0 ;if (nums.size ()==1 ) return nums[0 ];vector<int > dp (nums.size()) ;0 ] = nums[0 ];1 ] = max (nums[1 ],nums[0 ]);for (int i=2 ;i<nums.size ();i++){max (dp[i-2 ]+nums[i], dp[i-1 ]);return dp[nums.size ()-1 ];
打家劫舍II https://leetcode.cn/problems/house-robber-ii/description/
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
1 2 3 输入：nums = [2,3,2] 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
思路：
如果是一个环的情况，那么需要考虑的是如何转换，既然是首尾相连的情况，那么注意的是分成两种情况，第一种是指考虑开头和倒数第二个，第二种是指考虑第二个到最后一个
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :int rob (vector<int >& nums) if (nums.size ()==0 ) return 0 ;if (nums.size ()==1 ) return nums[0 ];int res1 = robrange (nums, 0 , nums.size ()-2 );int res2 = robrange (nums, 1 , nums.size ()-1 );return max (res1, res2);int robrange (vector<int >& nums, int start, int end) if (end==start) return nums[start];vector<int > dp (nums.size()) ;1 ] = max (nums[start], nums[start+1 ]);for (int i =start+2 ;i<=end;i++){max (dp[i-2 ]+nums[i], dp[i-1 ]);return dp[end];
买卖股票的最佳时机 https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/
给定一个数组 prices ，它的第 i 个元素prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回0 。
1 2 3 4 输入：[7,1,5,3,6,4] 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
思路：
贪心
1 2 3 4 5 6 7 8 9 10 11 12 class Solution {public :int maxProfit (vector<int >& prices) int low = INT_MAX;int res = 0 ;for (int i =0 ;i<prices.size (); i++){min (low, prices[i]);max (res, prices[i]-low);return res;
动态规划
乘积最大子数组 https://leetcode.cn/problems/maximum-product-subarray/description/
给你一个整数数组 nums，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
测试用例的答案是一个 32-位 整数。
子数组 是数组的连续子序列。
1 2 3 输入: nums = [2,3,-2,4] 输出: 6 解释: 子数组 [2,3] 有最大乘积 6。
思路：
因为是乘积的问题，所以会存在如果某个值特别小或者是特别大再负负得正之后仍然会出现最大的情况，因此我们在用动态规划记录的时候不仅要记录最大值还需要记录最小值
1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution {public :int maxProduct (vector<int >& nums) vector<int > maxp (nums) ;vector<int > minp (nums) ;int res = nums[0 ];for (int i=1 ;i<nums.size ();i++){max (maxp[i-1 ]*nums[i], max (nums[i], minp[i-1 ]*nums[i]));max (maxp[i], res);min (minp[i-1 ]*nums[i], min (nums[i], maxp[i-1 ]*nums[i]));return res;
栈&队列&单调栈 有效括号 https://leetcode.cn/problems/valid-parentheses/description/
给定一个只包括'('，')'，'{'，'}'，'['，']'的字符串 s ，判断字符串是否有效。
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 每个右括号都有一个对应的相同类型的左括号。 示例 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 class Solution {public :bool ismatch (char a, char b) if ((a==')' &&b=='(' )||(a=='}' &&b=='{' )||(a==']' &&b=='[' )){return true ;else {return false ;bool isValid (string s) char >st;if (s.size ()%2 !=0 ) return false ;for (int i=0 ;i<s.size ();i++){if (s[i]==')' ||s[i]=='}' ||s[i]==']' ){if (!st.empty ()&&ismatch (s[i],st.top ())){pop ();else {return false ;else {push (s[i]);return st.empty ();
删除相邻重复 示例：
1 2 3 4 输入："abbaca" "ca" "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca" ，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca" 。
https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/description/
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :string removeDuplicates (string s) {char >st;for (char c:s){if (st.empty ()||c!=st.top ()){push (c);else {pop ();"" ;while (!st.empty ()){top ();pop ();reverse (res.begin (), res.end ()); return res;
逆波兰表达式求值 https://leetcode.cn/problems/evaluate-reverse-polish-notation/description/
给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。
示例 1：
1 2 3 输入：tokens = ["2" ,"1" ,"+" ,"3" ,"*" ]9 2 + 1 ) * 3 ) = 9
示例 2：
1 2 3 输入：tokens = ["4" ,"13" ,"5" ,"/" ,"+" ]6 4 + (13 / 5 )) = 6
思路：
利用栈的思想模拟运算的过程，按照tokens的顺序将数字放进栈中，遇到运算符那么就拿出栈中的数字，运算结束之后再放进栈中
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 evalRPN (vector<string>& tokens) int >st;for (int i=0 ;i<tokens.size ();i++){if (tokens[i]!="/" &&tokens[i]!="+" &&tokens[i]!="-" &&tokens[i]!="*" ){push (stoi (tokens[i]));else {int num1 = st.top ();pop ();int num2 = st.top ();pop ();if (tokens[i] == "+" ) st.push (num2 + num1);if (tokens[i] == "-" ) st.push (num2 - num1);if (tokens[i] == "*" ) st.push (num2 * num1);if (tokens[i] == "/" ) st.push (num2 / num1);int result = st.top ();return result;
前K个高频元素 https://leetcode.cn/problems/top-k-frequent-elements/description/
给你一个整数数组 nums 和一个整数 k，请你返回其中出现频率前 k 高的元素。你可以按任意顺序 返回答案。
示例 1:
这道题目主要涉及到如下三块内容：
要统计元素出现频率 对频率排序 找出前K个高频元素 首先统计元素出现的频率，这一类的问题可以使用map来进行统计。
然后是对频率进行排序，这里我们可以使用一种容器适配器就是优先级队列
优先级队列内部元素是自动依照元素的权值排列。那么它是如何有序排列的呢？
缺省情况下priority_queue利用max-heap（大顶堆）完成对元素的排序，这个大顶堆是以vector为表现形式的completebinary tree（完全二叉树）
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 :class mycomparison {public :bool operator () (const pair<int , int >& lhs, const pair<int , int >& rhs) return lhs.second > rhs.second;vector<int > topKFrequent (vector<int >& nums, int k) {int , int >map;for (int i=0 ;i<nums.size ();i++){int ,int >, vector<pair<int , int >>, mycomparison> pri_que;for (unordered_map<int , int >::iterator it=map.begin (); it!=map.end (); it++){push (*it);if (pri_que.size ()>k){pop ();vector<int > res (k) ;for (int i=k-1 ;i>=0 ;i--){top ().first;pop ();return res;
每日温度 给定一个整数数组 temperatures，表示每天的温度，返回一个数组 answer ，其中answer[i] 是指对于第 i天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用0 来代替。
示例 1:
1 2 输入: temperatures = [73,74,75,71 ,69,72,76,73 ]1,1,4,2 ,1,1,0,0 ]
思路：
可以选择使用单调栈的方法 来求解，具体的思路是设置一个栈，遍历数组的时候和栈顶元素进行比较，小于栈顶元素的时候就需要将当前元素放入栈中
首先这道题必须有一个向量数组来存储对应位置的元素的值，vector<int> res(temperatures.size(),0)方便修改对应的元素
如果大于当前的栈顶元素的值，那么就要进行比较while循环，只要还是大于当前栈顶的元素都需要对栈顶的元素进行pop()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Solution {public :vector<int > dailyTemperatures (vector<int >& temperatures) {int > st;vector<int > res (temperatures.size(),0 ) ;push (0 );for (int i=1 ;i<temperatures.size ();i++){if (temperatures[i]<=temperatures[st.top ()]){push (i);else {while (!st.empty ()&& temperatures[i]>temperatures[st.top ()]){top ()]=i-st.top ();pop ();push (i);return res;
图论 深度优先搜索理论 深度优先搜索和回溯的思路大体上是一样的
搜索方向，是认准一个方向搜，直到碰壁之后再换方向 换方向是撤销原路径，改为节点链接的下一个路径，回溯的过程。 就地递归函数的下面，例如如下代码：
1 2 3 4 5 void dfs (参数) dfs (图，选择的节点);
可以看到回溯操作就在递归函数的下面，递归和回溯是相辅相成的
深度优先搜索的三部曲：
确认递归函数，参数
深搜需要二维数组数组结构保存所有路径，需要一维数组保存单一路径，这种保存结果的数组，我们可以定义一个全局变量，避免让我们的函数参数过多。
确认终止条件
1 2 3 4 if (终止条件) {return ;
终止添加不仅是结束本层递归，同时也是我们收获结果的时候。
处理目前搜索节点出发的路径
一般这里就是一个for循环的操作，去遍历 目前搜索节点所能到的所有节点。
1 2 3 4 5 for (选择：本节点所连接的其他节点) {dfs (图，选择的节点);
回溯，撤销处理的结果 广度优先搜索理论 广搜的搜索方式就适合于解决两个点之间的最短路径问题。
因为广搜是从起点出发，以起始点为中心一圈一圈进行搜索，一旦遇到终点，记录之前走过的节点就是一条最短路。
广度优先搜索代码模版：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) int , int >>que;push ({x,y});true ;while (!que.empty ()){int , int > cur = que.front (); pop (); int curx = cur.first;int cury = cur.second;for (int i=0 ;i<4 ;i++){int nextx = curx+dir[i][0 ];int nexty = cury+dir[i][1 ];if (nextx<0 || nextx>=grid.size () ||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]){push ({nextx,nexty});true ;
所有可能的路径 https://leetcode.cn/problems/all-paths-from-source-to-target/description/
给你一个有 n 个节点的有向无环图（DAG） ，请你找出所有从节点 0到节点 n-1的路径并输出（不要求按特定顺序 ） graph[i]是一个从节点 i 可以访问的所有节点的列表（即从节点i 到节点 graph[i][j]存在一条有向边）。
1 2 3 输入：graph = [[1,2],[3],[3],[]] [[0,1,3],[0,2,3]] 0 -> 1 -> 3 和 0 -> 2 -> 3
思路：
深度优先搜索
注意在用dfs做题的时候需要初始化path.push_back(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 >> res;int > path;void dfs (vector<vector<int >>& graph, int x) if (x == graph.size ()-1 ){push_back (path);return ;for (int i=0 ;i<graph[x].size ();i++){push_back (graph[x][i]);dfs (graph,graph[x][i]);pop_back ();int >> allPathsSourceTarget (vector<vector<int >>& graph) {push_back (0 );dfs (graph, 0 );return res;
岛屿数量 https://leetcode.cn/problems/number-of-islands/description/
给你一个由 '1'（陆地）和'0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
示例 ：
1 2 3 4 5 6 7 输入：grid = ["1" ,"1" ,"1" ,"1" ,"0" ],"1" ,"1" ,"0" ,"1" ,"0" ],"1" ,"1" ,"0" ,"0" ,"0" ],"0" ,"0" ,"0" ,"0" ,"0" ]1
深度优先搜索版本：
思路在于利用dfs来对岛屿中的数量进行标记是否能visited，必须是联通的才能继续标记为res++
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 dir[4 ][2 ] ={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) for (int i =0 ; i<4 ;i++){int nextx = x +dir[i][0 ];int nexty = y +dir[i][1 ];if (nextx<0 ||nexty>grid.size ()||nexty<0 ||nexty>grid[0 ].size) continue ;if (!visited[nextx][nexty] && grid[nextx][nexty]=='1' ){true ;dfs (grid, visited, nextx, nexty);int numIslands (vector<vector<char >>& grid) int n = grid.size (), m = grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i< n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&grid[i][j]=='1' ){true ;dfs (grid, visited, i, j);return res;
广度优先搜索版本
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 {public :int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<char >>& grid, vector<vector<bool >>& visited, int x, int y) int , int >>que;push ({x,y});true ;while (!que.empty ()){int , int > cur = que.front ();pop ();int curx = cur.first;int cury = cur.second;for (int i =0 ;i<4 ;i++){int nextx = curx+dir[i][0 ];int nexty = cury+dir[i][1 ];if (nextx<0 ||nextx>grid.size ()||nexty<0 ||nextt>grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&&grid[nextx][nexty]=='1' ){push ({nextx,nexty});true ;int numIslands (vector<vector<char >>& grid) int n = grid.size (), m = grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&gird[i][j]=='1' ){bfs (grid, visited, i, j);return res;
岛屿的最大面积 https://leetcode.cn/problems/max-area-of-island/description/
给你一个大小为 m x n 的二进制矩阵 grid。
岛屿 是由一些相邻的 1 (代表土地)构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直的四个方向上 相邻。你可以假设grid 的四个边缘都被 0（代表水）包围着。
岛屿的面积是岛上值为 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 28 29 30 31 32 33 class Solution {public :int count;int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>& grid, vector<vector<bool >>& visited, int x, int y) for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&& grid[nextx][nexty]==1 ){true ;dfs (grid, visited, nextx, nexty);int maxAreaOfIsland (vector<vector<int >>& grid) int n = grid.size (), m=grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i = 0 ; i < n; i++) {for (int j = 0 ; j < m; j++) {if (!visited[i][j] && grid[i][j] == 1 ) {1 ;true ;dfs (grid, visited, i, j);max (res, count);return res;
广度优先搜索
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 class Solution {public :int count = 0 ;int dir[4 ][2 ] = {0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void bfs (vector<vector<int >>& grid, vector<vector<bool >>& visited, int x, int y) int > que;push (x);push (y);true ;while (!que.empty ()){int xx = que.front ();que.pop ();int yy = que.front ();que.pop ();for (int i=0 ;i<4 ;i++){int nextx = xx+dir[i][0 ];int nexty = yy+dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (!visited[nextx][nexty]&& grid[nextx][nexty]==1 ){true ;push (nextx);push (nexty);int maxAreaOfIsland (vector<vector<int >>& grid) int n= grid.size (), m=grid[0 ].size ();bool >>visited = vector<vector<bool >>(n, vector <bool >(m, false ));int res = 0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (!visited[i][j]&&grid[i][j]==1 ){0 ;bfs (grid, visited, i, j);max (res , count);return res;
飞地的数量 https://leetcode.cn/problems/number-of-enclaves/description/
给你一个大小为 m x n 的二进制矩阵 grid，其中 0 表示一个海洋单元格、1表示一个陆地单元格。一次 移动 是指从一个陆地单元格走到另一个相邻（上、下、左、右 ）的陆地单元格或跨过grid 的边界。返回网格中 无法 在任意次数的移动中离开网格边界的陆地单元格的数量。
思路：
利用dfs或者是bfs的方法先把边界周围的岛屿全部去除为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 26 27 28 29 30 31 32 33 34 35 36 class Solution {public :int dir[4 ][2 ] = {0 , 1 , 1 , 0 , -1 , 0 , 0 , -1 };int count;void dfs (vector<vector<int >>& grid, int x, int y) 0 ;for (int i= 0 ;i<4 ;i++){int nextx = x +dir[i][0 ];int nexty = y +dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;if (grid[nextx][nexty]==0 ) continue ;dfs (grid, nextx, nexty);int numEnclaves (vector<vector<int >>& grid) int n = grid.size (), m=grid[0 ].size ();for (int i=0 ;i<n;i++){if (grid[i][0 ]==1 ) dfs (grid, i, 0 );if (grid[i][m-1 ]==1 ) dfs (grid, i, m-1 );for (int j=0 ;j<m;j++){if (grid[0 ][j]==1 ) dfs (grid, 0 , j);if (grid[n-1 ][j]==1 ) dfs (grid, n-1 , j);0 ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (grid[i][j]==1 ) dfs (grid, i, j);return count;
被围绕的区域 https://leetcode.cn/problems/surrounded-regions/description/
给你一个 m x n 的矩阵 board ，由若干字符'X' 和 'O' ，找到所有被 'X'围绕的区域，并将这些区域里所有的 'O' 用 'X'填充。
思路：
利用深度优先搜索的方法先将边界的联通区域全部设置为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 class Solution {public :int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<char >>& board, int x, int y) 'A' ;for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=board.size ()||nexty<0 ||nexty>=board[0 ].size ()) continue ;if (board[nextx][nexty]=='X' ||board[nextx][nexty]=='A' ) continue ;dfs (board, nextx, nexty);return ;void solve (vector<vector<char >>& board) int n= board.size (), m=board[0 ].size ();for (int i=0 ;i<n;i++){if (board[i][0 ]=='O' ) dfs (board, i,0 );if (board[i][m-1 ]=='O' ) dfs (board, i, m-1 );for (int j=0 ;j<m;j++){if (board[0 ][j]=='O' ) dfs (board, 0 , j);if (board[n-1 ][j]=='O' ) dfs (board, n-1 , j);for (int i =0 ; i<n ;i++){for (int j=0 ;j<m;j++){if (board[i][j]=='O' ) board[i][j]='X' ;;if (board[i][j]=='A' ) board[i][j]='O' ;
太平洋大西洋水流问题 https://leetcode.cn/problems/pacific-atlantic-water-flow/description/
有一个 m × n 的矩形岛屿，与 太平洋 和大西洋 相邻。 “太平洋” 处于大陆的左边界和上边界，而 “大西洋” 处于大陆的右边界和下边界。
这个岛被分割成一个由若干方形单元格组成的网格。给定一个m x n 的整数矩阵 heights ，heights[r][c] 表示坐标 (r, c) 上单元格高于海平面的高度 。
岛上雨水较多，如果相邻单元格的高度 小于或等于 当前单元格的高度，雨水可以直接向北、南、东、西流向相邻单元格。水可以从海洋附近的任何单元格流入海洋。
返回网格坐标 result 的 2D 列表 ，其中result[i] = [ri, ci] 表示雨水从单元格 (ri, ci)流动 既可流向太平洋也可流向大西洋 。
思路：
这道题本质上是在考虑连通图能不能到太平洋和大西洋，给出两个函数，dfs是对每一个点能够到的位置进行标记，isResult是遍历每一个节点是不是能够通过联通到达太平洋和大西洋
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 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 class Solution {public :int dir[4 ][2 ] = {0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>& heights, vector<vector<bool >>& visited, int x, int y) if (visited[x][y]) return ;true ;for (int i =0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y+dir[i][1 ];if (nextx<0 ||nextx>=heights.size ()||nexty<0 ||nexty>=heights[0 ].size ()) continue ;if (heights[x][y] < heights[nextx][nexty]) continue ;dfs (heights, visited, nextx, nexty);bool isResult (vector<vector<int >>& heights, int x, int y) bool >> visited =vector<vector<bool >>(heights.size (), vector <bool >(heights[0 ].size (), false ));dfs (heights, visited, x, y);bool isPacific = false ;bool isAtlantic = false ; for (int j=0 ;j<heights[0 ].size ();j++){if (visited[0 ][j]){true ;break ;for (int i=0 ;i<heights.size ();i++){if (visited[i][0 ]){true ;break ;for (int j=0 ;j<heights[0 ].size ();j++){if (visited[heights.size ()-1 ][j]){true ;break ;for (int i =0 ;i<heights.size ();i++){if (visited[i][heights[0 ].size ()-1 ]){true ;break ;if (isAtlantic && isPacific) return true ;return false ;int >> pacificAtlantic (vector<vector<int >>& heights) {int >> result;for (int i = 0 ; i < heights.size (); i++) {for (int j = 0 ; j < heights[0 ].size (); j++) {if (isResult (heights, i, j)) result.push_back ({i, j});return result;
最大人工岛 https://leetcode.cn/problems/making-a-large-island/description/
给你一个大小为 n x n 二进制矩阵 grid。最多 只能将一格 0 变成 1。
返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿 由一组上、下、左、右四个方向相连的1 形成。
示例 1:
1 2 3 输入: grid = [[1, 0], [0, 1]] 3 0 变成1 ，最终连通两个小岛得到面积为 3 的岛屿。
示例 2:
1 2 3 输入: grid = [[1, 1], [1, 0]] 4 0 变成1 ，岛屿的面积扩大为 4 。
示例 3:
1 2 3 输入: grid = [[1, 1], [1, 1]] 4 0 可以让我们变成1 ，面积依然为 4 。
思路：
最大人工岛编号 当完成编号之后，第二步骤就是对每个没有编号的节点进行相邻岛屿的面积遍历增加
注意这一步完成之后要对每个不同岛屿的面积数量进行记录，这个地方可以用map来进行记录
最大人工岛第二步遍历节点 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 48 49 50 51 52 53 54 55 56 57 58 59 class Solution {public :int count;int dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };void dfs (vector<vector<int >>&grid, vector<vector<bool >>& visited, int x, int y, int mark) if (visited[x][y]||grid[x][y]==0 ) return ;true ;for (int i=0 ;i<4 ;i++){int nextx = x+dir[i][0 ];int nexty = y + dir[i][1 ];if (nextx<0 ||nextx>=grid.size ()||nexty<0 ||nexty>=grid[0 ].size ()) continue ;dfs (grid, visited, nextx, nexty, mark);int largestIsland (vector<vector<int >>& grid) int n =grid.size (), m=grid[0 ].size ();bool >> visited = vector<vector<bool >>(n, vector <bool >(m, false ));int , int >gridNum;int mark = 2 ; bool isALLgrid = true ;for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){if (grid[i][j]==0 ) isALLgrid = false ;if (!visited[i][j]&&grid[i][j]==1 ){0 ;dfs (grid, visited, i, j, mark);if (isALLgrid) return n*m; int res = 0 ;int > visitedGrid; for (int i=0 ;i<n;i++){for (int j=0 ;j<m;j++){int count =1 ;clear (); if (grid[i][j]==0 ){for (int k=0 ;k<4 ;k++){int neari = i+dir[k][0 ];int nearj = j+dir[k][1 ];if (neari<0 ||nearj<0 ||neari>=grid.size ()||nearj>=grid[0 ].size ()) continue ;if (visitedGrid.count (grid[neari][nearj])) continue ;insert (grid[neari][nearj]);max (res, count);return res;
单词接龙 https://leetcode.cn/problems/word-ladder/description/
字典 wordList 中从单词 beginWord 和endWord 的 转换序列 是一个按下述规格形成的序列beginWord -> s1 -> s2 -> ... -> sk：
每一对相邻的单词只差一个字母。 对于 1 <= i <= k 时，每个 si 都在wordList 中。注意， beginWord 不需要在wordList 中。 sk == endWord给你两个单词 beginWord 和 endWord和一个字典 wordList ，返回 从 beginWord 到endWord 的 最短转换序列 中的单词数目 。如果不存在这样的转换序列，返回0 。
示例 1：
1 2 3 输入：beginWord = "hit" , endWord = "cog" , wordList = ["hot" ,"dot" ,"dog" ,"lot" ,"log" ,"cog" ]5 "hit" -> "hot" -> "dot" -> "dog" -> "cog" , 返回它的长度 5 。
示例 2：
1 2 3 输入：begin Word = "hit" , end Word = "cog" , wordList = ["hot" ,"dot" ,"dog" ,"lot" ,"log" ]0 end Word "cog" 不在字典中，所以无法进行转换。
思路：
这道题要解决两个问题：
首先题目中并没有给出点与点之间的连线，而是要我们自己去连，条件是字符只能差一个，所以判断点与点之间的关系，要自己判断是不是差一个字符，如果差一个字符，那就是有链接。
然后就是求起点和终点的最短路径长度，这里无向图求最短路，广搜最为合适，广搜只要搜到了终点，那么一定是最短的路径 。因为广搜就是以起点中心向四周扩散的搜索。
本题如果用深搜，会比较麻烦，要在到达终点的不同路径中选则一条最短路 。而广搜只要达到终点，一定是最短路。
广度优先搜索一定是能找到最短路径
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 :int ladderLength (string beginWord, string endWord, vector<string>& wordList) unordered_set<string> wordSet (wordList.begin(), wordList.end()) ;if (wordSet.find (endWord)==wordSet.end ()) return 0 ;int >visitMap;push (beginWord);insert (pair <string, int >(beginWord, 1 )); while (!que.empty ()){front ();pop ();int path = visitMap[word]; for (int i=0 ;i<word.size ();i++){for (int j=0 ;j<26 ;j++){'a' ;if (newWord ==endWord) return path+1 ;if (wordSet.find (newWord)!=wordSet.end ()&& visitMap.find (newWord)==visitMap.end ()){insert (pair <string, int >(newWord, path+1 ));push (newWord);return 0 ;
钥匙和房间 https://leetcode.cn/problems/keys-and-rooms/description/
有 n 个房间，房间按从 0 到n - 1 编号。最初，除 0号房间外的其余所有房间都被锁住。你的目标是进入所有的房间。然而，你不能在没有获得钥匙的时候进入锁住的房间。
当你进入一个房间，你可能会在里面找到一套不同的钥匙，每把钥匙上都有对应的房间号，即表示钥匙可以打开的房间。你可以拿上所有钥匙去解锁其他房间。
给你一个数组 rooms 其中 rooms[i] 是你进入i 号房间可以获得的钥匙集合。如果能进入所有 房间返回 true，否则返回false。
示例 1：
1 2 3 4 5 6 7 8 输入：rooms = [[1],[2],[3],[]] true 0 号房间开始，拿到钥匙 1 。1 号房间，拿到钥匙 2 。2 号房间，拿到钥匙 3 。3 号房间。true 。
示例 2：
1 2 3 输入：rooms = [[1,3],[3,0,1],[2],[0]] false 2 号房间。
思路：
这是在找一个有向图，如果出现有孤立的问题那么就不能开门进入，一定要全部连通，除此之外还需要注意的是这个是一个有向图的问题，还需要注意方向
因此需要用DFS来求解
其实本质上就是在利用深度优先搜索来进行遍历查找，如果能找到的话那么就进行标记，最后再进行筛选
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Solution {public :void dfs (const vector<vector<int >>& rooms, int key, vector<bool >& visited) if (visited[key]) return ;true ;int > keys = rooms[key];for (int key :keys){dfs (rooms, key, visited);bool canVisitAllRooms (vector<vector<int >>& rooms) vector<bool > visited (rooms.size(),false ) ;dfs (rooms, 0 , visited);for (int i:visited){if (i==false ) return false ;return true ;
岛屿的周长 https://leetcode.cn/problems/island-perimeter/description/
给定一个 row x col 的二维网格地图 grid，其中：grid[i][j] = 1 表示陆地，grid[i][j] = 0 表示水域。网格中的格子水平和垂直 方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖”指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1的正方形。网格为长方形，且宽度和高度均不超过 100。计算这个岛屿的周长。
思路：
遍历每一个空格，遇到岛屿，计算其上下左右的情况，遇到水域或者出界的情况，就可以计算边了。
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 dir[4 ][2 ]={0 ,1 ,1 ,0 ,-1 ,0 ,0 ,-1 };int islandPerimeter (vector<vector<int >>& grid) int res = 0 ;for (int i=0 ;i<grid.size ();i++){for (int j=0 ;j<grid[0 ].size ();j++){if (grid[i][j]==1 ){for (int k=0 ;k<4 ;k++){int x= i+dir[k][0 ];int y = j+dir[k][1 ];if (x<0 ||y<0 ||x>=grid.size ()||y>=grid[0 ].size ()||grid[x][y]==0 ){return res;
并查集理论基础 并查集常用来解决连通性问题。当我们需要判断两个元素是否在同一个集合里的时候，我们就要想到用并查集，并查集主要有两个功能：
将两个元素添加到一个集合中。 判断两个元素在不在同一个集合 基础理论知识 将两条边加入并查集
1 2 3 4 5 6 7 void join (int u, int v) find (u); find (v); if (u == v) return ;
判断两个边是不是在同一个集合中寻根
给出A元素，就可以通过 father[A] = B，father[B] = C，找到根为 C。
给出B元素，就可以通过 father[B] = C，找到根也为为 C，说明 A 和 B是在同一个集合里。大家会想第一段代码里find函数是如何实现的呢？其实就是通过数组下标找到数组元素，一层一层寻根过程，代码如下：
1 2 3 4 5 int find (int u) if (u == father[u]) return u; else return find (father[u]);
1 2 3 4 5 6 void init () for (int i = 0 ; i < n; ++i) {
最后我们如何判断两个元素是否在同一个集合里，如果通过 find函数 找到两个元素属于同一个根的话，那么这两个元素就是同一个集合，代码如下：
1 2 3 4 5 6 bool isSame (int u, int v) find (u);find (v);return u == v;
路径压缩就一行代码：
1 2 3 4 5 int find (int u) if (u == father[u]) return u;else return father[u] = find (father[u]);
以上代码在C++中，可以用三元表达式来精简一下，代码如下：
1 2 3 int find (int u) return u == father[u] ? u : father[u] = find (father[u]);
join 函数里的这段代码：
1 2 3 u = find (u); find (v); if (u == v) return ;
与 isSame 函数的实现是不是重复了？ 如果抽象一下呢，代码如下：
1 2 3 4 5 6 7 8 9 10 11 12 bool isSame (int u, int v) find (u);find (v);return u == v;void join (int u, int v) if (isSame) return ;
这样写可以吗？ 好像看出去没问题，而且代码更精简了。
其实这么写是有问题的 ，在join函数中 我们需要寻找 u 和v 的根，然后再进行连线在一起，而不是直接 用 u 和 v 连线在一起。
整体代码模版 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 int n =1005 ;int > father = vector <int >(n, 0 );void init () for (int i=0 ;i<n;i++){int find (int u) return u == father[u]? u:father[u]=find (father[u]);bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u);find (v);if (u==v) return ;
寻找图中是否存在路径 https://leetcode.cn/problems/find-if-path-exists-in-graph/description/
有一个具有 n 个顶点的 双向 图，其中每个顶点标记从 0 到 n - 1（包含0 和 n - 1）。图中的边用一个二维整数数组edges 表示，其中 edges[i] = [ui, vi] 表示顶点ui 和顶点 vi 之间的双向边。 每个顶点对由最多一条 边连接，并且没有顶点存在与自身相连的边。
请你确定是否存在从顶点 source 开始，到顶点destination 结束的 有效路径 。给你数组edges 和整数 n、source 和destination，如果从 source 到destination 存在 有效路径 ，则返回true，否则返回 false 。
思路：
简单的并查集实践，一般这种只需要你返回是否能连通的就可以用并查集来求解
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 class Solution {public :int n=200005 ;int > father = vector <int >(n,0 );void init () for (int i=0 ;i<n;i++){int find (int u) if (u==father[u]) return u;else return father[u] = find ((father[u]));bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u); find (v); if (u == v) return ; bool validPath (int n, vector<vector<int >>& edges, int source, int destination) init ();for (int i=0 ;i<edges.size ();i++){join (edges[i][0 ],edges[i][1 ]);return isSame (source, destination);
冗余连接 https://leetcode.cn/problems/redundant-connection/description/
树可以看成是一个连通且 无环 的 无向 图。
给定往一棵 n 个节点 (节点值 1～n)的树中添加一条边后的图。添加的边的两个顶点包含在 1 到n中间，且这条附加的边不属于树中已存在的边。图的信息记录于长度为n 的二维数组 edges，edges[i] = [ai, bi] 表示图中在 ai 和bi 之间存在一条边。
请找出一条可以删去的边，删除后可使得剩余部分是一个有着 n个节点的树。如果有多个答案，则返回数组 edges中最后出现的那个。
思路：
那么我们就可以从前向后遍历每一条边（因为优先让前面的边连上），边的两个节点如果不在同一个集合，就加入集合（即：同一个根节点）。
如果边的两个节点已经出现在同一个集合里，说明着边的两个节点已经连在一起了，再加入这条边一定就出现环了
已经判断 节点A 和 节点B 在在同一个集合（同一个根），如果将 节点A 和节点B 连在一起就一定会出现环。
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 :int n =1005 ;int > father = vector <int >(n, 0 );void init () for (int i=0 ;i<n;i++){int find (int u) if (u==father[u]) return u;else return father[u] = find (father[u]);bool isSame (int u, int v) find (u);find (v);return u==v;void join (int u, int v) find (u);find (v);if (u==v) return ;vector<int > findRedundantConnection (vector<vector<int >>& edges) {init ();for (int i=0 ;i<edges.size ();i++){if (isSame (edges[i][0 ], edges[i][1 ])) return edges[i];else (join (edges[i][0 ], edges[i][1 ]));return {};
冗余连接II https://leetcode.cn/problems/redundant-connection-ii/description/
在本问题中，有根树指满足以下条件的 有向 图。该树只有一个根节点，所有其他节点都是该根节点的后继。该树除了根节点之外的每一个节点都有且只有一个父节点，而根节点没有父节点。
输入一个有向图，该图由一个有着 n个节点（节点值不重复，从 1 到n）的树及一条附加的有向边构成。附加的边包含在1 到 n中的两个不同顶点间，这条附加的边不属于树中已存在的边。
结果图是一个以边组成的二维数组 edges 。 每个元素是一对[ui, vi]，用以表示 有向 图中连接顶点ui 和顶点 vi 的边，其中 ui 是vi 的一个父节点。
返回一条能删除的边，使得剩下的图是有 n个节点的有根树。若有多个答案，返回最后出现在给定二维数组的答案。
思路：
题目中的表述中提到该图由一个有着N个节点 (节点值不重复1, 2,..., N)的树及一条附加的边构成。附加的边的两个顶点包含在1到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 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 class Solution {public :static const int N =1010 ;int father[N];int n;void init () for (int i =1 ;i<=n;i++){int find (int u) if (father[u]==u) return u;else return father[u]=find (father[u]);void join (int u, int v) find (u);find (v);if (u==v) return ;else father[v] = u;bool same (int u, int v) find (u);find (v);return u==v;vector<int > getRemoveEdge (const vector<vector<int >>& edges) {init ();for (int i =0 ;i<n;i++){if (same (edges[i][0 ], edges[i][1 ])){ return edges[i];join (edges[i][0 ], edges[i][1 ]);return {};bool isTree (const vector<vector<int >>& edges, int deleteEdges) init ();for (int i=0 ;i<n;i++){if (i==deleteEdges) continue ;if (same (edges[i][0 ], edges[i][1 ])) return false ; join (edges[i][0 ], edges[i][1 ]);return true ;vector<int > findRedundantDirectedConnection (vector<vector<int >>& edges) {int inDegree[N]={0 };size ();for (int i=0 ;i<n;i++){1 ]]++;int > vec; for (int i=n-1 ;i>=0 ;i--){if (inDegree[edges[i][1 ]]==2 ){push_back (i);if (vec.size ()>0 ){if (isTree (edges, vec[0 ])){return edges[vec[0 ]];else {return edges[vec[1 ]];return getRemoveEdge (edges);
