代码随想录刷题小记

最新推荐文章于 2024-04-21 14:39:49 发布

跳跳口香糖

最新推荐文章于 2024-04-21 14:39:49 发布

阅读量898

点赞数

文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_42109854/article/details/131669491

版权

代码随想录刷题小记😃

6月计划

1.leetcode刷到200道

2.熟悉下求图最小路径怎么写(bfs,dfs,迪杰斯特拉)

3.netco项目理清流程，底层做进一步理解，照着它的代码手撸一遍；

cin输入数组

#include <bits/stdc++.h>
using namespace std;
int main () {
 int num;
vector<int> value;
while(cin >> num) {
    value.push_back(num);
    if (cin.get() == '\n')   /这里判断条件不能写反，不然数组要少一个输入
        break;
}
    return 0;
}
如果要输入多行，且数量未知
    while(cin >> num) {
    value.push_back(num);
} 我们需要用回车 + CTRL + Z 来终止输入；测试平台会自动处理，可以提交通过。

cin.tie与sync_with_stdio加速IO

std::ios::sync_with_stdio(false);//解除C++流与C流的同步
std::cin.tie(nullptr); //解除cin与cout的绑定，加速
std::cout.tie(nullptr);

快速排序

思路：快速排序采用分治法。首先从数列中选取一个元素作为中间值。依次遍历数据，所有比中间值小的元素放在左边，所有比中间值大的元素放在右边。然后按照此方法对左右两个子序列分别进行递归操作，直到所有数据有序；

//快速排序
template <class T>
int Partition(T data[],int left,int right)
{
    T pivot=data[left];
    while(left<right)
    {
        while(left<right&&data[right]>pivot)
            right--;
        data[left]=data[right];
        while(left<right&&data[left]<=pivot)
            left++;
        data[right]=data[left];
    }
    data[left]=pivot;
    return left;
}
 
template <class T>
void QuickSort(T data[],int left,int right)
{
    if(left<right)
    {
        int p=Partition(data,left,right);
        QuickSort(data,left,p-1);
        QuickSort(data,p+1,right);
    }
 
}

215.数组中的第K个最大元素(高频面试题)

题目描述：给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
思路：先快排再找第K个元素(nlog(n))，基于快排的选择方法(O(n), O(logn))、基于堆排的选择方法、计数排序

//采用基于快速排序的选择方法
//每次分治，会选择一个元素i，把比它小的放在左边，把比它大的放在右边，那么这个元素就是第i大的元素
//如果i == nums.size() - k,那么找到结果，直接返回
//与快速排序不同，可以进行剪枝
//如果 i > nums.size() - k,那么直接在左半部分递归
//否则，在右半部分递归
//时间复杂度的期望是O(n),空间复杂度(log(n))
int result = 0;
//选择最左边的元素为基准元素，比它小的放在左边，比它大的放在右边
int Partition(vector<int>& nums, int left, int right) {
    int mid = nums[left];
    while (left < right) {
        while (left < right && nums[right] > mid)
            right--;
        nums[left] = nums[right];

        while (left < right && nums[left] <= mid)
            left++;
        nums[right] = nums[left];
    }
    nums[left] = mid;
    return left;
}
//递归快排
void QuickSort(vector<int>& nums, int left, int right, int k) {
    if (left <= right) {
        int p = Partition(nums, left, right);
        //如果刚好第K大元素，直接返回
        if (p  == nums.size() - k) {
            result = nums[p];
            return;
        //剪枝过程
        }else if (p  > nums.size() - k) {
            QuickSort(nums, left, p - 1, k);
        }else {
            QuickSort(nums, p + 1, right, k);
        }
    }
}

int findKthLargest(vector<int>& nums, int k) {
    QuickSort(nums, 0, nums.size() - 1, k);
    return result;
}

//堆排序：构建一个完全二叉树，每个节点都比它的左右孩子大，那么根节点就是最大值，然后根节点跟最后一个节点对换，在进行一次重构，继续获取第二个最大值
//算法思路：因为是一个完全二叉树，那么nums[length/2]一定是第一个叶子节点，nums[length/2-1]是最后一个非叶子节点，从最后一个非叶子节点出发，依次调整二叉树，直到根节点，那么就完成了大顶堆的构建

//一次调整
void HeapAjust(vector<int>& arr, int start, int end) {
	int tmp = arr[start];
	for (int i = 2 * start + 1; i <= end; i = i * 2 + 1)
	{
		if (i < end && arr[i] < arr[i + 1]) {//有右孩子并且左孩子小于右孩子
			i++;
		}//i一定是左右孩子的最大值
		if (arr[i] > tmp) {
			arr[start] = arr[i];
			start = i;
		}
		else {
			break;
		}
	}
	arr[start] = tmp;
}

//堆排序
void HeapSort(vector<int>& arr, int len) {
    //第一次建立大根堆，从最后一个非叶子节点出发，依次调整二叉树
	for (int i = len / 2 - 1; i >= 0; i--) {
		HeapAjust(arr, i, len - 1);
	}
    //二叉树根节点与最后一个元素对换，调整二叉树
	int tmp;
	for (int i = 0; i < len - 1; i++) {
		tmp = arr[0];
		arr[0] = arr[len - 1 - i];
		arr[len - 1 - i] = tmp;
		HeapAjust(arr, 0, len - 1 - i - 1);
	}
}

34.在排序数组中查找元素的第一个和最后一个位置

题目描述：给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
思路：看到有序和O(log(n))的要求，大概率是二分法

//二分法用于找左右边界的题目
//下面的写法都是找到target左右的第一个元素
//关键在于=号的位置
//如果等号直接返回，就是二分查找
int left = 0;
int right = nums.size() - 1;
while(left <= right) {//这里统一写法，left<=right，这样即使[left,right]也是合法区间，对于一个元素的情况，也可以考虑进去
    int mid = left + (right - left) / 2;
    if (nums[mid] >= target) {//这里如果>=,那么就到左边去找，这样会找到左边界
        right = mid - 1;
    }else {//如果<，就到右边
        left = mid + 1;
    }
}

int left1 = 0;
int right1 = nums.size() - 1;
while(left1 <= right1) {
    int mid = left1 + (right1 - left1) / 2;
    if (nums[mid] > target) {
        right1 = mid - 1;
    }else {// <=，到右边去找，这样可以找到右边界
        left1 = mid + 1;
    }
}

牛客101题

461.汉明距离

题目描述：两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

//主要是计算一个数字二进制为1的个数
    int hammingDistance(int x, int y) {
        int temp = x ^ y;
        int result = 0;
        //用右移后的结果与上一位一位的算
        for (int i = 31; i >= 0; i--) {
            if ((temp >> i) & 1) {
                result++;
            }
        }
        return result;
    }

20.数组中的逆序对

题目描述：在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

思路：归并排序的思想；归并排序时间复杂度：O(nlogn)

    int mergeSort(vector<int>& nums, vector<int>& tmp, int l, int r) {//递归归并排序并计算逆序对的数量
        if (l >= r) {//只有一个元素 这里一定是>= 不然递归会范围出问题
            return 0;
        }
        
        int mid = l + (r - l)/2;
        int inv_count = mergeSort(nums, tmp, l, mid) + mergeSort(nums, tmp, mid + 1, r);
        int i = l, j = mid + 1, pos = l; //归并排序过程，从小到大
        while(i <= mid &&j <= r) {
            if (nums[i] <= nums[j]) {//如果左边比右边小，不存在逆序对
                tmp[pos] = nums[i];
                i++;
            } else {//左边比右边大，存在逆序对，计算逆序对数量
                tmp[pos] = nums[j];
                inv_count += mid - i + 1;
                ++j;
            }
            ++pos;
        }

        for (int k = i; k <= mid; k++) {
            tmp[pos++] = nums[k];
        }

        for (int k = j; k <= r; k++) {
            tmp[pos++] = nums[k];
        }
        copy(tmp.begin() + l, tmp.begin() + r + 1, nums.begin() + l);//更新数组顺序
       	//vector迭代器一般为左闭右开
        return inv_count;  //返回当前区间逆序对数量
    }

    int reversePairs(vector<int>& nums) {
        int n = nums.size();
        vector<int> tmp(n);  //中间数组
        return mergeSort(nums, tmp, 0, n - 1);
    }

448.找到所有数组中消失的数字

题目描述：给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
思路：哈希表求解：方法一：用额外空间方法二：用原数组nums当哈希表，不用额外空间

//不用额外空间解法
//由于数组大小为n，所以联想到用数组来当作哈希表使用。nums的范围在[1-n]中，可以利用这个范围之外的数字来表达是否出现的含义
//具体来说，遍历nums，每遇到一个数x，就让nums[x-1]加n。由于nums中所有数均在[1-n]中，增加以后，这些数必然大于n。最后遍历nums，若nums[i]未大于n.就说明没有遇到数字i + 1,这样就找出了所有缺失的数字。

560.和为K的子数组

题目描述：给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的连续子数组的个数 。

思路：暴力(超时)、hash+前缀和(需要技巧，不然效率低也会超时)

//pre记录0-j的和，那么0-j+1的和可以用pre+nums[j + 1]表示
//unordered_map：key表示前缀和的值，value表示key出现的次数
//从前往后遍历，当遍历到nums[j]时，找map中是否存在nums[j] - k的值，如果存在(假设他是0-x的前缀和)，那么存在连续子数组x + 1-j的前缀和为k
//技巧：1.pre可以用一个变量表示，而不是vector
//2.unorderde_map效率高，key和value分别存储什么需要思考
//3.从头开始遍历，以j为连续子数组的结尾可以解决重复问题，如果反方向需要去重
unordered_map<int, int> mp;
int pre = 0;
int result = 0;
mp[0] = 1;//这里先插入一个虚拟0元素，不然后漏掉第一个元素，因为我们计算的时x+1-j前缀和
for (int i = 0; i < nums.size(); i++) {
    pre += nums[i];
    auto it = mp.find(pre - k);
    if (it != mp.end()) result += it->second;
    mp[pre]++;
}
return result;

33.搜索旋转排序数组

题目描述：整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
思路：二次二分法，第一次二分找到旋转的位置，第二次二分找目标值；

//自己写的一版代码
int left = 0, right = nums.size() - 1;
//二分找旋转位置，可以找到第一个比它小的位置
while(left <= right) {
    if (nums[(left + right)/2] > nums[0]) {
        left = (left + right)/2 + 1;
    }else if (nums[(left + right)/2] < nums[0]){
        right = (left + right)/2 - 1;
    }else if (nums[(left + right)/2] == nums[0]) break;
}

int k;//记录旋转位置变量
//条件很多，逐一判断
if (left == 0) {
    if (nums.size() == 1) k = -1;
    else if (nums.size() == 2){
        if (nums[1] > nums[0]) k= -1;
        else k = 0;
    }else {
        if (nums[1] > nums[0] && nums[2] > nums[1]) k= -1;
        else if (nums[1] > nums[0] && nums[2] < nums[1]) k = 1;
        else k = 0;
    }
}else {
    k = left - 1;
}

left = 0, right = nums.size() - 1;

if (k == -1) ;//没有旋转
else if (nums[0] > target) left = k + 1;//旋转的情况
else if (nums[0] <= target) right = k;
//二分查找
while(left <= right) {
    if (nums[(left + right)/2] < target) {
        left = (left + right)/2 + 1;
    }else if (nums[(left + right)/2] > target){
        right = (left + right)/2 - 1;
    }else 
        return (left + right)/2;
}
return -1;

//网友版本
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int t = nums[0];
        int l = 0, r = nums.size() - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (t > nums[mid]) r = mid - 1;
            else l = mid + 1;
        }

        if (target >= t) l = 0;
        else r = nums.size() - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (target > nums[mid]) l = mid + 1;
            else if (target < nums[mid]) r = mid - 1;
            else return mid;
        }
        return -1;
    }
};

//官方一次二分版本
//基于几个结论
//1：有序区间可以判断target在不在其中
//2:区间是否有序，在本题中可以比较区间左右端点的值
//思路：当我们把数组一分为二的时候，一定有一部分是有序的，那么可以判断有序的部分是不是包含了target，如果包含了，更新左右边界，如果不包含，更新左右边界，一直二分下去。
int left = 0, right = nums.size() - 1;
while(left <= right) {
    int mid = (left + right) / 2;
    if (nums[mid] == target) {
        return mid;
    }else if (nums[mid] <= nums[right]) {//右半部分有序
        if (target > nums[mid] && target <= nums[right])//如果target在此区间内
            left = mid + 1;
        else//不在
            right = mid - 1;
    }else {//左半部分有序
        if (target >= nums[left] && target < nums[mid])
            right = mid - 1;
        else
            left = mid + 1;
    }
}
return -1;

287寻找重复数

题目描述：
思路：原数组作为哈希表

int findDuplicate(vector<int>& nums) {
    int n = nums.size() - 1;
    for (int i = 0; i < nums.size(); i++) {
        nums[nums[i] % n] += n;//找到对应数组下标并且+n用来标记
    }

    int result;
    //找到重复数字并且恢复原数组
    for (int i = 0; i < nums.size(); i++) {
        if (nums[i] > n && nums[i] <= 2*n) {
            nums[i] %= n;
        }else if (nums[i] > 2*n){
            nums[i] %= n;
            if (i == 0)
                result = n;
            else
                result = i;
        }
    }
    return result;
}

