LeetCode_热题100_知识点总结

LeetCode_热题100_知识点总结

• • • [0、C++万能头文件 和 加速读取](#0、C++万能头文件 和 加速读取)
    • 1、sort函数
    • • • [sort 函数对数组的排序](#sort 函数对数组的排序)
        • [sort 函数按照区间 a,b 第一个元素 a 进行排序](#sort 函数按照区间 [a,b] 第一个元素 a 进行排序)
        • [sort() 以第二个进行排序](#sort() 以第二个进行排序)
        • [自定义sort 解读](#自定义sort 解读)
    • [2、unordered_map 和 unordered_set](#2、unordered_map 和 unordered_set)
    • • mpk.push_back(str);
      • unordered_map初始化;
      • [it.second ;](#it.second ;)
      • [添加元素 mp_set.insert();](#添加元素 mp_set.insert();)
      • [去除元素 mp_set.erase();](#去除元素 mp_set.erase();)
    • 3、字符串的转换
    • • • [string -> int](#string -> int)
        • [int -> string](#int -> string)
    • [4、vector 和 数组](#4、vector 和 数组)
    • • • [vector 的 back()](#vector 的 back())
        • 数组初始化赋默认值
    • 5、emplace_back和push_back
    • [6、deque 双端队列](#6、deque 双端队列)
    • 7、随机函数
    • 8、构造函数声明+初始化列表进行变量初始化和赋值
    • 9、背包问题
    • • • 01背包
        • 完全背包
    • 10、双端队列（数组）
    • [11、 vector\<char> ------> string](#11、 vector<char> ------> string)
    • [12、 回溯](#12、 回溯)
    • • [组合 或者 子集 (控制开始位置 )](#组合 或者 子集 (控制开始位置 ))
      • 全排列（控制是否使用）
    • [13、 一维dp数组](#13、 一维dp数组)
    • • 组合
    • 14、每个数字占5个字符宽度，向右对齐

0、C++万能头文件 和 加速读取

#include<bits/stdc++.h>

ios::sync_with_stdio(false);
cin.tie(nullptr);

1、sort函数

sort 函数对数组的排序

int a[]={1,3,2};
sort(a,a+3);//注意这里3是数组的长度
//倒序排序 
sort(a,a+3,greater<int>()); 
vector<int> nums={1,3,2};
sort(nums.begin(),nums.end());//注意这里nums.begin()是地址 

sort 函数按照区间 a,b 第一个元素 a 进行排序

vector<vector<int>>& intervals
//将区间按第一个元素进行排序。
sort(intervals.begin(),intervals.end());

sort() 以第二个进行排序

//默认是用第一个进行排序
sort(points.begin(), points.end(), [](const vector<int>& u, const vector<int>& v) {
    return u[1] < v[1];  // 比较两个区间的起始位置
});

自定义sort 解读

注意<>{}; (为nums中的一个元素) {为比较的判断条件}

vector<pair<int,int>> map(n);
sort(map.begin(),map.end(),[](const pair<int,int> &u,const pair<int,int> &v){
    if(u.second != v.second) return u.second<v.second ;return  u.first < v.first; 
});

2、unordered_map 和 unordered_set

mpk.push_back(str);

unordered_map<string,vector<string>> mp;
//如果这个 key 不存在，unordered_map 会自动创建一个新的空 vector<string>
mp[k].push_back(str);

unordered_map初始化;

注意是大括号进行 key 和 value 的捆绑

unordered_map<char,char> mp={{')','('},{'}','{'},{']','['}};

it.second ;

ans.push_back(it.second);

添加元素 mp_set.insert();

mp.insert(c);

去除元素 mp_set.erase();

mp.erase(s[left++]);

3、字符串的转换

string -> int

int i=stoi(str);

int -> string

string str=to_string(i);

4、vector 和 数组

vector 的 back()

vector<vector<int>> merged;
{{1,2},
 {3,4},
 {5,6}}
merged.back()[0] 代表5
merged.back()[1] 代表6

数组初始化赋默认值

int counts[26]={0};

5、emplace_back和push_back

emplace_back

6、deque 双端队列

#定义双端队列
deque<int> q;
#在右端末尾添加一个元素
q.push_back();

#查看左端元素
q.front();
#查看右端元素
q.back();

#删除右端元素
q.pop_back();
#删除左端元素
q.pop_front();

7、随机函数

#include <cstdlib>
//范围通常是从 0 到 RAND_MAX，其中 RAND_MAX 是一个常量，通常为 32767
srand(time(0));  // 设置随机数种子
int pivotIndex = left + rand() % (right - left + 1);

8、构造函数声明+初始化列表进行变量初始化和赋值

//下方代码的用法和第一行相同，是构造函数初始化列表，对变量初始化和赋值
DLinkedNode(int _key,int _value):key(_key),value(_value),prev(nullptr),next(nullptr){} 
//构造函数
//初始化 capacity 成员变量 为传递给构造函数的参数 _capacity
//初始化 size 成员变量 为 0，表示缓存初始化时为空。
LRUCache(int _capacity):capacity(_capacity),size(0){}

9、背包问题

01背包

遍历物品 再遍历背包

倒序遍历（不重复使用）

numsi 代表物品的质量 和 价值

j 代表容量

 // 遍历数组中的每个数字
for (int i = 0; i < nums.size(); ++i) {
    // 从容量 capacity 往下遍历，避免重复使用同一个数字
    // 如果 j >= nums[i]，我们可以选择将 nums[i] 加入到组合中
    for (int j = capacity; j >= nums[i]; --j) {
        //  dp[j] 代表j容量可以存储的最大价值
        //j - nums[i] 为容量减小   +nums[i] 为增加的价值
        dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
    }
}

完全背包

放与不放，偷与不偷

遍历物品 再遍历背包

正序遍历（重复使用）

dp数组初始化

dp0 初始化

注意溢出的情况

/ /完全背包
        //dp 数组初始化，
        vector<int> dp(amount+1,INT_MAX);
        dp[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){
                    dp[j]=min(dp[j-coins[i]]+1,dp[j]);
                }
            }
        }
        return dp[amount]==INT_MAX? -1 :dp[amount];

10、双端队列（数组）

deque<int> levelList;  
//在队列末尾添加元素
levelList.push_back(curNode->val);
//在队列头添加元素
levelList.push_front(curNode->val);

11、 vector<char> ------> string

vector<char> path;
string(path.begin(),path.end());

12、 回溯

组合 或者 子集 (控制开始位置 )

for (int i = start; i <= n; i++) {
	path.push_back(i);           // 将当前数字添加到组合
	backtracking(n, k, i + 1);   // 递归调用，继续选择下一个数字
	path.pop_back();             // 撤销选择，回溯
}

全排列（控制是否使用）

void backtracking(vector<int>& nums,vector<bool> &used){
       if(path.size()==nums.size()){
           ans.push_back(path);
           return;
       }
       for(int i=0;i<nums.size();i++){
           if(!used[i]){
               path.push_back(nums[i]);
               used[i]=true;
               backtracking(nums,used);
               used[i]=false;
               path.pop_back();
           }
       }
   }

13、 一维dp数组

组合

dp[j] = dp [j] + dp[j-1]; 等号左侧的 dp[j] 相当于 dp[i][j]，等号右侧的dp[j] 其实相当于 dp[i-1][j]

14、每个数字占5个字符宽度，向右对齐

cout << setw(5) << x;

欢迎大家和我沟通交流(✿◠‿◠)