思路：环形链表

因为数组大小为n+1，一定有一个数字([1,n])重复了一次，其他数字都出现并且只出现一次。那么可以将数组下标n和nums[n]建立一个映射关系f(n),其映射关系为n->f(n)，假设从0出发，一定会产生一个有环的类似链表结构。假设数组为[1,3,4,2,2]，那么链表可以抽象为:

那么问题就转换为求有环链表的入口问题，先用快慢指针确认有环，然后慢指针从头开始，直到和快指针相遇，相遇的节点就是环的入口。
```
int findDuplicate(vector<int>& nums) {
    int slow = 0;
    int fast = 0;
    slow = nums[slow];
    fast = nums[nums[fast]];
    while(slow != fast) {
        slow = nums[slow];
        fast = nums[nums[fast]];
    }
    slow = 0;
    while(slow != fast) {
        slow = nums[slow];
        fast = nums[fast];
    }
    //这里slow不会返回下标，而是返回入口的值(重读数)，因为一开始slow != fast
    return slow;
}
```

48.旋转图像

题目描述：给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。你必须在** 原地** 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
思路：使用矩阵当额外空间、原地旋转、先上下颠倒再沿对角线对换

//先上下颠倒再对角线对换
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int slow = 0, fast = matrix.size() - 1;
        while (slow < fast) {
            //swap可以不用额外空间
            swap(matrix[slow], matrix[fast]);
            slow++;
            fast--;
        }

        for (int i = 0; i < matrix.size(); i++) {
            for (int j = i; j < matrix.size(); j++) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
        
    }
};

//原地旋转
//对于矩阵的第一个元素，他旋转会覆盖右上角元素，右上角又会覆盖右下角元素，而右下角元素又会覆盖左下角元素，最后左下角元素覆盖第一个元素
//那么可以temp保存第一个元素，从左下角元素开始旋转，完成一个元素的旋转
//对矩阵的左上四分之子阵进行旋转即可完成整个矩阵90度旋转
class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int temp;
        int n = matrix.size();
        for (int i = 0; i < matrix.size()/2; i++) {
            for (int j = 0; j < (matrix[0].size() + 1) / 2; j++) {
                temp = matrix[i][j];
                matrix[i][j] = matrix[n - j - 1][i];
                matrix[n - j - 1][i] = matrix[n - i - 1][n - 1 - j];
                matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
                matrix[j][n - i - 1] = temp;
            }
        }
    }
};

128.最长连续序列

题目描述：给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
思路：用unordered_set来去重并处理

//首先unordered_set用来去重
//一般的方法，对于num,循环去找num+1，如果存在，那么longestStreak+1。对于每个num，都去循环找,O(n*n)
//这里其实寻找重复了，如果对于数字num，存在num-1，那么去找一遍num-1即可，因为num-1开始肯定是最长的序列。
unordered_set<int> num_set;
for (int num : nums) {//去重
    num_set.insert(num);
}
int longestStreak = 0;
for (int num : num_set){
    if (!num_set.count(num - 1)) {//如果不存在num-1了，开始循环遍历找
        int currentNum = num;
        int currentSreak = 1;

        while(num_set.count(currentNum + 1)) {
            currentNum += 1;
            currentSreak += 1;
        }
		//更新最长序列
        longestStreak = max(longestStreak, currentSreak);
    }
}
return longestStreak;

.31.下一个排列

题目描述：leetcode
思路：两边扫描(官方思路)

//自己写的一版
//思路：对于序列[1,5,6,4,2,8,7,3],后三位是递减顺序，那么后三位不管怎么调换位置，也生成不了下一个排列
//2 < 8，那么意味着可以把8,7,3中第一个比2大的元素与2对换位置，再做排序
//即[1,5,6,4,3,8,7,2]
static bool cmp (int& a, int& b) {
    return a >= b;
}
void nextPermutation(vector<int>& nums) {
    //先反转，方便处理
    reverse(nums.begin(), nums.end());
    int i = 0;
    //找到第一个逆序数字i+1
    for (i = 0; i < nums.size() - 1; i++) {
        if (nums[i] <= nums[i + 1]) {
            continue;
        }else {
            break;
    }
    //如果遍历完也没找到，那说明下一个排列就是1-n
    if (i == nums.size() - 1) {
        sort(nums.begin(), nums.end());
        return;
    }
    //找到第一个比nums[i+1]大的数字
    int j;
    for (j = 0; j <= i; j++) {
        if (nums[i + 1] < nums[j]) break;
    }
    //对换位置并且排序
    swap(nums[i + 1], nums[j]);
    sort(nums.begin(), nums.begin() + i + 1, cmp);
    //最后反转返回
    reverse(nums.begin(), nums.end());
}

49.字母异位词分组

题目描述：给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
思路：哈希表比较、排序

unordered_map<string, vector<string>> mp;
//对于异位词，排序之后是相同的，把对应的str加入到value中
for (string& str : strs) {
    string key = str;
    //sort对string排序
    sort(key.begin(), key.end());
    mp[key].push_back(str);
}
vector<vector<string>> result;
for (auto x : mp) {
    result.push_back(x.second);
}
return result;
}

155.最小栈

//辅助栈(栈里放包括当前元素以前的最小元素)
class MinStack {
public:
    MinStack() {
        //初始化辅助栈里加入一个INT_MAX便于处理栈为空的情况
        min_stack.push(INT_MAX);
    }
    
    void push(int val) {
        //push:主栈里直接push
        //辅助栈里更新当前元素的最小值
        x_stack.push(val);
        min_stack.push(min(min_stack.top(), val));
    }
    
    void pop() {
        //直接pop
        x_stack.pop();
        min_stack.pop();
    }
    
    int top() {
        //取top
        return x_stack.top();
    }
    
    int getMin() {
        //辅助栈顶元素即为最小值
       return min_stack.top();
    }
private:
    stack<int> x_stack;
    stack<int> min_stack;
};

//不使用辅助栈，用链表实现一个MIN_STACK
class MinStack {
public:
    MinStack() {
        head = nullptr;//头结点初始化
    }
    
    void push(int val) {
        //若栈空，则申请新节点空间并赋予头结点
        if (head == nullptr){
            head = new Node(val, val);
        } 
        // 若栈非空，则更新新节点的栈内元素最小值后，将新节点插入栈顶，最后更新头节点
        else {
            int tmp = val < head->min ? val : head->min;
            Node* cur = new Node(val, tmp);
            cur->next = head;
            head = cur;
        }
    }
    
    void pop() {
        // 让头节点指向自身的下一个节点即可
        // 不用管出栈之后的最小值变化，即使当前出栈元素就是最小值也无妨，
        // 因为每个节点的 min 值记录的都是栈底到此节点的元素最小值
        head = head->next;
    }
    
    int top() {
        // 直接返回头节点 val 值即可，头节点永远指向栈顶
        return head->val;
    }
    
    int getMin() {
         // 直接返回头节点 min 值即可，头节点的 min 值永远是栈内所有元素的最小值
        return head->min;
    }
private:
    //节点
    struct Node{
        int val;//节点的值
        int min;//以该节点为栈顶的栈内最小元素的值
        Node* next;//下一个节点

        Node(int x, int y) :val(x), min(y), next(nullptr) {}
    };
	//定义头结点
    Node *head;
};

21.合并两个有序链表

题目描述：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
思路：迭代、递归。

//迭代法(自己写的版本，很罗嗦，直接在l1上操作)
//如果有空链表，直接返回不为空的链表头节点
//直接在list1上操作，需要一个虚拟头节点来合并，因为插入节点需要上一个节点来操作

if (list1 == nullptr || list2 == nullptr) return list1 == nullptr ? list2 : list1;//有空的情况
ListNode* headList = new ListNode(0, list1);//虚拟节点指向list1头部
ListNode* result = list1->val > list2->val ? list2 : list1;//记录要返回的头节点
while(headList->next != nullptr) {
    if (list2 == nullptr) break;//如果list2遍历完了，那么已经合并完毕
    if (headList->next->val <= list2->val) {//如果list1当前元素比list2小，那么不需要操作，list1移到下一个节点
        if (headList->next->next == nullptr) {//如果list1下一个节点为空，那么直接指向list2的当前元素位置
            headList->next->next = list2;
            break;
        } else//否则，移动一个位置
            headList = headList->next;
    }else if (headList->next->val > list2->val) {//如果list1当前元素比list2大，需要向list1插入list2的元素
        ListNode* temp = headList->next;
        ListNode* temp2 = list2->next;//这里list2的下一个节点必须要记录
        headList->next = list2;//这里直接用原来的节点，不要new来操作，否则就是开辟新节点了
        headList->next->next = temp;
        list2 = temp2;//list2向下移动
        headList = headList->next;//继续向下移动
    }
}
return result;

//另外一个版本，比较清晰(新建一个虚拟头结点，尾部接入)
    ListNode* merge(ListNode* l1, ListNode* l2) {
        ListNode* dummyHead = new ListNode();//虚拟头结点，用于保存合并后的头结点
        ListNode* cur = dummyHead;//实际操作的虚拟头结点
        while(l1 && l2) {
            if (l1->val <= l2->val) {//如果l1比较小，那么虚拟头结点尾部插入l1
                cur->next = l1;
                l1 = l1->next;
            } else {//反之尾部插入l2
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;//节点后移
        }
        //如果其中某个链表为空，那么直接指向另一个链表遍历的位置，因为已经有序了
        cur->next = l1 ?  l1:l2;
        return dummyHead->next;
    }

//递归
//返回值，返回l1、l2合并的结果
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    //终止条件，如果l1、或者l2为空，那么直接返回
    if (l1 == NULL) {
        return l2;
    }
    if (l2 == NULL) {
        return l1;
    }
//当前层逻辑：如果l1值比较小，那么去合并(l1->next,l2)，并使l1->next去接住这个合并结果
    if (l1->val <= l2->val) {
        l1->next = mergeTwoLists(l1->next, l2);
        return l1;
    }
//如果l2值比较小，逻辑相同
    l2->next = mergeTwoLists(l1, l2->next);
    return l2;
}
};

148.排序链表

题目描述：给你链表的头结点 head ，请将其按升序排列并返回 排序后的链表 。

思路：放到数组，排序，链表重构(O((n)log(n)),O(n))。归并排序(递归、迭代)

//归并排序，递归方式(自顶向下)，需要用到栈空间O(log(n))
//递归排序主函数，先切割到最小单元，返回时进行排序回溯
ListNode* mergeSort(ListNode* head) {
    if (!head || !head->next) return head;//空或者只有一个元素，直接返回
    ListNode* mid = findMid(head);//找到链表中点
    ListNode* l1 = head;//左半部分
    ListNode* l2 = mid->next;//右半部分
    mid->next = nullptr;//给左半部分设置停止标志
    l1 = mergeSort(l1);//左右部分，别分排序
    l2 = mergeSort(l2);
    return merge(l1, l2);//将已经有序的左右部分合并
}
//找到链表中点方法，快慢指针法
ListNode* findMid(ListNode* head) {
    ListNode* slow = head, *fast = head;
    while(fast->next && fast->next->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}
//两个有序链表的合并
ListNode* merge(ListNode* l1, ListNode* l2) {
    ListNode* dummyHead = new ListNode();
    ListNode* cur = dummyHead;
    while(l1 && l2) {
        if (l1->val <= l2->val) {
            cur->next = l1;
            l1 = l1->next;
        } else {
            cur->next = l2;
            l2 = l2->next;
        }
        cur = cur->next;
    }
    cur->next = l1 ?  l1:l2;
    return dummyHead->next;
}

ListNode* sortList(ListNode* head) {
    return mergeSort(head);
}

//归并排序，自底向上，空间复杂度O(1)
//用subLength表示每次需要排序的子链表长度，初始时subLength = 1;
//每次将链表拆分为若干个长度为subLength的子链表，按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength*2的有序子链表
//将subLength的值加倍，重复第二步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于length,整个链表排序完毕
ListNode* sortList(ListNode* head) {
    if (head == nullptr) return head;
    //记录下链表长度
    int length = 0;
    ListNode* node = head;
    while(node != nullptr) {
        length++;
        node = node->next;
    }
    //定义虚拟头结点
    ListNode* dummyHead = new ListNode(0, head);
    //subLength倍数增长，直到接近length
    for (int subLength = 1; subLength < length; subLength <<= 1) {
        ListNode* prev = dummyHead, *curr = dummyHead->next;
        //将链表按照subLength分为两两一组分别去合并
        while(curr != nullptr) {
            //第一个subLength子链表
            ListNode* head1 = curr;
            for (int i = 1; i < subLength && curr->next != nullptr; i++) {
                curr = curr->next;
            }
            //第二个subLength子链表
            ListNode* head2 = curr->next;
            curr->next = nullptr;
            curr = head2;
            for (int i = 1; i < subLength && curr != nullptr && curr->next != nullptr; i++) {
                curr = curr->next;
            }
            ListNode* next = nullptr;
            if (curr != nullptr) {
                //记录两组子链表剩余元素下一个元素
                next = curr->next;
                curr->next = nullptr;
            }
            //合并两个有序链表
            ListNode* merged = merge(head1, head2);
            //有序的部分记录串联起来
            prev->next = merged;
            while(prev->next != nullptr){
                prev = prev->next;
            }
            curr = next;
        }
    }
    return dummyHead->next;
}

106.构造二叉树

给出二叉树的前序/后序、中序的遍历数组，可以唯一确定一个二叉树结构；
只有前序和后序不能确认二叉树结构；
重构思想（以后序与中序为例）：

递归实现：首先后序的最后一个元素为根节点

在中序中找到该节点，切割中序数组为左右两部分，左半部分为左子树右半部分为右子树

再来切割后序数组，以左子树的大小为依据切割

递归重构 cur -> left = Traversal(vector<int> inorderleft, vector<int> postorderleft);

cur -> right = Traversal(vector<int> inorderright, vector<int> postorderright);
优化方法；用左右数组范围替代传入vector

654.最大二叉树

1.以数组中最大元素为依据左右分割为左子树与右子树

2.思路与106相同

124.二叉树的最大路径和

题目描述：二叉树中的路径被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

路径和 是路径中各节点值的总和。

给你一个二叉树的根节点 root ，返回其 最大路径和 。

思路：递归遍历，后序；

简单的考虑一颗小树的情况：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3xMvjFlf-1689081778512)(E:\zhangfiles\markdownfile\代码随想录刷题小计\image\1685332306831.jpg)]

那么最大路径的情况可以概括为三种情况：

a+b+c：表示不联络父节点的情况或者本身是根节点

a+b a+c：递归时返回a+b 或 a+c，选择一个更优的方案返回

    int maxPathValue(TreeNode* root, int& val) {
        if (root == nullptr) return 0;
        int left = maxPathValue(root -> left, val);
        int right = maxPathValue(root -> right, val);//后序遍历
        int lmr = root -> val + max(0, left) + max(0, right);//第一种情况
        int ret = root -> val + max(0, max(left, right));//第2、3种情况
        val = max(val, max(lmr, ret));//更新最大路径值
        return ret;//注意这里只返回了第2、3情况的值，因为第一种情况没必要返回了，他不能链接父节点
    }

    int maxPathSum(TreeNode* root) {
        int val = INT_MIN;
        maxPathValue(root, val);
        return val;
    }

543.二叉树的直径

题目描述：给你一棵二叉树的根节点，返回该树的直径。二叉树的直径是指树中任意两个节点之间最长路径的长度。这条路径可能经过也可能不经过根节点 root 。两节点之间路径的长度由它们之间边数表示。
思路：后序遍历，同124的思路。

    int MaxValue = 0;
    int MaxPath(TreeNode* root) {
        if (root == nullptr) return 0;//遇到空节点，最大节点数为0
        
        int p1 = MaxPath(root->left);//左子树最大节点数
        int p2 = MaxPath(root->right);//右子树最大节点数
        MaxValue = max(p1 + p2 + 1, MaxValue);//更新最大值，中节点联结左右子树的最大值
        return max(p1, p2) + 1;//返回只连接左子树或者右子树的最大值，因为这样向上回溯才有效(路径的定义)，它不能连结父节点
    }
    int diameterOfBinaryTree(TreeNode* root) {
        MaxPath(root);
        return MaxValue - 1;
    }

94.二叉树中序遍历(Mirros)

题目描述：二叉树中序遍历(不用额外空间)

//Morris中序遍历不需要额外空间，并且是一种迭代遍历法
//通过找到前序节点来指向当前节点，一是可以遍历完左子树回到中节点，二是可以告诉我们遍历完了左子树，省去了用栈去维护。
vector<int> inorderTraversal(TreeNode* root) {
    vector<int> res;
    TreeNode* predecessor = nullptr;

    while(root != nullptr){
        //如果左子树不为空，进入左子树
        if (root->left != nullptr){
            predecessor = root->left;
            //找到前驱节点
            while(predecessor->right != nullptr && predecessor->right != root) {
                predecessor = predecessor->right;
            }
			//如果前驱节点为空，说明左子树还没遍历
            if (predecessor -> right == nullptr) {
                predecessor ->right = root;
                root = root->left;
            }else {//说明已经遍历完毕
                res.push_back(root->val);
                predecessor->right = nullptr;
                root = root->right;
            }
        }
        //左子树为空，直接进入右子树操作
        else {
            res.push_back(root->val);
            root = root->right;
        }
    }
    return res;
}

114.二叉树展开为链表

题目描述：给你二叉树的根结点 root ，请你将它展开为一个单链表：
- 展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null
- 展开后的单链表应该与二叉树 先序遍历 顺序相同。
思路：额外空间(存到数组，链表重构)、递归、迭代

//递归方法
//采用逆后续遍历方式
//在归的过程中改变指向，完成二叉树的展开
//记录之前的节点
TreeNode* pre = nullptr;
void flatten(TreeNode* root) {
    solve(root);
}
void solve(TreeNode* root){
    if (root == nullptr) return;
    solve(root->right);
    solve(root->left);
    //左孩子设为空
    root->left = nullptr;
    //右孩子挂前序节点
    root->right = pre;
    //更新前序节点
    pre = root;
}

动态规划五部曲：

1.确定dp数组以及下标的含义

2.确定递推公式

3.dp数组如何初始化

4.确定遍历顺序

5.举例推导dp数组

回溯算法

回溯三部曲

递归函数参数
递归终止条件
单层搜索的逻辑

void backtracking(参数) {
    if (终止条件) {
        存放结果；
        return;
	}
for (选择：本层集合中元素(树中节点孩子的数量就是集合的大小)) {
    处理结点；
        backtracking(路径，选择列表)； //递归
        回溯，撤销处理结果
	}
}

77.组合

题目描述：给定两个整数n和k，返回1-n中所有可能的k个数的组合。
思路：回溯算法递归遍历。

递归函数的返回值及参数：

vector<vector<int>> result;
vector<int> tmp;
void backtracking(int n, int k, int index)//index用来标记本层递归的起始位置
    回溯算法中一般返回值为void

终止条件：

if (tmp.size() == k) {
    result.push_back(tmp);  
    return;
}

单层逻辑：

回溯法的搜索过程就是一个树型结构的遍历过程，可以看出for循环用来横向遍历，递归的过程是纵向遍历。
    for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
    path.push_back(i); // 处理节点
    backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    path.pop_back(); // 回溯，撤销处理的节点
}

优化思路：当i-n之间的元素个数不足我们需要的组合时，比如n = 4， k = 4，那么当i = 2是没有意义的。所以比较剩余元素个数和需要元素的个数，进行剪枝优化。

已经选择的元素个数：path.size();
所需需要的元素个数为: k - path.size();
列表中剩余元素（n-i）+ 1 >= 所需需要的元素个数（k - path.size()）
在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

216.组合总和Ⅲ

题目描述：找出所有相加之和为n的k个数的组合。组合中只允许含有1-9个正整数，并且每种组合中不存在重复数字。

所有数组都是正数，解集不能包含重复的组合。
思路：在回溯算法求所有排列结果的基础上挑选出和为n的排列。

递归函数参数：

vector<vector<int>> result;
vector<int> tmp; //可以作为参数传入 但浪费空间
void backtracking(int n, int k, int index, int sum);

终止条件：

if (tmp.size() == k) {
    if (sum == n) result.push_back(tmp);
    return; // 如果path.size() == k 但sum != targetSum 直接返回
}

单层逻辑：

for (int i = index; i <= 9; i ++) {
    tmp.push_back(i);
    backtracking(n, k, i + 1, sum + i);
    tmp.pop_back();
}

剪枝

17.电话号码的字母组合

给定一个仅包含数字2-9的字符串，返回所有它能表示的字母组合。（对于重复数字，后台认为"ab"和"ba"不相同，这点使得这个题比较简单）
思路：先用数组保存每个数字对应的字母字符串，然后用回溯算法求解。
递归函数参数：

void backtracking(string digits, int index);
if (tmp.size() == digits.size()) {
    result.push_back(tmp);
    return;
}

单层逻辑：

        for (int i = 0; i < dic[digits[index] - '0'].size(); i++) {
            tmp.push_back(dic[digits[index] - '0'][i]);
            backtracking(digits, index + 1);
            tmp.pop_back();
        }
    }

39.组合总和

题目描述：给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有使数字和为target的组合。(candidates中的数字可以无限制重复被选取)
思路：回溯搜索，与216的不同点在于本题可以重复选取数字。
递归函数参数：

void backtracking(vector<int> nums, int target, int index);//index是为了去重

终止条件：

 if (sum > target) {
            return;
        }
        if (sum == target) {
            result.push_back(tmp);
            return;
        }

单层逻辑：

        for (int i = index; i < nums.size(); i++) {
            tmp.push_back(nums[i]);
            backtracking(nums, target - nums[i], i); //去重逻辑
            tmp.pop_back();
        }

去重逻辑：在216中，i = index; backtracking(i + 1)，来实现组合的不重复，但是数字不能重复。如果想要数字可以重复，可以写为 i = index; backtracking(i）来实现。（简单粗暴的理解方式）

40.组合总和Ⅱ

题目描述：给定一个集合candidates和一个目标数字target，找出candidate中所有使数字和为target的组合。candidates中的每个数字只能使用一次。
与39组合总和的异同点：

39:元素不重复，但可以重复使用

本题：元素重复，但是不可以重复使用

都要找到和为target的组合，但是组合之间不能重复。

思路：回溯算法搜索。本题跟216类似，只不过需要添加去重逻辑，这种排列组合题去重逻辑一定要在回溯的过程中去重，不然很容易超时。去重套路跟之前题目类似：先排序，然后在a的循环中，如果candidates[i] == candidates[i - 1],continue,因为a如果重复，那么后续得到的组合可能导致重复，所以这样可以实现对a的去重，然后递归实现对b、c、d位置的去重。
```
        for (int i = index; i < candidates.size() && (target - candidates[i] >= 0); i++) {
            if (i > index && candidates[i] == candidates[i - 1]) // 去重逻辑 当前组合位置去重
                continue;
            path.push_back(candidates[i]);
            backtracking(candidates, target - candidates[i], i + 1);
            path.pop_back();
        }
```

131.分割回文串

题目描述：给定一个字符串s，请将s分割成一些子串，使每个子串都是回文串。返回所有的分割方案。
思路：所有分割方案，这种题一般采用暴力搜索，所以用回溯算法来搜素。
递归函数返回值

    vector<vector<string>> result;//存放结果
    vector<string> tmp;//存放回文子串，存放中间结果
    void backtracking(string s, int index)//index：用来避免重复切割，与组合的index作用一样

终止条件：

        if (index == s.size()) {
            result.push_back(tmp);
            return;
        }

单层逻辑：

        string a = "";//存放当前层 子串的切割方法
        for (int i = index; i < s.size(); i++) {
            a = a + s[i];
            string b = a;  //直接判断 当前切割子串是否为回文，不是continue，是的话再放入中间结果
            reverse(b.begin(), b.end());//可以自己写函数，用双指针法优化
            if (a == b) {
                 tmp.push_back(a);
                 backtracking(s, i + 1);
                tmp.pop_back();
            }
        }

93.复原IP地址

**题目描述：**给定一个只包含数字的字符串，复原它并返回所有可能的IP地址格式。有效的IP地址正好由四个整数(每个整数位于0到255之间组成，且不能含有前导0)，整数之间用’.'分隔。

思路：这种问题还是需要回溯算法遍历求解，与131类似。

递归函数返回值：

 vector<string> result;
 vector<string> path;
void backtracking(string s, int index); //index为了不重复选取

终止条件：

        if (path.size() == 4 && index == s.size()) {
            result.push_back(path[0] + '.' + path[1] + '.' + path[2] + '.' + path[3]);
            return;
        }
        if (path.size() > 4)
            return;

单层逻辑：

        string a = "";
        for (int i = index; i < s.size(); i++) {
            a += s[i];
            if (isIp(a)) {
            path.push_back(a);
            backtracking(s, i + 1);
            path.pop_back();
            }
        }
    }
    bool isIp(string s) { //判断当前字符是不是合法IP
        if (s.size() > 3)
            return false;
        if (s[0] == '0' && s.size() >= 2)
            return false;
        if (stoi(s) > 255)//字符串转int
            return false;
        return true;
    }

78.子集

题目描述：给定一组不含重复元素的整数数组nums，返回该数组所有可能的子集。(解集不能包含重复的子集)
思路：如果把子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！
递归函数参数：

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex); //index为了不重复选取

终止条件：

result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }

单层逻辑：

for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }

90.子集Ⅱ

题目描述：给定一个整数数组nums，其中可能包含重复元素，请返回该数组所有可能的子集。解集不能包含重复的子集。
思路：与78相同，多了一个去重逻辑。

去重逻辑：与大多数的回溯算法去重套路相同，先排序，然后遇到连续相同的数，第一个进入循环，后续的跳过。

        for (int i = index; i < nums.size(); i++) {
            if (i > index && nums[i] == nums[i - 1]) //去重逻辑
                continue;
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }

491.递增子序列(重要)

题目描述：给定一个整形数组，你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。(数组中可能包含重复数组，相等的数字被视为递增的一种情况)
思路：找到所有满足条件的组合，注意这个子序列是有顺序的，所以之前的排序去重套路失效！！转而使用used数组或者set。
递归函数参数：

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) //index为了不重复选取

终止条件：

if (path.size() > 1) {
    result.push_back(path);
    // 注意这里不要加return，因为要取树上的所有节点
}

单层逻辑

unordered_set<int> uset; // 使用set来对本层元素进行去重
for (int i = startIndex; i < nums.size(); i++) {
    if ((!path.empty() && nums[i] < path.back())
            || uset.find(nums[i]) != uset.end()) {
            continue;
    }
    uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
    path.push_back(nums[i]);
    backtracking(nums, i + 1);
    path.pop_back();
}

46.全排列

题目描述：给定一个不含重复数字的数组nums，返回其所有可能的排列。

递归函数参数：

vector<vector<int>> result;
vector<int> tmp; //可以作为参数传入
void backtracking(vector<int> nums, vector<bool> index)

递归终止条件：

if (tmp.size() == nums.size()) 
	return;

单层逻辑：

for (int i = 0; i < nums.size(); i++) {
    if (index[i]) {
        tmp.push_back(nums[i]);
        index[i] = false;
        backtracking(nums, index);
        index[i] = true;
        tmp.push_back();
    }
}

47.全排列Ⅱ

题目描述：给定一个可包含重复数字的序列nums，按任意顺序返回所有不重复的序列。

思路：与全排列思路类似，只不过需要加去重逻辑。

        for (int i = 0; i < nums.size(); i++) {
            //去重逻辑   注意先排序，如果后一个数等于前一个 跳过  
            if (i > 0 && nums[i] == nums[i - 1] && index[i] && index[i-1])
                continue;
            
            if (index[i]) {
                index[i] = false;
                tmp.push_back(nums[i]);
                backtracking(nums, index);
                index[i] = true;
                tmp.pop_back();
            }
        }

51.N皇后

题目描述：N皇后问题
思路：棋盘的每一行代表一次递归层，通过回溯遍历所有条件，根据条件判定是否进入下一层回溯，有点套路化。
递归参数：

vector<vector<string>> result;
vector<string> path(n, string(n, '.'));//实际代码全局变量不能再此初始化
void backtracking(int n, int count)；

终止条件：

if (count == n) {
      result.push_back(path);
      return;
 }

单层逻辑：

for (int i = 0; i < n; i++) {
      if (islegal(count, i, n)) {
      path[count][i] = 'Q';
       backtracking(n, count + 1);
       path[count][i] = '.';
          }
}

判断是否合法函数：这里比实际求对角线是否有皇后简单了一点，因为我们是逐层往下递归，只需要判断前面的对角线是否有皇后。

    bool islegal(int count, int i, int n) {
        for (int j = 0; j < n; j++)
            if (path[j][i] == 'Q')
                return false;       
        for (int j = count - 1,  k = i - 1; j > -1 && k > -1; j--, k--) {
            if (path[j][k] == 'Q')
                return false;
        }
        for (int j = count - 1,  k = i + 1; j > -1 &&  k < n; j--, k++) {
            if (path[j][k] == 'Q')
                return false;
        }
        return true;
    }

37.数独

题目描述：填充空格来解决数独问题。
思路：这种问题一般需要穷举，所以考虑回溯遍历找解。与之前的递归不一样，比如N皇后问题，一行只能放一个皇后，而这道题一行要放九个数字，所以单层递归里面一个for循环是不够的，需要两层for循环来求解。
递归函数参数：

bool backtracking(vector<vector<char>>& board);//这道题要直接修改board

终止条件：本题的代码随想录写法不需要终止条件，因为通知bool的返回来判断是否找到解了。
单层逻辑：

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] != '.') continue;
            for (char k = '1'; k <= '9'; k++) {     // (i, j) 这个位置放k是否合适
                if (isValid(i, j, k, board)) {
                    board[i][j] = k;                // 放置k
                    if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                    board[i][j] = '.';              // 回溯，撤销k
                }
            }
            return false;                           // 9个数都试完了，都不行，那么就返回false
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}

判断合法函数：

   bool isvalid(int row, int col, char val, vector<vector<char>>& board) {
       for (int i = 0; i < 9; i++) {
           if (board[row][i] == val)
            return false;
       }
       for (int i = 0; i < 9; i++) {
           if (board[i][col] == val)
            return false;
       }
       int startRow = (row / 3) * 3;
       int startCol = (col / 3) * 3;
       for (int i = startRow; i < startRow + 3; i++) {
           for (int j = startCol; j < startCol + 3; j++) {
               if (board[i][j] == val)
                return false;
           }
       }
       return true;
   }

22.括号生成

题目描述：数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
思路：回溯(需要剪枝)

//括号问题有个规律：如果')'数量大于'('，那么一定组不成合法括号
//如果从头开始组成合法括号，一直满足上述条件，那么最后的结果就是合法括号

//注意这里回溯的写法，与求排列不同，根据当前左右括号数进行添加，而不是一个一个去添加
void backtracking(string temp, vector<string>& result, int i, int j) {
    if (i < 0 || j < 0) return;
    if (i == j && i == 0) {//左右括号用完，合法括号
        result.push_back(temp);
        return;
    }else if (i == j) {//左右括号数量相等，下一个只能添加左括号
        backtracking(temp + '(', result, i - 1, j);
    }else if (i < j) {//左括号数量多，那么下一个左右括号都行
        //temp+'('隐含了回溯的过程
        backtracking(temp + ')', result, i, j - 1);

        backtracking(temp + '(', result, i - 1, j);
    } else
        return;
}

vector<string> generateParenthesis(int n) {
    vector<string> result;
    backtracking("", result, n, n);
    return result;
}

贪心算法

455.分发饼干

题目描述：你是一个家长，要给孩子们分发食物，g[i]表示每个孩子的胃口值，s[i]表示每个饼干的尺寸，求出尽可能喂饱孩子的数量。
思路：用尽可能小的饼干去满足小胃口的孩子。先排序胃口和饼干，然后遍历饼干，去喂胃口小的孩子。

376.摆动序列

题目描述：有一个数组，求出该数组中为摆动序列的最长子序列的长度。
思路：贪心算法；找到数组的波峰和波谷，计算有摆动的位置。

这道题Leetcode官方题解好理解一点

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int n = nums.size();
        if (n < 2) {
            return n;
        }
        int prevdiff = nums[1] - nums[0];
        int ret = prevdiff != 0 ? 2 : 1;  //当数组大小为2时，等式显然；
        //当数组大小大于2，nums[0] != nums[1]，当出现摆动result + 2;
        //当nums[0] == nums[1], 属于平坡情况，当出现摆动result + 1;
        for (int i = 2; i < n; i++) {
            int diff = nums[i] - nums[i - 1];
            if ((diff > 0 && prevdiff <= 0) || (diff < 0 && prevdiff >= 0)) {
                ret++;
                prevdiff = diff;//这里有摆动才更新orediff的原因是因为出现单调坡的时候，一直更新会出现问题
            }
        }
        return ret;
    }
};

53.最大子数组和

问题描述：给定一个整数数组，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
贪心策略：从头开始计算累加和，如果累加和为负数，那么舍弃掉这个累加和，从下一个数重新计算；同时result要不断更新得到的最大子序列和。

public:
    int maxSubArray(vector<int>& nums) {
        int sum = 0;
        int result = -100000;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];      //子序列和
            result = max(sum, result);//更新结果数组
            if (sum < 0) //如果和为负数，那么从下一个数开始计算
                sum = 0;
        }
        return result;
    }

55.跳跃游戏

题目描述：给定一个非负整数数组，你最初位于数组的第一个位置，数组中的每个元素代表你在该位置可以跳跃的最大长度，判断你是否能够达到最后一个位置。
思路：不拘泥于具体的跳跃过程，计算覆盖范围，从第一个数字的覆盖范围开始，计算后续范围内的最大覆盖范围，不断更新覆盖范围，如果最大覆盖范围能够包含最后一个数字，那么返回true;

    bool canJump(vector<int>& nums) {
        int right = 0;//覆盖范围
        for (int i = 0; i <= right; i++) {
            right = max(i + nums[i], right);//更新覆盖范围
          if (right >= nums.size() - 1) //如果能够包含最后一个元素，那么返回true;
            return true;   
        }
        return false;
    }

45.跳跃游戏Ⅱ

题目描述：于55类似，本题求跳到最后一个位置的最少步数（测试用例保证可以跳到最后一个位置）。
思路：同样不要拘泥于具体在哪个位置跳，只判断覆盖范围，当i到达上一跳的最大范围时，如果没达到终点，那么更新最大范围，步数+1，继续循环，否则结束输出结果。

int jump(vector<int>& nums) {
        if (nums.size() == 1) return 0;
        int curDistance = 0;    // 当前覆盖最远距离下标
        int ans = 0;            // 记录走的最大步数
        int nextDistance = 0;   // 下一步覆盖最远距离下标
        for (int i = 0; i < nums.size(); i++) {
            nextDistance = max(nums[i] + i, nextDistance);  // 更新下一步覆盖最远距离下标
            if (i == curDistance) {                         // 遇到当前覆盖最远距离下标
                ans++;                                  // 需要走下一步
                curDistance = nextDistance;             // 更新当前覆盖最远距离下标（相当于加油了）
                if (nextDistance >= nums.size() - 1) break;  // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
            }
        }
        return ans;
    }

1005.K次取反后最大化的数组和

题目描述：给定一个数组A，选择某个下标i并将nums[i]替换为-nums[i]，重复这个过程k次，可以多次选择同一个下标i。以这种方式修改数组后，返回数组最大的可能和。
思路：如果数组存在负数，那么先反转负数(绝对值大的负数)，如果负数都反转完了，将最小的正数反转剩下的次数。
解题步骤：

第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小

第二步：从前向后遍历，遇到负数将其变为正数，同时K–

第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完

第四步：求和

134.加油站

题目描述：在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
思路：暴力解法：遍历每个加油站，判断从当前加油站出发是否能转一圈（不用考虑逆向转圈，如果正向不能转一圈，那么逆向也不会有一个路径），for循环适合线性结构，首尾相连可以用while。
贪心：记录每个加油站剩余汽油，res[i] = gas[i] - cost[i]，i从0开始累加res[i],如果res[i]小于0，那么从下一个位置开始重新计算。

    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        for (int i = 0; i < gas.size(); i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {   // 当前累加rest[i]和 curSum一旦小于0
                start = i + 1;  // 起始位置更新为i+1
                curSum = 0;     // curSum从0开始
            }
        }
        if (totalSum < 0) return -1; // 说明怎么走都不可能跑一圈了
        return start;
        //这里之所以可以直接返回start,是因为total > 0,那么就证明start到最后一站的剩余油量一定大于0到start的剩余油量，可以保证汽车跑一圈。
    }

135.分发糖果

题目描述：老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。你需要按照以下要求，帮助老师给这些孩子分发糖果：

每个孩子至少分配到 1 个糖果。

相邻的孩子中，评分高的孩子必须获得更多的糖果。

那么这样下来，老师至少需要准备多少颗糖果呢？
思路：这是属于两边要兼顾的题目，需要考虑孩子左右两边得分情况。先从左边遍历，如果当前孩子比左边高，那么candys[i] = candys[i - 1] + 1；同理，再从右边遍历；最后取两个结果的最大值，表示同时满足两个条件。

860.柠檬水找零

题目描述：
在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
思路：当顾客给5元，不需要找零；当顾客给10元，只能找5块的零钱；当顾客给20元，有两种选择；3个五元，1个五元和一个10元。贪心思路，贪在第三种方式，优先找1个五元和10元的，因为5元更万能，既可以找零10元，又可以找零20元，类似于喂小孩子饼干的题目，用尽可能小的饼干去喂饱小孩子，这里是用尽可能面值大的钱去找零。

 bool lemonadeChange(vector<int>& bills) {
     //自己写的一版用的unordered_map,但其实这种找零的情况只有两种，5元和10元，用数组或者变量就足够
       int five = 0;
       int ten = 0;
       int twenty = 0;

       for (int bill : bills) {
           if (bill == 5) five++;

           if (bill == 10) {
               if (five <= 0) return  false;
               ten++;
               five--;
           }

           if (bill == 20) {
               if (five >= 1 && ten >=1) {
                   five--;
                   ten--;
               } else {
                if (five <= 2) return false;
                   five -= 3;
               }
           }

       }
       return true;

406.根据身高重建队列(不好想)

题目描述：
思路：有点类似于分发糖果的题目，先按照一个方向去贪心，然后根据另一个方向去调整结果；先按照身高从大到小排序，如果身高一样，按照K的值从小到大排序。然后从头开始遍历，按照K的值来插入。

在按照身高从大到小排序后：优先按照身高高的人的k来插入，这样后续节点的插入不会影响之前的结果，最终按照k的规则实现了队列。

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

    static bool cmd (vector<int> a, vector<int> b) {//排序规则
        if (a[0] != b[0])
            return a[0] > b[0];
        return a[1] < b[1];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        vector<vector<int>> queue;//注意这里不要初始化大小，因为插入操作会增加size
        sort(people.begin(), people.end(), cmd);
        for (int i = 0; i < people.size(); i++) {
            int position = people[i][1];//获取当前people的位置
            queue.insert(queue.begin() + position, people[i]);
        }
//用的vector数组，底层时数组实现，插入效率很低，可以改用list，底层实现时链表，插入效率很高
        return queue;
    }

452.用最少数量的箭引爆气球

题目描述：
思路：类似于406问题思路，先排序，后续跟进处理。将左边界从小到大排序。index = points[0][1],循环处理，如果index大于下一个气球的左边界，下一个气球可以一起射爆，index = min(index, points[i][1]);反之，index = points[1], result++;

    static bool cmp(vector<int> &a, vector<int> &b) {//这里最好加上引用 会提高运行速度
        return a[0] < b[0];
    }

    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(), points.end(), cmp);
        int result = 1;//初始需要一只箭
        int index = points[0][1];
        for (int i = 0; i < points.size(); i++) {
            if (index >= points[i][0]) {//如果可以一起射爆，那么更新右边界
                index = min(index, points[i][1]);
            }else {//不能一起射爆，箭数+1，更新有边界
                index = points[i][1];
                result++;
            }
        }
        return result;
    }

435.无重叠区间

题目描述：给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意: 可以认为区间的终点总是大于它的起点。区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
思路：贪心思路贪在哪儿？：先按照左边界从小到大排序，然后从头开始遍历，如果当前区间的左边界大于前一个区间的右边界，那么这两个区间一定交叠，必须要删除一个区间，那么我们贪心的策略在于：删除右边界大的那个区间。

    static bool cmp(vector<int>& a, vector<int>& b) {
        return a[0] < b[0];
    }
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end(), cmp);
        int result = 0;
        int left = intervals[0][1];
        for (int i = 0; i < intervals.size() - 1; i++) {
            if (left > intervals[i + 1][0]) {//如果区间有交叠
                left = min(left, intervals[i + 1][1]);//相当于删除右边界较大的区间
                result++;
            }else //否则更新新边界
                left = intervals[i + 1][1];
        }
        return result;
    }

763.划分字母区间

字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。返回一个表示每个字符串片段的长度的列表。
思路：没有很符合贪心算法的特性；
笨方法：创建hash数组，计算所有出现的字母频次。定义left、right边界，从头开始遍历，如果当前字母及之前所有字母他们的频次都用完了，那么输出一个length = right - left + 1;更新左右边界。
代码随想录(代码很巧妙)：在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了。此时前面出现过所有字母，最远也就到这个边界了。
统计每一个字符最后出现的位置
从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

    vector<int> partitionLabels(string s) {
        int hash[27] = {0};//hash数组，注意最好不用vector
        for (int i = 0; i < s.size(); i++) {
            hash[s[i] - 'a'] = i;//很巧妙地去统计字母最后出现的位置
        }
        vector<int> result;
        int left = 0;
        int right = 0;
        for (int i = 0; i < s.size(); i++) {
            right = max(right, hash[s[i] - 'a']);//当前字母以前的最大出现位置
            if (i == right) {//当前位置到达最大位置
                result.push_back(right - left + 1);//输出一次结果
                left = i + 1;//更新左边界
            }
        }
        return result;
    }

56.合并区间

题目描述：给出一个区间的集合，请合并所有重叠的区间。
思路：与452、435类似；先按左边界从小到大排序；初始化左右边界，从头开始遍历，如果当前区间与下一个区间重叠，那么就合并这两个区间(取两个区间右边界的最大值、左边界的最小值)；

    static bool cmp(vector<int>& a, vector<int>& b) {
        return a[0] < b[0];
    }
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end(), cmp);
        vector<vector<int>> result;
        int left = intervals[0][0];//初始化左边界
        int right = intervals[0][1];//初始化右边界
        for (int i = 1; i < intervals.size(); i++) {
            if (right >= intervals[i][0]) {//如果两个区间重叠
                right = max(right, intervals[i][1]);//合并两个区间
            } else {//如果不重叠
                result.push_back({left, right});//输出不重叠区间
                left = intervals[i][0];
                right = intervals[i][1];
            }
        }
        result.push_back({left, right});
        return result;
    }

738.单调递增的数字

题目描述：给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。
思路：暴力解法，n–，每次去判断这个数字是否满足；

贪心：从后往前遍历，如果当前位小于前一位，那么当前位为9，前一位减一；这里存在一个问题，比如100，会输出90；所以需要设置一个标志位，记录当前置9的位，如果当前位被置9，那么后面所有位都要置9；

    int monotoneIncreasingDigits(int n) {
        string strNum = to_string(n);
        int flag = strNum.size();//初始化标志位
        for(int i = strNum.size() - 1; i > 0; i--) {
            if (strNum[i - 1] > strNum[i]) {
                strNum[i - 1]--;
                flag = i;//更新标志位
            }
        }
        for (int i = flag; i < strNum.size(); i++) {
            strNum[i] = '9';//置9的位及后面所有位都置9
        }
        return stoi(strNum);
    }

968.监控二叉树

题目描述：给定一个二叉树，我们在树的节点上安装摄像头。节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。计算监控树的所有节点所需的最小摄像头数量。
思路：让叶子节点的父节点安装摄像头，以此为依据，继续安装，直到所有节点都被监控；
难点：二叉树的遍历、节点信息的传递
遍历顺序：我们需要知道节点左右孩子的状态来判断当前节点的状态，所以需要后序遍历；
返回值：关键的一点，把节点状态分类：无覆盖、有摄像头、已覆盖；
细节：当遇到空节点返回？应该返回已覆盖
最后判断头节点，会不符合设定的逻辑，比如出现无覆盖的情况，可以再判断一次或者添加虚拟头结点；

class Solution {
private:
    int result;
    int traversal(TreeNode* cur) {
        if (cur == NULL) return 2;//遇到空节点，返回已覆盖
        int left = traversal(cur->left);    // 左
        int right = traversal(cur->right);  // 右
        if (left == 2 && right == 2) return 0;//这里状态分类是精简化的结果
        else if (left == 0 || right == 0) {
            result++;
            return 1;
        } else return 2;
    }
public:
    int minCameraCover(TreeNode* root) {
        result = 0;
        if (traversal(root) == 0) { // 最后还要判断root的状态 root 无覆盖
            result++;
        }
        return result;
    }
};

581.最短无序连续子数组

题目描述：给你一个整数数组 nums ，你需要找出一个 连续子数组 ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。请你找出符合题意的最短子数组，并输出它的长度。

思路：类似于身高排队问题，要确定两端的位置，可以一端一端去确定，可以避免顾此失彼的问题。

int leftMax = -1000000;
int rightMin = 1000000;
int left = nums.size() - 1;//左端极限情况
int right = 0;//右端极限情况
//先确定右端位置，循环从左到右遍历，如果当前元素比左边元素小，那么更新右端位置，因为这个元素肯定需要重新排序
for (int i = 0; i < nums.size(); i++) {
    if (nums[i] > leftMax) {
        leftMax = nums[i];
    }else if (nums[i] < leftMax){
        right = i;
    }
}
//相同思路确定左端位置
for (int i = nums.size() - 1; i >= 0; i--) {
    if (nums[i] < rightMin) {
        rightMin = nums[i];
    }else if (nums[i] > rightMin){
        left = i;
    }
}
//right <= left表示数组有序，否则输出子数组大小
return right > left ? right - left + 1 : 0 ;

背包问题系列(01背包和完全背包)

01.背包理论基础

1.dp数组含义：dp[i][j] 表示 0 - i 的物品任意放在容量j的背包里

2.递推公式：不放物品idp[i-1][j]

放物品dp[i-1][j-weight]+value[i]

dp[i][j]取上述两种情况最大值

3.dp数组初始化：背包容量为0的列初始化为0

物体为0的行初始化：如果背包容量可以装下则初始化为value[0]否则初始化为0

4.遍历顺序：对于二维数组的01背包问题，先遍历背包或者物品都行

01.背包理论基础(滚动数组)

1.dp数组含义：dp[j] 容量为j的背包能装的最大价值

2.递推公式：dp = max(dp[j], dp[j - weight[i]] + value[i])

初始化:dp[0] = 0

0416.分割等和子集

题目描述：给出一个只包含正整数的非空数组，判断时候可以分割为两个子集，使得两个子集的元素和相等。
思路：动态规划；判断能付否将数组元素大小的物体装入背包，使背包装的价值最大
背包的容量为sum/2,物品的重量和价值都为数组元素大小
当背包价值最大，如果最大价值等于背包容量，那么return true;

1049.最后一块石头的重量

题目描述：有一堆石头，用整数数组表示；每一回合，从中任意选出两个石头，将他们一起粉碎，有两种情况：

x==y 两个石头完全粉碎

x<y 产生新石头，y-x
思路：本质是一个石头分堆问题，当两堆石头质量越接近，那么相撞后剩余的小石头质量越小
转化为背包问题，设置背包容量为sum/2,找到价值最大的解即为其中一堆石头的重量，总重量减去即为另一堆石头的重量，最后计算相撞的结果。

494.目标和

题目描述：给你一个非负整数数组，一个目标target；对数组中的每个整数前添加+或-,然后串联起来，构成一个表达式，使得运算结果等于target，给出有多少种方法构造；
思路：这是动态规划的另一种应用方式；经典的动态规划为背包最大值问题；这道题转化为装满容量为j的背包的种类问题；
dp[i][j]：从0-i物品中任意选取装满容量为j的背包有多少种选法

递推公式：

dp[i][j] = dp[i - 1][j - nums[i - 1]] + dp[i - 1][j] if j >= nums[i - 1]
dp[i][j] = dp[i - 1][j] if j < nums[i - 1]

注意此处nums[i-1]而不是nums[i],因为我们初始化dp数组大小为nums.size() + 1;

初始化：dp[0][0]=1其他为0；因为在此题中空数组的情况，这种情况下可能满足最后的计算和为target;
遍历顺序：同基础01背包；但是需要注意，题解初始化第一行，所以j = 0遍历顺序；

而经典背包问题初始化一行一列，所以j=1遍历顺序，但两者等效；

剪枝/去掉异常数据：

        if (sum + target < 0 || (sum + target) % 2 == 1) {
            return 0;
        }

474.一和零

题目描述：
给你一个二进制字符数组strs和两个整数m和n；请你找出并返回strs的最大子集的长度，该子集中最多有m个0和n个1。
思路：该题是经典01背包问题的另一个应用；背包的容量从一维扩展成二维，问题转化为在二维背包容量下，最多装多少个物品，或者最大价值是多少(每个物品的价值都为1)。
dp[i][j]:在容量为i j的情况下，背包最大价值

递推公式：

dp[i][j] = max(dp[i][j], dp[i - count0][j - count1] + 1) if i >= count0 && j >= count1

初始化：整体初始化为0
遍历顺利：倒序遍历，同01背包滚动数组解法

02.完全背包理论基础

与01背包的区别：完全背包一个物品可以取多次放入背包；
dp[i][j]:容量为j的背包，0-i个物品任意放的最大价值(每个物品数量不限)
递推公式：
```
dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i])
```
注意其中的区别：当放得下物品i时，要状态转移到同层，区别于01背包状态转移到上一层；
遍历顺序：与01背包相同

采用滚动数组与01背包的区别：背包容量需要顺序遍历、两层for循环可以颠倒(仅限纯完全背包问题)

	vector<int> weight = {1, 3, 4};
    vector<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++) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }

518.零钱兑换Ⅱ

题目描述：给你一个整数数组coins表示不同面额的硬币，另有一个整数amount表示总金额，计算并返回可以凑成总金额的硬币组合数。
思路：与494目标和类似，不过本问题是多重背包问题，因为不同面额的硬币有无数个；
dp[j]:装满背包j一共有多少种方法；
递推公式：dp[j] += dp[j - coins[i]];
初始化：dp[0] = 1;有争议，leetcode后台数据指定为0，如果为0，那么dp数组全部为0，没有意义；
遍历顺序：先遍历物品，再遍历背包(组合数)；如果先背包，再物品得到的是组合数；
通过二维dp数组的递归规律判断滚动数组的遍历顺序；

377组合总和(与518很像，不过这是一个排列问题，后续再搞懂具体原理3/30)

题目描述：给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的个数。(不同的排列当作不同的结果)
思路：多重背包问题：先遍历背包再遍历物品

70.爬楼梯(完全背包求解)

思路：与377题是一样的题目；

322.零钱兑换

题目描述：给定不同面额的硬币coins和一个总金额amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回-1，每种硬币的数量是无限的。
思路：与377类型相同；采用dp数组迭代求解，需要注意一些细节技巧；
dp[j]:装满容量为j的背包最少物品数量

递推公式：

dp[j] = min(dp[j], dp[j - coins[i]] + 1)

初始化：需要一些技巧,用INT_,MAX来表示无法凑成面额，最后需要进行一步检测。

vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;
...
if (dp[amount] == INT_MAX) return -1;
return dp[amout];

遍历顺序：先遍历物品、先遍历背包都可以；先遍历物品表示组合数，先遍历背包表示排列数。对于本题最小硬币数量来讲，结果是一样的。

279完全平方数

题目描述：给定正整数n，找到若干个完全平方数(如1，4，9，16)使得他们的和等于n。你需要让组成和的完全平方数的个数最少。
思路：此题与322题完全相同，此题可能不会出现找不到组合的情况。

139.单词拆分

题目描述：给定一个字符串s和一个字符串列表wordDict作为字典。请判断是否可以利用字典中出现的单词拼接出s。(字典中的单词可以重读使用，不要求字典中的单词全部使用)
dp[j]：s字符串0-j的子串可不可以被拼接；
递推公式：

dp[j] = if (dp[i] == true && st.find(substr(i, j -i) != st.end())   0 < i < j

初始化：dp[0] = true , 其他为false; 无明显含义，单纯为了递推公式推导；
遍历顺序：先遍历容量，再遍历子串是否能组成(判断条件)；
这道题不要去套完全背包，单纯看作一个dp问题来看。

打家劫舍系列

0198.打家劫舍

题目描述：你是一个小偷，不能偷相邻房间的钱。给定一个代表每个房屋存放金额的非负整数数组，计算不被抓的情况下，能偷到的最大金额；
思路：动态规划问题
dp[j]:偷0-j个房间得到的最大金币数量
```
dp[j] = max(dp[j - 1], dp[j - 2] + value[i])
```
初始化：dp[0] = value[0] dp[1] = max(dp[0], dp[1])
遍历顺序：顺序遍历

0213.打家劫舍Ⅱ

题目描述：0198基础上，房子是一个环形的：第一个房子跟最后一个房子是挨着的。
思路：分为考虑偷第一间房子和不考虑第一间房子两种情况。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mrCpxciJ-1689081778514)(E:\zhangfiles\markdownfile\代码随想录刷题小计\image\image-20230404113315966.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Glpg0XBB-1689081778515)(E:\zhangfiles\markdownfile\代码随想录刷题小计\image\image-20230404113342805.png)]

337.打家劫舍Ⅲ

题目描述：偷的房间结构为一个二叉树，相邻结点不能被偷；求最大可偷金额；
思路：二叉树动态规划与常规数组动态规划有所不同

dp[0] dp[1]:当前结点偷与不偷可以获得的最大金额；

dp[0] = max(left[0] , left[1]) + max(right[0], right[1]);
dp[1] = root -> val + left[0] + right[0];

遍历顺序：递归遍历(后序遍历)，因为本层节点的逻辑需要比较结点左右儿子的函数返回值；
初始化：if (root == NULL) return {0, 0};

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
    // 长度为2的数组，0：不偷，1：偷
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        // 偷cur，那么就不能偷左右节点。
        int val1 = cur->val + left[0] + right[0];
        // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
};

股票问题

121.买卖股票的最佳时机

题目描述：
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
思路：有很多方法可以求解(贪心或者直接模拟)，但是要考虑动态规划来求解一系列买卖股票问题。
dp[i][1]: 在第i天不持有股票的最大利润；dp[i][0]：在第i天持有股票的最大利润
递推公式：

dp[i][0] = max(dp[i - 1][0]， -prices[i]);  //这里表示要持有更便宜的
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);

初始化：dp[0][0] = -prices[i] dp[0][1] = 0
遍历顺序：顺序遍历

122.买卖股票的最佳时机Ⅱ

题目描述：可以多次购买股票，但是不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
思路：动态规划(或者直接求累加和)
与121的不同点：本题可以多次购买；递推公式不同，当第i天持有时，如果购买当天股票，需要用前几天不持有股票的利润减去当天股票价格。
递推公式：

dp[i][0] = max(dp[i - 1][0]， dp[i - 1][1]-prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);

123.买卖股票的最佳时机Ⅲ

题目描述：给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）

递推公式：

dp[i][0] = dp[i - 1][0];//第i天不操作 其实也可以省略这个状态 一直为0
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0]-prices[i]);//第i天 第一次持有
dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);//第i天 第一次不持有
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);//第i天 第二次持有
dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);//第i天 第二次不持有

初始化：

dp[0][0] = 0;
dp[0][1] = -prices[0];//这里比较直观
dp[0][2] = 0;
dp[0][3] = -prices[0];//这里可以认为当天买卖一次，又买； 为了后续的遍历合理性
dp[0][4] = 0;

遍历顺序：

顺序遍历；
最后结果输出：
     return max(dp[prices.size() - 1][2], dp[prices.size() - 1][4]);
//为什么最后一天一定有最大值，因为我们每次更新第i天的策略都是取当前操作的最大值

188.买卖股票的最佳时机Ⅳ

题目描述：与123的不同，你最多可以买卖K次。
思路：与123完全相同，只不过不止5个状态，而是2k + 1个状态。

    int maxProfit(int k, vector<int>& prices) {
        vector<vector<int>> dp(prices.size(), vector<int>(2*k + 1, 0));
            for (int j = 1; j < 2*k + 1; j++)
                if (j % 2 == 1)//持有股票时，初始化为-第一天的股票价格
                     dp[0][j] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            for (int j = 1; j < 2*k+1; j++) {
                if (j % 2 == 1)//持有
                    dp[i][j] = max(dp[i-1][j], dp[i - 1][j - 1] - prices[i]);
                else//不持有
                    dp[i][j] = max(dp[i- 1][j], dp[i - 1][j - 1] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2*k];
    }

309.最佳买卖股票时机含冷冻期

题目描述：给定一个整数数组prices，其中第 prices[i] 表示第i天的股票价格。设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）；卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

**注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
dp数组：

dp[i][0]//第i天持有股票
dp[i][1]//第i天不持有股票
dp[i][2]//第i天是否卖出股票

转移方程：

if (dp[i - 1][2] == 0)//如果前一天没卖股票，今天不是冷冻期
	dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
else if (dp[i - 1][2] == 1 && i - 2 >= 0)//今天是冷冻期
	dp[i][0] = max(dp[i - 1][0], dp[i - 2][1] - prices[i]);

	dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
if (dp[i][1] == dp[i - 1][0] + prices[i])//如果今天卖出股票，那么标志位设为1
	dp[i][2] = 1;

初始化：

dp[0][0] = -prices[0];
dp[0][1] = 0;
dp[0][2] = 0;

遍历顺序：顺序遍历

714.买卖股票的最佳时机含手续费

题目描述：给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
与122区别，在卖出股票的时候，要减掉手续费，其他的相同。

300.最长递增子序列

题目描述：给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
dp[i]:0-i中以nums[i]结尾的最长递增子序列的长度；
递推公式：

for (int j = i - 1; j > -1; j--) {//顺序遍历
	if (nums[i] > nums[j]) {//循环跟之前的数比较，如果大于，那么取dp[i] 和 dp[i + 1]最大值
		dp[i] = max(dp[i], dp[j] + 1);
 	}
}

遍历顺序：顺序遍历
初始化：

vector<int> dp(nums.size(), 1);//因为，如果没找到比之前元素大的，那么就说明当前数字自己就是最长递增子序列，长度为1

674.最长连续递增序列

题目描述：给定一个未经排序的整数数组，找到最长且 连续递增的序列，并返回该序列的长度。
dp[i]:0-i中以nums[i]结尾的最长连续递增序列
递推公式：

if (nums[i] > nums[i - 1])//如果大于前一个整数，那么最大长度+1
	dp[i] = dp[i - 1] + 1;
else //否则，重置为1
    dp[i] = dp[i];

遍历顺序：顺序遍历
初始化：全初始化为1

718.最长重复子数组

题目描述：给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度(子数组是连续的)。
思路：与平时的动态规划数组不同，本题需要采用二维dp数组求解，因为是两个数组之间的比较。
dp[i][j]:以**nums1[i-1]结尾的子数组和以nums2[i-1]**结尾的子数组最长公共子数组长度；

递推公式：

if (nums1[i - 1] == nums2[i - 1])
    dp[i][j] = dp[i - 1][j - 1] + 1;

初始化：dp[0][j] dp[i][0]初始化为0；
遍历顺序：先遍历一数组或者二数组都行，因为他们的状态都是对角线方向推导而来；

1143.最长公共子序列

题目描述：给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0。
dp[i][j]:0,i-1和0,j-1的最长公共子序列；
递推公式：

if (nums[i - 1] == nums[j - 1])
    dp[i][j] = dp[i - 1][j - 1] + 1;
else
    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);

初始化：与718相同，dp[0][j] dp[i][0]初始化为0；
遍历顺序：从左到右，从上到下；

1035.不相交的线

题目描述：leetcode1035。
思路：这道题可以转化为最长公共子序列问题，因为公共子序列包含了对应顺序，那么他们之间连线一定是不相交的，即最大连线数量。

53.最大子数组和

题目描述：给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
dp[i]:以nums[i]为结尾的子数组的最大和；
递推公式：

dp[i] = max(dp[i - 1], dp[i - 1] + nums[i]);//延续前面和不延续两种情况

初始化：dp[0] = nums[0];
遍历顺序:顺序遍历；

392.判断子序列

题目描述：给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
思路：双指针：分别指向s和t头部元素，如果相等，同时后移；反之，只移动t的指针；最后判断s的指针是否移动到末尾；
动态规划：用最长公共子序列求解；

115.不同的子序列

题目描述：给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。
dp[i][j]:以s[i - 1]结尾的子串中包含以t[j - 1]结尾的子串个数；
递推公式：

if (s[i - 1] == s[j - 1])
    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
//dp[i - 1][j - 1]表示使用s[i - 1]包含最大数量
//dp[i -1][j]表示不使用s[i - 1]包含最大数量
else
    dp[i][j] = dp[i - 1][j];

初始化：

dp[i][0] = 1;//t为空，s的子序列中t出现个数
dp[0][j] = 0;
dp[0][0] = 1;

遍历顺序：从上到下，从左到右

583.两个字符串的删除操作

题目描述：给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步可以删除任意一个字符串中的一个字符。
dp[i][j]:以i-1结尾的word1和以j-1结尾的word2相同所需的最小步数；

递推公式：

if (word1[i - 1] == word[j - 1])
    dp[i][j] = dp[i - 1][j - 1];
else
    dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;//删掉word1[i - 1]或者word2[j - 1];

初始化：

dp[0][j] = j;
dp[i][0] = i;
dp[0][0] = 0;

遍历顺序：从上到下，从左到右；

72.编辑距离

题目描述：给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：
- 插入一个字符
- 删除一个字符
- 替换一个字符
与1143类似；
dp[i][j]:以i - 1结尾的word1转换成以j - 1结尾的word2所需的最少操作数；

递推公式：

if (word1[i - 1] == word2[j - 1])
    dp[i][j] = dp[i - 1][j - 1];
else
    dp[i][j] = min({dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]}) + 1;
//分别对应删除、增加、修改
//dp[i][j - 1]表示删除word2，逆向来看就是增加word1

初始化:

dp[0][j] = j;
dp[i][0] = i;
dp[0][0] = 0;

遍历顺序：从上到下，从左到右；

647.回文子串

题目描述：给定一个字符串，你的任务是计算字符串中有多少个回文子串。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
思路：动态规划(空间复杂度要高一点)或者双指针。
dp[i][j]:i - j 子串是否是回文字符串。true or false

之所以这样设置是因为回文串是一个对称的关系。如果设置成传统的dp[i]，那么dp[i - 1]与其关系就很弱。

        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        int result = 0;
        for (int i = s.size() - 1; i >= 0; i--) {  // 注意遍历顺序！！！
            for (int j = i; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    if (j - i <= 1) { // 情况一 和 情况二：只有一个字符和只有两个字符
                        result++;
                        dp[i][j] = true;
                    } else if (dp[i + 1][j - 1]) { // 情况三：大于两个字符情况
                        result++;
                        dp[i][j] = true;
                    }
                }
            }
        }//这道题的遍历顺序很重要，

初始化：初始化为false，方便代码的逻辑，只处理符合回文子串的情况。
**遍历顺序：**i的状态与i + 1 有关，所以i从大到小遍历；j与j - 1有关，所以从小到大遍历。

516.最长回文子序列

题目描述：给你一个字符串s，找出其中最大的回文子序列，返回改序列的长度（注意子序列和子串的区别）
思路：动态规划，或者跟自己的reverse求最长公共子序列；
dp[i][i]：i-j 最长子序列长度

递推公式：

if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1] + 2;
else
    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);

初始化： dp[i][j] = 1 if i == j
遍历顺序：i从到到小，j从小到大。
代码对比，自己写的

      vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        int result = 0;
        for (int i = s.size() - 1; i > -1; i--) {
            for (int j = i ; j < s.size(); j++) {
                if (s[i] == s[j]) {	//这里判断条件太多了，其实需要判断的大多是是单个字符的情况i == j
                    if (j == i -1)  //两个字符情况
                        dp[i][j] = 2;
                    else if (j == i ) //单个字符情况
                         dp[i][j] = 1;
                    else 
                        dp[i][j] = dp[i + 1][j - 1] + 2;
                } else {
                    if (i == s.size() - 1)//单个字符
                        dp[i][j] = 1;
                    else if (j == 0) //单个字符
                        dp[i][j] = 1;
                    else
                        dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]);
                }
                result = max(result, dp[i][j]);//这里效率也很低，因为是子序列，所以最后一个元素一定是最长回文子串
            }
        }
        return result;

代码随想录版本

  vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        for (int i = 0; i < s.size(); i++) dp[i][i] = 1;//初始化一个字符的回文数量
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i + 1; j < s.size(); j++) {//这里直接j=i+1,去判断两个及以上字符情况
                if (s[i] == s[j]) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;//当一个字符的时候已经初始化了
                    //两个字符的时候:dp[i][j] = dp[j][i] + 2;
                    //这里dp[j][i]一定等于0，因为我们只会更新矩阵上半部分的值
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][s.size() - 1];

3.无重复字符的最长子串

题目描述：给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
思路：dp求解
dp[i]:以i结尾的最长无重复字符子串长度
递推公式：

if (s[i] == s[i - 1])
    dp[i] = 1;
else {
    int j;
    for (int j = i - 1; j > i - 1 - dp[i - 1]; j--) {
        if(s[i] == s[j])
            break;
    }
    dp[i] = i - j;
}

初始化:全部初始化为1；
遍历顺序：从头开始遍历.
滑动窗口思路(其实跟动态规划思路是一样的，感觉这个题目的解法是滑动窗口)

    int lengthOfLongestSubstring(string s) {
        if (s.size() == 0)
            return 0;
        int result = 1;
        int slow = 0;
        int fast = 0;

        while(fast < s.size()) {
            int i;
            for (i = fast - 1; i >= slow; i--) {//这里一定是>=slow 在滑动窗口内去寻找
                if (s[i] == s[fast]) {
                    break; 
                }
            }
            if (i == slow && s[i] != s[slow]) {//如果没有重复的
                result = max(result, fast - slow + 1);
                fast++;
            }else {//如果有重复的
                slow = i + 1;
                result = max(result, fast - slow + 1);
                fast++;
            }
        }
        return result;
    }

32.最长有效括号

题目描述：给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
思路：动态规划
dp[i]:以i结尾的最长有效括号子串的长度。
递推公式：

情况一：
    s[i] == '('  此时无法以s[i]结尾形成有效括号子串:dp[i] = 0;
情况二：
    s[i] == ')'
    	子情况一:s[i - 1] == '('
            此时s[i]与s[i - 1]形成有效括号，此时还要加上s[i - 2]的有效括号长度
            dp[i] = dp[i - 2] + 2;
         子情况二：s[i - 1] ==')'
            此时需要去找与s[i - 1]匹配的有效括号的位置上一个位置，即s[i - dp[i - 1] - 1]
            if s[i - dp[i - 1] - 1] == '('
                那么此时dp[i] = dp[i - 1] + 2;
			还要考虑"()(())"这种连接的情况，因为现在是一个完整的有效括号了
                dp[i] = dp[i - 1] + 2 + dp[i - 2 - dp[i - 1]];

初始化：初始化为0；
遍历顺序：从小可以推出大，所以顺序遍历；

338.比特位计数

题目描述：给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。
思路：一个一个求(复杂度较高)，dp

//如果x是偶数，那么它可以表示为x/2 * 2，即把x/2左移了一位，不会发生1数量变化
//如果x是奇数，那么它可以表示为x - 1 + 1,即比x小的偶数+1，1的数量随之+1
vector<int> dp(n + 1, 0);
for (int i = 1; i <= n; i++) {
    if (i % 2 == 0) {//偶数
        dp[i] = dp[i / 2];
    }else {//奇数
        dp[i] = dp[i - 1] + 1;
    }
}
return dp;

//int一共32位，常规求一个数字1的个数，要右移或者左移32次
//Brian Kernighan算法: 令x = x&(x-1)，这个运算每次使x最后一个1变为0，重复这个操作，直到x变为0，可以得到1的个数，时间复杂度位log(n) < 32

312.戳气球

题目描述：有 n 个气球，编号为0 到 n - 1，每个气球上都标有一个数字，这些数字存在数组 nums 中。
现在要求你戳破所有的气球。戳破第 i 个气球，你可以获得 nums[i - 1] * nums[i] * nums[i + 1] 枚硬币。这里的 i - 1 和 i + 1 代表和 i 相邻的两个气球的序号。如果 i - 1或 i + 1 超出了数组的边界，那么就当它是一个数字为 1 的气球。
求所能获得硬币的最大数量。
思路：区间dp
dp[i][j]:区间(i,j)戳破所有气球能得到的最大金币数量

递推公式：

dp[i][j] = max k (dp[i][k] + dp[k][j]) + value[k]*value[i]*value][j]    (k range (i,j)) 
//假定k是区间(i,j)最后一个被戳破气球的下标，那么可以将区间划分为(i, k), (k, j)
//那么dp[i][j]可以由dp[i][k] dp[k][j]状态转移过来
//因为k是最后一个被戳破的，所以两个区间互不影响，可以用和的形式来表示

初始化：可以全部初始化为0，因为空区间金币数本身为0，其他区间可以由空区间推导而来。
遍历顺序：

其中，红色表示已初始化，黑色表示当前需要求解的最大金币值，绿色表示当前区间推导需要的区间位置。
可以看出，每次都需要切割区间，那么大区间回切成一个个小区间去完成状态推导；比如长度为2的区间由区间长度1的区间推导而来，所以遍历顺序为：先去求解区间长度为1的区间，再去递增求解高长度区间。

代码：

int maxCoins(vector<int>& nums) {
    int n = nums.size();
    //n+2，在区间两边添加1，方便处理边界情况
    vector<vector<int>> dp(n + 2, vector<int>(n+ 2, 0));
    //存储nums,两边+1，方便处理边界
    vector<int> temp(n + 2);
    temp[0] = 1;
    temp[n + 1] = 1;
    for (int i = 1; i <= n; i++) {
        temp[i] = nums[i - 1];
    }
	//len表示区间长度，从区间长度递增方向遍历
    for (int len = 3; len <= n + 2; len++) {
        //l表示区间左边界
        for (int l = 0; l <= n + 2 - len; l++) {
            //遍历最后一个戳破的气球
            for (int k = l + 1; k < l + len - 1; k++) {
                int left = dp[l][k];
                int right = dp[k][l + len - 1];
                int sum = left + right + temp[k]*temp[l]*temp[l + len - 1];
                dp[l][l + len - 1] = max(dp[l][l + len - 1], sum);
            }
        }
    }
    return dp[0][n + 1];
}

滑动窗口

76.最小覆盖字串

题目描述：给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。
思路：滑动窗口求解(滑动hash超时)；

滑动窗口思想：用i,j表示滑动窗口的左边界和右边界，通过改变i,j来扩展和收缩滑动窗口，可以想象成一个窗口在字符串上游走，当这个窗口包含的元素满足条件，即包含字符串T的所有元素，记录下这个滑动窗口的长度j-i+1，这些长度中的最小值就是要求的结果。

步骤一：不断增加j使滑动窗口增大，直到窗口包含了T的所有元素
步骤二：不断增加i使窗口缩小，因为是要求最小子串，所以将不必要的元素排除在外，使长度减少，直到碰到一个必须包含的元素，这个时候不能再扔了，记录此时滑动窗口的长度，并更新最小值
步骤三：让i再增加一个位置，这个时候窗口包含子串不满足条件，那么继续从步骤一开始执行，寻找新的满足条件的滑动窗口，如此反复，直到j超出了字符串S的范围
//map记录字符串中各个字符需要数量，相当于hash表，need表示t需要的，win表示窗口
unordered_map<char, int>need, win;
for (auto &i : t) need[i]++;
//left,right表示窗口左右端口
//count表示字符种类数,len表示最小长度,start表示最小长度起始位置
int left = 0, right = 0, count = 0, len = INT_MAX, start = 0;
while(right < s.size()) {
    //窗口右边第一个元素是t需要的
    if (need.find(s[right]) != need.end()) {
        //对应字符数量+1
        win[s[right]]++;
        //这里注意==的用法，表示s[right]这个元素第一次满足需求的数量
        if (win[s[right]] == need[s[right]]) {
            //种类数+1
            count++;
        }
    }
	//如果窗口可以覆盖字符串t
    while(count == need.size()) {
        //更新最小长度
        if (len > right - left + 1) {
            start = left;
            len = right - left + 1;
        }
        //窗口缩小，对应字符数量减少，如果不满足覆盖要求了，种类数-1
        if (need.find(s[left]) != need.end()) {
            if (need[s[left]] == win[s[left]]) {
                --count;
            }
            win[s[left]]--;
        }
        //缩小窗口
        left++;
    }
    //扩大窗口，这里主要right++位置，如果放在while前面会漏掉"AD"  "A" 这种情况
    right++;
}
//三元运算符
return len == INT_MAX ? "" : s.substr(start, len);

221.最大正方形

题目描述：
思路：暴力解法、动态规划

int maximalSquare(vector<vector<char>>& matrix) {
    vector<vector<int>> dp(matrix.size(), vector<int>(matrix[0].size(), 0));
    int result = 0;

    for (int i = 0; i < dp.size(); i++) {
        if (matrix[i][0] == '1') {
            dp[i][0] = 1;
            result = 1;
        }
    }
    for (int i = 0; i < dp[0].size(); i++) {
        if (matrix[0][i] == '1') {
            dp[0][i] = 1;
            result = 1;
        }
    }
//递推公式： dp[i][j]以nums[i][j]为右下角的最大正方形
//dp[i][j] == 0, dp[i][j] = 0
//dp[i][j] == 1, dp[i][j] = min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j])
//有理论推导，但是可以画个图找规律(dp[i][j - 1] dp[i - 1][j] dp[i - 1][j - 1]分别最小，看看结果)

    for (int i = 1; i < dp.size(); i++) {
        for (int j = 1; j < dp[0].size(); j++) {
            if (matrix[i][j] == '0')  dp[i][j] = 0;
            else {
                dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
            }
            result = max(result, dp[i][j]); 
        }
    }

    return result*result;
}

单调栈系列

739.每日温度

题目描述：给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。
思路：单调栈求解(栈里放数组下标)；
采用单调递增栈，先把第一个元素下标压入栈，接着循环遍历，如果当前元素比栈顶元素大，那么栈顶弹出，并更新result数组，直到当前元素小于等于栈顶元素，然后将当前元素压入栈；
时间复杂度：O(n) 空间复杂度：O(n);

496.下一个更大元素Ⅰ

题目描述：nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置右侧的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 ans 作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。
思路：单调栈，与739解题思路一样，但是需要map来存每一个元素和它的下一个更大元素，最后对nums1中的每个元素都搜索map中是否有索引；

503.下一个更大元素Ⅱ

题目描述：在496基础上，下一个最大元素可以继续从头去找，而不是到数组末尾就结束了(成环);

思路：与496思路相同，难点在于成环的处理，成环一般考虑成重复拼接的过程，搭配取模的操作，可以更简单的实现；

vector<int> nextGreaterElements(vector<int>& nums) {
    stack<int> st;
    vector<int> result(nums.size(), -1);

    for (int i = 0; i < nums.size()*2; i++) {//关键在于取模的过程，其实相当于在后面又拼接了一遍nums数组
        while(!st.empty() && nums[i%nums.size()] > nums[st.top()]) {
            result[st.top()] = nums[i%nums.size()];
            st.pop();
        }
        st.push(i%nums.size());
    }

    return result;
}

42.接雨水

题目描述：给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
思路：双指针、单调栈；
双指针，关键是理解能接的雨水可以分解成如下一列列的形式：

那么能接的雨水数量，可以分解为对于每个height[i]，寻找他左边的最大值和右边的最大值，那么i这一列可以接到的雨水数为：min(left,right)-height[i];

暴力解法为每次都遍历左右两边，找大最值，是超时的，可以通过先求每一列左边最大值和右边最大值数组left[i]、right[i]，一次遍历求解能接的雨水数量。

单调栈：用来找比当前元素大的第一个元素的位置；接雨水还可以分解为下面的形式：

具体思路：先将0压入栈，接着遍历height数组；如果height[i]比栈顶元素大，那么弹出栈顶元素，可以得到(height[i]是比弹出的元素大的右边第一个元素，现在的栈顶元素是比当前元素大的左边第一个元素)，可以计算得一部分雨水量，继续比较栈顶元素与height[i]，直到height[i]<=栈顶元素，st.push(i)。最后遍历结束，将所有雨水量收集起来为最终结果。

84.柱状图中最大的矩形

题目描述：给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。求在该柱状图中，能够勾勒出来的矩形的最大面积。
思路：单调栈(单调递减栈，用来找下一个小的元素)，与接雨水思路相同；
难点在于，对于每个以heighs[i]为基准去寻找最大矩形，那么这个最大矩形是以左边第一个比height[i]小的列和右边第一个比heights[i]小的列组成(左闭右闭)；这个思路与接雨水是很相似的，接雨水是找左边和右边第一个比当前列大的元素位置。
与接雨水类似，需要处理三种情况(或者两种情况)
情况一：当前遍历元素heights[i]比栈顶元素大
情况二：当前遍历元素heights[i]等于栈顶元素
情况三：当前遍历元素heights[i]小于栈顶元素

技巧：在heights[i]数组头部和尾部补0；如果高度数组为[1,2,3,4,5]，那么此时全部入栈，我们是在情况三去计算result的，那么这时会输出0，需要加额外逻辑，此时尾部补0，可以顺应逻辑，如果高度数组为[5,4,3,2,1]，这是会取不到left；

int largestRectangleArea(vector<int>& heights) {
    int result = 0;
    stack<int> st;
    heights.insert(heights.begin(), 0); // 数组头部加入元素0
    heights.push_back(0); // 数组尾部加入元素0
    st.push(0);

    // 第一个元素已经入栈，从下标1开始
    for (int i = 1; i < heights.size(); i++) {
        if (heights[i] > heights[st.top()]) { // 情况一
            st.push(i);
        } else if (heights[i] == heights[st.top()]) { // 情况二
            st.pop(); // 这个可以加，可以不加，效果一样，思路不同
            st.push(i);
        } else { // 情况三
            while (!st.empty() && heights[i] < heights[st.top()]) { // 注意是while
                int mid = st.top();
                st.pop();
                if (!st.empty()) {
                    int left = st.top();
                    int right = i;
                    int w = right - left - 1;
                    int h = heights[mid];
                    result = max(result, w * h);
                }
            }
            st.push(i);//这里最后一定要把当前元素入栈
        }
    }
    return result;
}

85.最大矩形

题目描述:给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。
思路：将矩阵分解为84题情景来分析，从上到下，一行一行来看，每一行都可以看作是一个柱状图的最大矩形子问题；

第一行高度分别为：[1, 0, 1, 0, 0];

第二行高度分别为:[2, 0, 2, 1, 1];

第三行高度分别为:[3, 1, 3, 2, 2];

第四行高度分别为:[4, 0, 0, 3, 0];

注意计算第n行高度的时候，如果当前行元素为0，那么可以把本行高度置0；因为当前行元素为0，其它列的柱形想要联结本列形成最大矩形的话，一定不会包含本行为0的元素，也就是说上一行计算的最大矩阵已经包含了本行联结这一列的结果，所以可以高度置0；

图论

dfs(深度优先搜索)

思路：深度优先所搜算法，沿着每一个可能的路径向下进行搜索，直到不能再深入为止，并且每个节点只能访问一次；

求解迷宫问题代码(数组这种结构)：


bool is_taoli = false;
int n;
vector<int> dx = { 0,0,-1,1 };
vector<int> dy = { -1,1,0,0 };

bool is_valid(int x, int y, vector<vector<int>> map, vector<vector<int>>& used) {
	if (x > n || y > n || x < 1 || y < 1 || map[x][y] == 1)
		return false;
	return true;
}
void dfs(int x, int y, vector<vector<int>> map, vector<vector<int>>& used) {
	if (used[x][y])
		return;
	if (x == n && y == n) {
		is_taoli = true;
		return;
	}
	used[x][y] = true;
	for (int i = 0; i < 4; i++) {
		if (is_valid(x + dx[i], y + dy[i], map, used)) {
			dfs(x + dx[i], y + dy[i], map, used);
		}
	}
}

bfs(广度优先搜索)

思路：bfs是一种盲目搜索法，它搜索检查每一个可以到达的点，直到找到结果位置；

求解迷宫问题代码：

void bfs(int x, int y, vector<vector<int>> map, vector<vector<int>>& used) {
	queue<vector<int>> que;
	que.push({ x, y });
	while (!que.empty()) {
		vector<int> node = que.front();
		que.pop();
		if (used[node[0]][node[1]] == 1)
			continue;
		if (node[0] == n && node[1] == n) {
			is_taoli = true;
			break;
		}
		used[node[0]][node[1]] = true;
		for (int i = 0; i < 4; i++) {
			if (is_valid(node[0] + dx[i], node[1] + dy[i], map, used)) {
				que.push({ node[0] + dx[i], node[1] + dy[i] });
			}
		}
	}
}

301.删除无效括号

题目描述：给你一个由若干括号和字母组成的字符串 s ，删除最小数量的无效括号，使得输入的字符串有效。

返回所有可能的结果。答案可以按 任意顺序 返回。
思路：这道题包含小写字母并且需要返回所有满足条件的结果，基本可以确定需要暴力搜索来求解；
回溯：转换为子集问题，再从子集中找符合条件的结果返回；会超时，单单一个回溯就会超时，因为它相当于找了所有删除的结果，冗余度太高。(dfs思路好像可以)
bfs：每一层放上一层删除一个元素的结果，用set来去重，如果这一层有满足条件的字符串，那么就可以返回结果，从最小删除无效括号的数量出发。

class Solution {
public:
    int legal(string s) {//计数器法判断字符串括号是否合法
        int cnt = 0;
        for(auto x : s){
            if(x == '(') cnt++;
            if(x == ')') cnt--;
            if(cnt < 0) return 0;//')'多的情况
        }
        return cnt == 0; //'('是否多
    }
    vector<string> removeInvalidParentheses(string s) {
        vector<string> res;//结果集
        if(legal(s)) {
            res.push_back(s);
            return res;
        }
        int n = s.length();
        queue<string> q;
        q.push(s);//第一层就是不删除的情况，s
        while(!q.empty()){
            vector<string> all;//上一层元素
            unordered_set<string> now;//当前层元素，用set去重
            unordered_set<string> leg;//当前层是否有合法元素，set去重
            int m = q.size();
            for(int i = 0; i < m; i++) {
                all.push_back(q.front());
                q.pop();
            }
            for(auto s : all) {
                int len = s.length();
                for(int i = 0; i < len; i++) {
                    if(s[i] == '(' || s[i] == ')') {//任意删除一个元素
                        string tmp = s;
                        tmp.erase(i,1);
                        now.insert(tmp);
                        if(legal(tmp)) leg.insert(tmp);
                    }
                }
            }
            if(!leg.empty()) {//如果当前层有合法元素，说明出现删除最小数量合法的字符串括号，返回结果
                for(auto x : leg) {
                    res.push_back(x);
                }
                break;
            } else {//否则，继续下一层删除
                for(auto x : now) q.push(x);
            }
        }
        return res;
    }
};

邻接表表示法：

#include<bits/stdc++.h>
using namespace std;

#define maxSize 1000

struct ArcNode {
	int adjvex;
	ArcNode* nextarc;
	int info;//权重
};


struct Vnode {
	int data;
	ArcNode* firstarc;
};

struct Graph {
	Vnode adjlist[maxSize];
	int n, e;
};

vector<int> used(10, 0);

Graph* graph;
void insertNode(ArcNode* node, ArcNode* newNode) {
	ArcNode* p = node;
	while (p->nextarc != NULL)
		p = p->nextarc;
	p->nextarc = newNode;
}

void create() {
	graph = new Graph;
	cout << "输入顶点的数目" << endl;
	cin >> graph->n;

	cout << "输入边的个数" << endl;
	cin >> graph->e;

	int u = -1, v = -1, weight = -1;
	for (int i = 0; i < graph->n; i++) {
		graph->adjlist[i].firstarc = NULL;
	}

	ArcNode* node;
	for (int i = 0; i < graph->e; i++) {
		cin >> u >> v;
		node = new ArcNode;
		node->adjvex = v;
		node->nextarc = NULL;
		graph->adjlist[u].data = u;
		if (graph->adjlist[u].firstarc == NULL) {
			graph->adjlist[u].firstarc = node;
		}
		else
			insertNode(graph->adjlist[u].firstarc, node);
	}

}

bfs(广度优先搜索)

void bfs() {
    queue<int> qe;
    qe.push(graph->adjlist[0].data);

    while (!qe.empty()) {
        int temp = qe.front();
        qe.pop();
        if (used[temp] == 1)
            continue;
        used[temp] = 1;
        cout << temp << endl;
        ArcNode* node = graph->adjlist[temp].firstarc;
        while (node != NULL) {
            qe.push(node->adjvex);
            node = node->nextarc;
        }
    }
}

200.岛屿数量

题目描述：给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。
思路：DFS

207.课程表

题目描述：你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
思路：拓朴排序相关题目。首先统计每个节点的入度，将入度为0的节点加入队列；通过bfs来遍历每个节点，将相应节点的入度-1，最后判断每个节点是否都没有入度了，如果都没有入度了，那么可以按照一定顺序修完所有课程；有入度即表示，想修该课程必须先修其他课程；.

bfs解法

    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> rudu(numCourses, 0);//入度数组

        int count = 0;
        for (const auto& info : prerequisites) {//统计入度
            rudu[info[0]]++;
        }

        queue<int> que;
        for (int i = 0; i < numCourses; i++) {//入度为0加入队列，表示可以先修这个课程
            if (rudu[i] == 0) {
                    que.push(i);
                    count++;
            }
        }

        while(!que.empty()) {
            for (const auto& info : prerequisites) {//先修可以修的课程，然后把它的所有相邻节点的入度-1，如果某个相邻节点的入度为0，那么将v放入队列中
                if (info[1] == que.front()) {
                    rudu[info[0]]--;
                    if (rudu[info[0]] == 0) {
                        que.push(info[0]);
                        count++;
                    }
                }
            }
            que.pop();
        }
        return count == numCourses;
    }

437.路经总和Ⅲ

题目描述：给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的路径的数目。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

思路：穷举搜索(类似dfs)；每访问一个节点node，检测以node为起始节点向下延申的路径有多少种，同时判断是否满足条件。递归遍历每一个节点的所有可能路径，然后将这些路径数目加起来即为返回结果。

首先定义rootSum(p, val)表示以节点p为起点向下且满足路径和为val的路径数目。对二叉树上的每个节点p求出rootSum(p, targetSum)，然后对这些路径数目求和返回结果。
    //递归求解以root节点向下且符合路径和的路径数目
    int rootSum(TreeNode* root, long targetSum) {
        if (root == nullptr) return 0;
        
        int ret = 0;
    	//判断到本节点是否满足路径和，这里不return，继续向下搜索，因为有负数情况
        if (root -> val == targetSum) ret++;

        ret += rootSum(root->left, targetSum - root->val);
        ret += rootSum(root->right, targetSum - root->val);
        return ret;
    }
	//遍历每个节点，然后对每个节点求向下且满足路径和的路径数目，最后递归返回累加求和
    int traversal(TreeNode* root, int targetSum) {
        if (root == nullptr) return 0;

        int ret = 0;
        ret += rootSum(root, targetSum);
        ret += traversal(root -> left, targetSum);
        ret += traversal(root -> right, targetSum);
        return ret;
    }
    int pathSum(TreeNode* root, int targetSum) {
        return traversal(root, targetSum);
    }

djlist[u].data = u;
if (graph->adjlist[u].firstarc == NULL) {
graph->adjlist[u].firstarc = node;
}
else
insertNode(graph->adjlist[u].firstarc, node);
}

}


##### bfs(广度优先搜索)

```c++
void bfs() {
    queue<int> qe;
    qe.push(graph->adjlist[0].data);

    while (!qe.empty()) {
        int temp = qe.front();
        qe.pop();
        if (used[temp] == 1)
            continue;
        used[temp] = 1;
        cout << temp << endl;
        ArcNode* node = graph->adjlist[temp].firstarc;
        while (node != NULL) {
            qe.push(node->adjvex);
            node = node->nextarc;
        }
    }
}

200.岛屿数量

题目描述：给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。
思路：DFS

207.课程表

题目描述：你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。

在选修某些课程之前需要一些先修课程。先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则必须先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。

请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。
思路：拓朴排序相关题目。首先统计每个节点的入度，将入度为0的节点加入队列；通过bfs来遍历每个节点，将相应节点的入度-1，最后判断每个节点是否都没有入度了，如果都没有入度了，那么可以按照一定顺序修完所有课程；有入度即表示，想修该课程必须先修其他课程；.

bfs解法

    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> rudu(numCourses, 0);//入度数组

        int count = 0;
        for (const auto& info : prerequisites) {//统计入度
            rudu[info[0]]++;
        }

        queue<int> que;
        for (int i = 0; i < numCourses; i++) {//入度为0加入队列，表示可以先修这个课程
            if (rudu[i] == 0) {
                    que.push(i);
                    count++;
            }
        }

        while(!que.empty()) {
            for (const auto& info : prerequisites) {//先修可以修的课程，然后把它的所有相邻节点的入度-1，如果某个相邻节点的入度为0，那么将v放入队列中
                if (info[1] == que.front()) {
                    rudu[info[0]]--;
                    if (rudu[info[0]] == 0) {
                        que.push(info[0]);
                        count++;
                    }
                }
            }
            que.pop();
        }
        return count == numCourses;
    }

437.路经总和Ⅲ

题目描述：给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的路径的数目。路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

首先定义rootSum(p, val)表示以节点p为起点向下且满足路径和为val的路径数目。对二叉树上的每个节点p求出rootSum(p, targetSum)，然后对这些路径数目求和返回结果。
    //递归求解以root节点向下且符合路径和的路径数目
    int rootSum(TreeNode* root, long targetSum) {
        if (root == nullptr) return 0;
        
        int ret = 0;
    	//判断到本节点是否满足路径和，这里不return，继续向下搜索，因为有负数情况
        if (root -> val == targetSum) ret++;

        ret += rootSum(root->left, targetSum - root->val);
        ret += rootSum(root->right, targetSum - root->val);
        return ret;
    }
	//遍历每个节点，然后对每个节点求向下且满足路径和的路径数目，最后递归返回累加求和
    int traversal(TreeNode* root, int targetSum) {
        if (root == nullptr) return 0;

        int ret = 0;
        ret += rootSum(root, targetSum);
        ret += traversal(root -> left, targetSum);
        ret += traversal(root -> right, targetSum);
        return ret;
    }
    int pathSum(TreeNode* root, int targetSum) {
        return traversal(root, targetSum);
    }