该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/posts/ACM/ds-1

struct BTNode{
    char data;
    BTNode *lchild,*rchild;
  //C语言中 struct BTNode *lchild,*rchild;
}BTNode;

struct BTNode{
    char data;
    BTNode *lchild,*parent,*rchild;
}BTNode;

struct BTNode{
    char data;
    BTNode *lchild,*rchild;
  bool ltag,rtag;//true时表示指向前驱后继
}BTNode;

struct Node{
    char data;
    int parent;/
}BTNode;

struct Node{
    char data;
    Node *firstchild;
  Node *nextsibling;//右兄弟
}Node;

vector<int> p;

void Init(int n){
    p.resize(n);
    for(int i = 0;i < n;i++) p[i] = i;//s[i] = 1,h[i] = 1;
    //p[i] = -1;
}

int find(int x){
    if(p[x] == x) return x;//p[x] < 0
    //路径压缩
    else return p[x] = Find(p[x]);//优化效率find(p[x])
}

void Union(int x,int y){
    int rootx = Find(x);
    int rooty = Find(y);
    if(rootx != rooty){
        //p[rootx] = rooty;
        //按秩合并
        //按树的高度合并
        //其中路径压缩可能会改变树的高度
        //此时 h 数组记录的高度是估计的高度 仅使用按高度合并可以把树的高度控制在 logn 以内
        if(h[rootx] < h[rooty]) p[rootx] = rooty;// = rootx
        else if(h[rootx] > h[rooty]) p[rooty] = rootx; // = rooty
        else{
            p[rootx] = rooty;
            h[rooty]++;//--
        }
        //按树的大小合并size
        //优先将小树合并到大树上 合并后 s 叠加
        if(s[rootx] <= s[rooty]){
            p[rootx] = rooty;
            s[rooty] += s[rootx];
        }else{
            p[rooty] = rootx;
            s[rootx] += s[rooty];
        }
    }
}

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/posts/CTF/quzheng

dd if=/dev/sda of=disk_image.raw bs=4M conv=noerror,syncmd5sum disk_image.raw > disk_image.md5

http.request.uri contains "login"

ip.src 源 / ip.dist 出 / ip.addr
tcp.port tcp.srcport tcp.dstport

tshark -r  -T fields  -e dns.qry.name | sort | uniq > test.txt

看完了？说点什么呢

岁在乙巳冬月，值人民领袖毛泽东诞辰日，星垂平野，长风振衣，遥思不绝

魂兮归矣，瞰人间换了，此天此地。黎庶长怀开路人，泪化红旗星雨。笔起惊雷，弓鸣裂月，山海皆铭誓。沉浮谁主？苍茫万里澄霁。

遥想故国寒宵，冻云欲锁，赤焰燃荒砌。一叶红船犁暗夜，终得春回潮沸。雪岭魂雕，窑灯鬓影，俱是峥嵘气。乾坤重整，初心犹在心底。

山河列阵如碑，思君岁岁，肝胆依然洗。大道如砥通皓月，清风两袖未徙。禾下乘凉，云端牧箭，皆念当时意。东方既白，千峰披曙而起。

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/posts/CTF/wp-1

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/posts/ACM/qianzhuihe

void insert(int x1,int y1,int x2,int y2){
    b[x1][y1] += 1;
    b[x2 + 1][y1] -=1;
    b[x1][y2 + 1] -=1;
    b[x2 + 1][y2 + 1] +=1;
}

b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];

看完了？说点什么呢

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/notes/14

看完了？说点什么呢

壹·引用与致谢

本文由https://io.zouht.com/154.html 补充与精简而来 遵守CC-BY-SA-4.0 license

同时对作者@ChrisKim表示感谢 您的视频教程非常详细与易懂

C++ 标准模板库 (STL, Standard Template Library)：包含一些常用数据结构与算法的模板的 C++ 软件库。

贰·常用容器

2.1 向量 vector

#include <vector>

连续的顺序的储存结构（和数组一样的类别），但是有长度可变的特性。

时间复杂度：$O(n)$

vector<int> arr;
arr.push_back(3);// 尾接
arr.pop_back();  // 尾删

arr.size()

arr.resize(5,3); //改长赋初值 改短直接删

arr.empty(); // 如果是空返回 `true` 反之返回 `false`.

arr.clear();

for (auto ele : arr) cout << ele << endl;
for (int i = 0; i < arr.size(); i++) cout << a[i] << endl;

尾接 & 尾删 时间复杂度：均摊 $O(1)$

清空 时间复杂度：$O(n)$

改变长度 时间复杂度：$O(n)$

一般情况 vector 可以替换掉普通数组，除非该题卡常（指卡时间复杂度常数。

注意事项

提前指定长度

如果长度已经确定，那么应当直接在构造函数指定长度，而不是一个一个 .push_back(). 因为 vector 额外内存耗尽后的重分配是有时间开销的，直接指定长度就不会出现重分配了。

// 优化前: 522ms
vector<int> a;
for (int i = 0; i < 1e8; i++)
    a.push_back(i);
// 优化后: 259ms
vector<int> a(1e8);
for (int i = 0; i < a.size(); i++)
    a[i] = i;

当心 size_t 溢出

vector 获取长度的方法 .size() 返回值类型为 size_t，通常 OJ 平台使用的是 32 位编译器（有些平台例如 cf 可选 64 位），那么该类型范围为 $[0,2^{32})$.

vector<int> a(65536);
long long a = a.size() * a.size(); // 直接溢出变成0了

2.2 栈 stack

#include <stack>

通过二次封装双端队列 (deque) 容器，实现先进后出的栈数据结构。

常用方法

注意事项

不可访问内部元素！

下面都是错误用法

for (int i = 0; i < stk.size(); i++)
    cout << stk[i] << endl;
for (auto ele : stk)
    cout << stk << endl;

2.3 队列 queue

#include <queue>

通过二次封装双端队列 (deque) 容器，实现先进先出的队列数据结构。

常用方法

注意事项

不可访问内部元素！同栈stack

2.4 优先队列 priority_queue

#include <queue>

提供常数时间的最大元素查找，对数时间的插入与提取，底层原理是二叉堆。

常用方法

priority_queue<类型, 容器, 比较器> pque

priority_queue<int> pque1;//堆顶 1 3 4 4 最大的在堆顶  储存int的大顶堆
priority_queue<int, vector<int>, greater<int>> pque2; // 最小的在堆顶 储存int的小顶堆

//二维写法
priority_queue<pair<int,int>, vector<pair<int,int>>, cmp> arr;

//比较器
struct cmp {
    bool operator()(const pair<int,int> &a, const pair<int,int> &b) const {
        return a.second < b.second;
    }
};

进出队复杂度 $O(\log n)$，取堆顶 $O(1)$.

适用情形

持续维护元素的有序性：每次向队列插入大小不定的元素，或者每次从队列里取出大小最小/最大的元素，元素数量 $n$，插入操作数量 $k$.

• 每次插入后进行快速排序：$k\cdot n\log n$
• 使用优先队列维护：$k\cdot\log n$

注意事项

仅堆顶可读

只可访问堆顶，其他元素都无法读取到。下面是错误用法：

cout << pque[1] << endl;

所有元素不可写

堆中所有元素是不可修改的。

如果你恰好要修改的是堆顶元素，那么是可以完成的：

int tp = pque.top();
pque.pop();
pque.push(tp + 1);

2.5 集合 set

#include <set>

提供对数时间的插入、删除、查找的集合数据结构。底层原理是红黑树。

常用方法

set<类型, 比较器> st

• 类型：要储存的数据类型
• 比较器：比较大小使用的比较器，默认为 less<类型>，可自定义

set<int> st1;               // 储存int的集合（从小到大）
set<int, greater<int>> st2; // 储存int的集合（从大到小）

if(st.find(1) != st.end()) cout << "yes" << endl; // 查找

可使用迭代器进行遍历：

for (set<int>::iterator it = st.begin(); it != st.end(); ++it) cout << *it << endl;
for (auto it = st.begin(); it != st.end(); ++it) cout << *it << endl;

基于范围的循环（C++ 11）：

for (auto &ele : st) cout << ele << endl;

增删查时间复杂度均为 $O(\log n)$

适用情形

• 元素去重：$[1,1,3,2,4,4]\to[1,2,3,4]$
• 维护顺序：$[1,5,3,7,9]\to[1,3,5,7,9]$

注意事项

不存在下标索引

set 虽说可遍历，但仅可使用迭代器进行遍历，它不存在下标这一概念，无法通过下标访问到数据。

元素只读

set 的迭代器取到的元素是只读的（因为是 const 迭代器），不可修改其值。如果要改，需要先 erase 再 insert. 下面是错误用法：

cout << *st.begin() << endl; // 正确。可读。
*st.begin() = 1;             // 错误！不可写！

不可用迭代器计算下标

set 的迭代器不能像 vector 一样相减得到下标。下面是错误用法：

auto it = st.find(2);      // 正确，返回2所在位置的迭代器。
int idx = it - st.begin(); // 错误！不可相减得到下标。

2.6 映射 map

#include <map>

提供对数时间的有序键值对结构。底层原理是红黑树。

常用方法

map<键类型, 值类型, 比较器> mp

map<int, int> mp1;               // int->int 的映射（键从小到大）
map<int, int, greater<int>> st2; // int->int 的映射（键从大到小）

可使用迭代器进行遍历：

for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it)
    cout << it->first << ' ' << it->second << endl;

基于范围的循环（C++ 11）：

for (auto &pr : mp) cout << pr.first << ' ' << pr.second << endl;

增删改查时间复杂度均为 $O(\log n)$

适用情形

需要维护映射的场景可以使用：输入若干字符串，统计每种字符串的出现次数。(map<string, int> mp)

注意事项

中括号访问时默认值

如果使用中括号访问 map 时对应的键不存在，那么会新增这个键，并且值为默认值，因此中括号会影响键的存在性。

map<char, int> mp;
cout << mp.count('a') << endl; // 0
mp['a'];                       // 即使什么都没做，此时mp['a']=0已经插入了
cout << mp.count('a') << endl; // 1
cout << mp['a'] << endl;       // 0

不可用迭代器计算下标

map 的迭代器不能像 vector 一样相减得到下标。下面是错误用法：

auto it = mp.find('a');      // 正确，返回2所在位置的迭代器。
int idx = it - mp.begin();   // 错误！不可相减得到下标。

2.7 字符串 string

#include <string>

常用方法

string s1;           // 构造字符串，为空
string s2 = "awa!";  // 构造字符串，并赋值awa!
string s3(10, '6');  // 构造字符串，通过构造函数构造为6666666666

数值与字符串互转（C++11）

注意事项

尾接字符串一定要用 +=

string 的 += 运算符，将会在原字符串原地尾接字符串。而 + 了再 = 赋值，会先生成一个临时变量，在复制给 string.

通常字符串长度可以很长，如果使用 + 字符串很容易就 TLE 了。

// 优化前: 15139ms
string s;
for (int i = 0; i < 5e5; i++)
    s = s + "a";

// 优化后: < 1ms (计时器显示0)
string s;
for (int i = 0; i < 5e5; i++)
    s += "a";

.substr() 方法的奇葩参数

一定要注意，C++ string 的取子串的第一个参数是子串起点下标，第二个参数是子串长度。

第二个参数不是子串终点！不是子串终点！要与 java 等其他语言区分开来。

.find() 方法的复杂度

该方法实现为暴力实现，时间复杂度为 $O(n^2)$.

2.8 二元组 pair

#include <utility>

顾名思义，就是储存二元组的。

常用方法

pair<第一个值类型, 第二个值类型> pr

• 第一个值类型：要储存的第一个值的数据类型
• 第二个值类型：要储存的第二个值的数据类型

pair<int, int> p1;
pair<int, long long> p2;
pair<char, int> p3;
// ...

赋值

pair<int, char> pr = {1, 'a'};

直接取值

• 取第一个值：.first
• 取第二个值：.second

pair<int, char> pr = {1, 'a'};
int awa = pr.first;
char bwb = pr.second;

结构化绑定 C++17

pair<int, char> pr = {1, 'a'};
auto &[awa, bwb] = pr;

判同 直接用 == 运算符

pair<int, int> p1 = {1, 2};
pair<int, int> p2 = {1, 3};
if (p1 == p2) { ... } // false

叁·迭代器简介

3.1迭代器认识

对于一个 vector，我们可以用下标遍历：

for (int i = 0; i < a.size(); i++)
    cout << a[i] << endl;

我们同时也可以用迭代器来遍历：

for (vector<int>::iterator it = a.begin(); it != a.end(); ++it)
    cout << *it << endl;

• a.begin() 是一个迭代器，指向的是第一个元素
• a.end() 是一个迭代器，指向的是最后一个元素再后面一位
• 上述迭代器具有自增运算符，自增则迭代器向下一个元素移动
• 迭代器与指针相似，如果对它使用解引用运算符，即 *it，就能取到对应值了

3.2 为何需要迭代器？

很多数据结构并不是线性的（例如红黑树），对于非线性数据结构，下标是无意义的。无法使用下标来遍历整个数据结构。

迭代器的作用就是定义某个数据结构的遍历方式，通过迭代器的增减，代表遍历到的位置，通过迭代器便能成功遍历非线性结构了。

例如，set 的实现是红黑树，我们是没法用下标来访问元素的。但是通过迭代器，我们就能遍历 set 中的元素了：

for (auto it = st.begin(); it != st.end(); ++it) cout << *it << endl;

3.3 迭代器用法

对于 vector 容器，它的迭代器功能比较完整，以它举例：

• .begin()：头迭代器
• .end()：尾迭代器
• .rbegin()：反向头迭代器
• .rend()：反向尾迭代器
• 迭代器 + 整型：将迭代器向后移动
• 迭代器 - 整型：将迭代器向前移动
• 迭代器 ++：将迭代器向后移动 1 位
• 迭代器 --：将迭代器向前移动 1 位
• 迭代器 - 迭代器：两个迭代器的距离// set 不可用
• prev(it)：返回 it 的前一个迭代器
• next(it)：返回 it 的后一个迭代器

3.4 常见问题

.end() 和 .rend() 指向的位置是无意义的值

对于一个长度为 10 的数组：for (int i = 0; i < 10; i++)，第 10 位是不可访问的

对于一个长度为 10 的容器：for (auto it = a.begin(); it != a.end(); ++it)，.end 是不可访问的

不同容器的迭代器功能可能不一样

迭代器细化的话有正向、反向、双向，每个容器的迭代器支持的运算符也可能不同，因此不同容器的迭代器细节很有可能是不一样的。

删除操作时需要警惕

肆·常用算法

4.1 swap()

交换两个变量的值

4.2 sort()

默认排序从小到大

vector<int> arr{1, 9, 1, 9, 8, 1, 0};
sort(arr.begin(), arr.end());
// arr = [0, 1, 1, 1, 8, 9, 9]

如果要从大到小，则需要传比较器进去。

vector<int> arr{1, 9, 1, 9, 8, 1, 0};
sort(arr.begin(), arr.end(), greater<int>());
// arr = [9, 9, 8, 1, 1, 1, 0]

如果需要完成特殊比较，则需要手写比较器。

比较器函数返回值是 bool 类型，传参是需要比较的两个元素。记我们定义的该比较操作为 $\star$：

• 若 $a\star b$，则比较器函数应当返回 true
• 若 $a\not\star b$，则比较器函数应当返回 false

bool cmp(pair<int, int> a,pair<int, int> b){
    //第二位从小到大
    if(a.second != b.second) return a.second < b.second;
    //第一位从大到小
    return a.first > b.first;
}
//如果传入cmp的两个元素相同 则他一定会返回false 与 sort 函数实现有关
// return a.first >= b.first 错误写法 会 RE
int main()
{
    vector<pair<int, int>> arr{{1, 9}, {2, 9}, {8, 1}, {0, 0}};
    sort(arr.begin(), arr.end(), cmp);//手写比较器
    // arr = [(0, 0), (8, 1), (2, 9), (1, 9)]
    for (auto ele : arr) cout << ele.first << " " << ele.second << endl;
    return 0;
}

4.3 lower_bound() / upper_bound()

在已升序排序的元素中，应用二分查找检索指定元素，返回对应元素迭代器位置。找不到则返回尾迭代器。

• lower_bound(): 寻找 $\geq x$ 的第一个元素的位置
• upper_bound(): 寻找 $>x$ 的第一个元素的位置

怎么找 $\leq x$ / $< x$ 的第一个元素呢？

• $>x$ 的第一个元素的前一个元素（如果有）便是 $\leq x$ 的第一个元素
• $\geq x$ 的第一个元素的前一个元素（如果有）便是 $<x$ 的第一个元素

返回的是迭代器，如何转成下标索引呢？减去头迭代器即可。

用法示例

vector<int> arr{0, 1, 1, 1, 8, 9, 9};
vector<int>::iterator it = lower_bound(arr.begin(), arr.end(), 7);
int idx = it - arr.begin();
// idx = 4

我们通常写成一行：

vector<int> arr{0, 1, 1, 1, 8, 9, 9};
idx = lower_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4
idx = lower_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 4
idx = upper_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4
idx = upper_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 5

4.4 reverse()

反转一个可迭代对象的元素顺序

用法示例

vector<int> arr(10);
iota(arr.begin(), arr.end(), 1);
// 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
reverse(arr.begin(), arr.end());
// 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
reverse(arr.begin() + 2,arr.begin() + 6);//反转 为左闭右开区间 [2,6) 反转 2345

4.5 max() / min()

返回最大值 / 最小值的**数值

int mx = max({1, 2, 3, 4}); // 4
int mn = min({1, 2, 3, 4}); // 1

4.6 unique()

消除数组的重复相邻元素，数组长度不变，但是有效数据缩短，返回的是有效数据位置的结尾迭代器。

例如：$[1,1,4,5,1,4]\to[1,4,5,1,4,\underline?]$，下划线位置为返回的迭代器指向。

template< class ForwardIt >
ForwardIt unique( ForwardIt first, ForwardIt last );

用法示例

单独使用 unique 并不能达成去重效果，因为它只消除相邻的重复元素。但是如果序列有序，那么它就能去重了。

但是它去重后，序列尾部会产生一些无效数据：$[1,1,2,4,4,4,5]\to[1,2,4,5,\underline?,?,?]$，为了删掉这些无效数据，我们需要结合 erase.

vector<int> arr1{1,2,1,4,5,4,4};
//1 1 2 4 4 4 5
//1 2 4 5 *(unique返回*的位置)
sort(arr1.begin(),arr1.end());
arr1.erase(unique(arr1.begin(),arr1.end()), arr1.end());

4.7 数学函数

所有函数参数均支持 int / long long / float / double / long double

注意事项

由于浮点误差，有些的数学函数的行为可能与预期不符，导致 WA。如果你的操作数都是整型，那么用下面的写法会更稳妥。

原文地址：https://codeforces.com/blog/entry/107717

• $\lfloor\frac{a}{b}\rfloor$
  • 别用：floor(1.0 * a / b)
  • 要用：a / b
• $\lceil\frac{a}{b}\rceil$
  • 别用：ceil(1.0 * a / b)
  • 要用：(a + b - 1) / b （$\lceil\frac{a}{b}\rceil=\lfloor\frac{a+b-1}{b}\rfloor$）
• $\lfloor\sqrt a\rfloor$
  • 别用：(int) sqrt(a)
  • 要用：二分查找 https://io.zouht.com/7.html
• $a^b$
  • 别用：pow(a, b)
  • 要用：快速幂 https://io.zouht.com/18.html
• $\lfloor\log2 a\rfloor$
  • 别用：log2(a)
  • 要用：__lg （不规范，但是这是竞赛）/ `bit
  width`（C++20 可用）

4.8 gcd() / lcm()

（C++17）返回最大公因数 / 最小公倍数

int x = gcd(8, 12); // 4
int y = lcm(8, 12); // 24

如果不是 C++17，但是是 GNU 编译器（g++），那么可以用内置函数 __gcd().

当然，gcd / lcm 函数也挺好写，直接写也行（欧几里得算法）：

int gcd(int a, int b)
{
    if (!b)
        return a;
    return gcd(b, a % b);
}

int lcm(int a, int b)
{
    return a / gcd(a, b) * b;
}

STL题目练习

• 字符相关补充
  • cin.getline(buf, n, '@'); 遇到‘@’或者读满 n-1 结束
  • getchar(); 去换行
  • getline(cin, s, '@')遇到‘@’停止

5.1 Vector

洛谷 P1047

用 bool 向量记录每个位置的状态

vector<bool> arr(l + 1,false);
for(int a = 0;a < m;a++){
    int i,j;
    cin >> i >> j;
    for(int b = i;b <= j;b++) arr[b] = true;
}

5.2 Stack/Queue

洛谷 P1739表达式括号匹配

检查()左右括号匹配

遇到左括号就入一次栈 右括号就抵消一次 最后判空

stack<bool> st;
for (char ch : s){
    if(ch == '(') st.push(true);
    else if(ch == ')'){
        if(st.empty()){
            cout << "NO";
            return 0;
        }
        st.pop();//抵消一次
    }
}
if(st.empty()) cout << "YES";
else cout << "NO";

洛谷 P1449后缀表达式

stack<int> arr;//栈
string s;
int num = 0;//临时 用来存数
getline(cin, s, '@');
for( char ch : s){
    if(ch == '.'){//将数压入栈
        arr.push(num);
        num = 0;
    }
    else if(ch == '+'){
        int a = arr.top(); arr.pop();
        int b = arr.top(); arr.pop();
        arr.push(a+b);
    }
    else if(ch == '-'){
        int a = arr.top(); arr.pop();
        int b = arr.top(); arr.pop();
        arr.push(b-a);
    }
    else if(ch == '*'){
        int a = arr.top(); arr.pop();
        int b = arr.top(); arr.pop();
        arr.push(a*b);
    }
    else if(ch == '/'){
        int a = arr.top(); arr.pop();
        int b = arr.top(); arr.pop();
        arr.push(b/a);
    }
    else num = num * 10 + (ch - '0');//叠数字
}
cout << arr.top();//栈顶即是答案

洛谷 P1996 约瑟夫问题

一个圆圈点到人出局 使用队列解决问题 每次安排 m-1 个人出列到队尾 第 m 个人报数出列

for(int i = 1;i <= n;i++) arr.push(i);
while(!arr.empty()){
    for(int i = 1;i < m;i++){
        int x = arr.front();
        arr.pop();
        arr.push(x);
    }
    cout << arr.front();
    arr.pop();
    if(!arr.empty()) cout << " ";
}

5.3 Priority_queue

洛谷 P1090 合并果子

贪心（建哈弗曼树），就是每一次选取最小的两堆果子进行合并

priority_queue<int, vector<int> ,greater<int>> arr;
int n,ans = 0;
cin >> n;
for(int i = 1;i <= n;i++){
    int tmp;
    cin >> tmp;
    arr.push(tmp);
}
while(arr.size() > 1){
    int x = arr.top(); arr.pop();
    int y = arr.top(); arr.pop();
    int z = x + y;
    arr.push(z);
    ans += z;
}
cout << ans;

可以知道用 priority_queue 逐个 push n 个数，每次 push 是 O(log n)，合计 O(n log n)。

循环执行 n−1 次，每次包含 2 次 pop 和 1 次 push，堆操作都是 O(log n)，因此总计 O((n−1) log n) ≈ O(n log n)。

洛谷 P6033 合并果子 加强数据版

将所有变量开long long可以通过Subtask #3 $n = 10^5$

但对于$n = 10^7$ 目前插入的效率太低了 只能重新优化算法 我们需要双队列

• q1：存放初始排序好的果子堆大小
• q2：存放新合并出来的堆（也是递增的，因为每次插入的都是比取出来的更大的）

每次合并要做的事情：

1. 从这两个队列的队首中，取出两个最小的数（分别是 x 和 y）分两次取 第一小 第二小
2. 把 x+y 加到总代价 ans 里 把 x+y 再放回 q2（保持有序）

但仍要在push的时候优化速度 使用桶排序

（本题洛谷卡输入速度 上快读）

经验积累（ $ 5 10^5 $ 以上 上同步流 $ 2 10^6 $ 以上的考虑输入速度）

queue<long long> q1, q2;
long long ans = 0;
const int N = 100001;
vector<int> cnt(N, 0);
int maxA = 0;

#define rd read()
inline long long read()
{
    long long x = 0, y = 1;
    char c = getchar();
    while (c > '9' || c < '0')
    {
        if (c == '-')
            y = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        x = x * 10 + c - '0', c = getchar();
    return x * y;
}

long long getMin() {
    long long x;
    if (q1.empty()) {
        long long x = q2.front(); q2.pop();
        return x;
    }
    if (q2.empty()) {
        long long x = q1.front(); q1.pop();
        return x;
    }
    if (q1.front() < q2.front()) {
        long long x = q1.front(); q1.pop();
        return x;
    } else {
        long long x = q2.front(); q2.pop();
        return x;
    }
    return x;
}

int main() {
    long long n = rd;
    //桶排序
    for (int i = 0; i < n; i++) {
        int x = rd;
        cnt[x]++;
        if (x > maxA) maxA = x;  
    }
    for (int v = 1; v <= maxA; v++) while (cnt[v]--) q1.push(v);

    for (int i = 1; i < n; i++) {
        long long x = getMin();
        long long y = getMin();
        ans += x + y;
        q2.push(x + y);
    }
    cout << ans << "\n";
    return 0;
}

洛谷 P1168 中位数

• 维持动态中位数

每次排序整个数组复杂度高，对于 N=100000 会超时（O(N² log N)）。

对于大数据，使用 优先队列 维护中位数，左右两个堆

• lefta（大根堆）：存储较小的一半数据，堆顶是这一半的最大值
• righta（小根堆）：存储较大的一半数据，堆顶是这一半的最小值
• 因为 lefta 始终不少于 righta，所以 lefta.top() 就是中位数
• 对于奇数个元素：lefta.top() 是真正的中位数
• 对于偶数个元素：lefta.top() 是较小的那个中位数

priority_queue<int> lefta; // 大顶堆
priority_queue<int, vector<int>, greater<int>> righta; // 小顶堆
int N;
cin >> N;

for(int i = 0; i < N; i++) {
    int x;
    cin >> x;

    if(lefta.empty() || x <= lefta.top()) lefta.push(x);
    else righta.push(x);

    // 保持 lefta 堆大小 >= righta 堆大小，且 lefta 堆最多比 righta 多 1 个
    if(lefta.size() < righta.size()) {
        lefta.push(righta.top());
        righta.pop();
    } else if(lefta.size() > righta.size() + 1) {
        righta.push(lefta.top());
        lefta.pop();
    }

    if(i % 2 == 0) { 
        cout << lefta.top() << endl;
    }
}

洛谷 P3871 [TJOI2010] 中位数

原理与上方相同 但增加了实时添加 实时调取这些特性

priority_queue<int> lefta; //大顶堆
priority_queue<int ,vector<int>,greater<int>> righta; //小顶堆bug1

void insert(int x){
    if(lefta.empty() || x <= lefta.top())  lefta.push(x); //bug2
    else righta.push(x);

    if(righta.size() > lefta.size()){
        lefta.push(righta.top());
        righta.pop();
    }
    else if(righta.size() + 1 < lefta.size()){//bug3
        righta.push(lefta.top());
        lefta.pop();
    }
}
int main(){
    cin >> N;
    for(int i = 0;i < N;i++){
        int x; cin >> x;
        insert(x);
    }
    cin >> M;
    while(M--){
        cin >> s;
        if(s == "add"){
            int x; cin >> x;
            insert(x);
        }
        else cout << lefta.top() << endl;
    }
    return 0;
}

5.4 Set / Multiset

洛谷 P2085 最小函数值

洛谷 P1160 队列安排

5.5 map / unordered_map

P1309 瑞士轮

P5318 查找文献

P1830 轰炸

5.6 String

P1308 统计单词数

P1914 小书童——密码

P3375 【模板】KMP算法

二分查找的再梳理Update

分清两种情况 男左女右

• $ [mid,r]$ $l = mid,r = mid - 1$; mid = (l + r + 1) >> 1;
• $[l,mid]$ $r = mid,l = mid + 1$; mid = (l + r) >> 1;

//找有序数组的起始位置
vector<int> a(n + 1);
for(int i = 0;i < n;i++) cin >> a[i];
while(q--){
    int x;cin >> x;
    int l = 0,r = n - 1;
    while(l < r){
        int mid = (l + r) >> 1;
        if(a[mid] >= x) r = mid;
        else l = mid + 1;
    }
    if(a[l] != x) cout << "-1 -1" << endl;
    else{
        cout << l << " ";
        l = 0,r = n - 1;
        while(l < r){
            int mid = (l + r + 1) >> 1;
            if(a[mid] <= x) l = mid;
            else r = mid - 1;
        }
        cout << l << endl;
    }
}

二分查找算法的应用范围

• 在有序数组中进行查找一个数（二分下标）

如果数据存放在链表中，访问一个元素我们都得通过遍历，有遍历的功夫我们早就找到了这个元素，因此，在链表中不适合使用二分查找。

其中「有序」这个条件可以放宽，半有序数组或者是山脉数组里都可以应用二分查找算法。

旋转和山脉数组的值都有规律可循，元素的值不是随机出现的，在这个特点下，「减治思想」就可以应用在旋转数组和山脉数组里的一些问题上。我们可以把这两类数组统一归纳为部分有序数组

这种二分法用于查找一个有范围的数，也被称为「二分答案」，或者「二分结果」，也就是在「答案区间」里或者是「结果区间」里逐渐缩小目标元素的范围；

二分查找算法的两种思路

思路 1：在循环体中查找元素 思路 2：在循环体中排除目标元素一定不存在的区间

二分查找的时间复杂度

大 O 不在乎常数差距，只在乎增长趋势。

故 O(2⋅logn)=O(logn)

推导$\frac{n}{2^{k}}=1$

$k=\log_{2}{n} $

二分查找例用-二分下标

1基础-搜索元素位置

while(left <= right){
    int mid = left + (right - left)/2;
    if (nums[mid] == target){
        return mid;
    }
    else if (nums[mid] > target){
        right = mid - 1;
    }
    else{
        left = mid + 1;
    }
}

2基础-搜索元素位置 递归写法

public static int search(int[] nums, int target) {
    return binarySearch(nums, target, 0, nums.length - 1);
}

private static int binarySearch(int[] nums, int target, int left, int right) {
    if (left > right) {
        return -1;
    }

    int mid = left + (right - left) / 2;

    if (nums[mid] == target) {
        return mid;
    } else if (nums[mid] > target) {
        return binarySearch(nums, target, left, mid - 1);
    } else {
        return binarySearch(nums, target, mid + 1, right);
    }
}

3基础-在有序数组中查找元素的第一个和最后一个位置

public int[] searchRange(int[] nums, int target) {
    int left = find(nums, target, true);  // 左
    int right = find(nums, target, false); // 右
    return new int[]{left, right};
}
private int find(int[] nums,int target,boolean isLeft){
    int right = nums.length - 1,left = 0;
    int bound = -1;
    while(left <= right){
        int mid = left + (right - left)/2;
        if(nums[mid] == target){
            bound = mid;
            if(isLeft){
                right = mid - 1;
            }
            else{
                left = mid + 1;
            }
        }
        else if(nums[mid] > target){
            right = mid - 1;
        }
        else{
            left = mid + 1;
        }
    }
    return bound;
}

4旋转数组-无重复寻找最小值

边界处理

情况一：nums[mid] > nums[right]

说明 最小值一定在右边（mid 不可能是最小值）。 因为 nums[mid] 比 nums[right] 大，说明从 mid+1 到 right 这段区间里一定有更小的值。

所以我们可以放心地写：

left = mid + 1;

情况二：nums[mid] < nums[right]

说明 最小值在左边，而且 mid 本身可能就是最小值。

所以不能丢掉 mid，只能写：

right = mid;

保留 mid 继续判断。

当 left == right 时，就是最小值的下标。

-> 绕路 mid左右加和 不影响复杂度 但只需要判断 哪一边有序，或者 最小值在哪一边，就能决定收缩方向

public int findMin(int[] nums) {
     int left = 0;
     int right = nums.length - 1;

     while(left < right){
         int mid = left + (right - left)/2;
         if(nums[mid] > nums[right]){
            left = mid + 1;
         } else{
            right = mid;
         }
     }
     return nums[right];
}

旋转数组有重复最小值 II

while(left < right){
     int mid = left + (right - left)/2;
     if(nums[mid] > nums[right]){
        left = mid + 1;
     } else if(nums[mid] < nums[right]){
        right = mid;
     } else{
        right--;
     }
 }
 return nums[right];

5搜索旋转数组无重复

法一 先找最小值，将数组拆分

public int search(int[] nums, int target) {
    int mainIndex = searchMin(nums);

    int leftIndex = getBound(nums,target,0,mainIndex - 1);//左面
    int rightIndex = getBound(nums,target,mainIndex,nums.length - 1);//右面

    if (leftIndex != rightIndex) return Math.max(leftIndex,rightIndex);
    else return -1;

}
private int getBound(int[] nums,int target,int left,int right){
    while(left <= right){
        int mid = left + (right - left)/2;
        if(nums[mid] == target){
            return mid;
        }
        else if(nums[mid] > target){
            right = mid - 1;
        }
        else{
            left = mid + 1;
        }
    }
    return -1;
}
private int searchMin(int[] nums){
    int left = 0;
    int right = nums.length - 1;

    while(left < right){
        int mid = left + (right - left)/2;

        if (nums[mid] < nums[right]){
            right = mid;
        }
        else if (nums[mid] > nums[right]){
            left = mid + 1;
        }
    }
    return right;
}

法二 一步二分法

每次二分时，至少有一半区间是有序的。

• if nums[left] <= nums[mid] → 左边有序
• 否则右边有序。

判断 target 是否在有序区间里。

• 如果在，就缩小到有序区间；
• 如果不在，就缩小到另一半。

while (left <= right) {
    int mid = left + (right - left) / 2;

    if (nums[mid] == target) return mid;

    // 左边有序
    if (nums[left] <= nums[mid]) {
        if (target >= nums[left] && target < nums[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    } 
    // 右边有序
    else {
        if (target > nums[mid] && target <= nums[right]) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
}

6搜索旋转数组有重复数组 II

法一 两步失效

小云同学还期望改造刚才的无重复数组 但她考虑到时间复杂度在最坏情况下退化为 O(n) 故给搜索最小数的时候也加上了 right--;但很不幸无法 AC（280/282）

样例是

nums = [1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1] target = 2

她发现在有大量重复元素的情况下（如样例），searchMin 找到的 旋转点位置不唯一，从而导致分段二分出错 她终于发现是算法思路限制 无法通过修补通过这个样例

法二

while(left <= right){ //错点 1
    int mid = left + (right - left)/2;

    if(nums[mid] == target) return true;

    // 遇到重复元素无法判断哪边有序
    if(nums[left] == nums[mid] && nums[mid] == nums[right]){
        left++;
        right--;
    }
    // 左半边有序
    else if(nums[mid] >= nums[left]){
        if(target >= nums[left] && target < nums[mid]){
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    // 右半边有序
    else {
        if(target > nums[mid] && target <= nums[right]){
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
}

7山脉数组找峰顶索引

while(left < right){
    int mid = left + (right - left)/2;
    if(arr[mid] < arr[mid+1]){
        left = mid + 1;
    }
    else{
        right = mid;
    }
}

8山脉数组中查找目标值

使用相对熟悉的多步二分直接 AC 但请 GPT 大人纠正了一些错误代码习惯 摘录在这里

1. 减少重复调用 mountainArr.get(mid)

在 find 和 getmax 中，每次判断都调用了两次 mountainArr.get(mid) 或 mountainArr.get(mid+1)。

2. 二分查找时使用 left <= right 而不是 left < right

原来的 while(left < right) 循环会在循环结束后再单独判断 mountainArr.get(left)，加上上面的优化可以直接写成标准二分查找形式 left <= right，逻辑更干净。

private int getPeak(MountainArray mountainArr){
    int left = 0, right = mountainArr.length() - 1;
    while(left < right){
        int mid = left + (right - left)/2;
        int midVal = mountainArr.get(mid);
        int midNextVal = mountainArr.get(mid + 1);
        if(midVal < midNextVal) left = mid + 1;
        else right = mid;
    }
    return left;
}

private int binarySearch(MountainArray mountainArr, int target, int left, int right, boolean increasing){
    while(left <= right){
        int mid = left + (right - left)/2;
        int midVal = mountainArr.get(mid);
        if(midVal == target) return mid;
        if(increasing){
            if(midVal < target) left = mid + 1;
            else right = mid - 1;
        } else {
            if(midVal > target) left = mid + 1;
            else right = mid - 1;
        }
    }
    return -1;
}

但通过刚才经验了解不是很熟练一次二分 故写了一下 有些小问题记录一下

int m2 = mountainArr.get(mid+1); 可能越界

• 当 mid == mountainArr.length() - 1 时，mid+1 会越界。
• 在取 m2 前先判断 mid < length - 1，否则不要去访问 mid+1。

但仍不能 AC 对于 样例点 输入 [0,5,1] 0 输出 -1 有问题

这才意识到这种做法无法保证返回最小下标 故放弃

public int findInMountainArray(int target, MountainArray mountainArr) {
        int left = 0;
        int right = mountainArr.length() - 1;
        while(left <= right){
            int mid = left + (right - left)/2;
            int m1 = mountainArr.get(mid);

            if(m1 == target) return mid;

            if(mid < mountainArr.length() - 1){ //越界检查
                int m2 = mountainArr.get(mid + 1);
                if(m1 < m2) { //上升区间,m1上升 
                    if(m1 < target) left = mid + 1; //m1小于目标值 去掉左边
                    else right = mid - 1;
                }
                else{ //下降区间
                    if(m1 < target) right = mid - 1;
                    else left = mid + 1;
                }   
            }
            else right = mid - 1; // mid 已经在数组最后，直接往左缩
        }
        return -1;
    }

9小结Boss寻找两个正序数组的中位数

参考题解

法一：划分法

给定两个正序数组 nums1 和 nums2，求它们合并后的中位数，时间复杂度 O(log(m+n)) 暗示我们不能真的合并数组，而要用「二分法」。

Step1思考

中位数把一个有序数组分成两部分：

1. 左边部分的元素全部 ≤ 右边部分的元素
2. 左边部分和右边部分长度相等（或左边多 1 个）

如果我们能把两个数组合并后的「左边」和「右边」拆开，就能直接得到中位数。

我们希望 leftA + leftB 和 rightA + rightB：

• 左边所有元素 ≤ 右边所有元素
• 左边长度 = 右边长度（或左边多 1）

记：

i + j = (m + n + 1) / 2

这个公式保证左右两边长度关系正确（总长度奇偶都通用）

然后要满足：

A[i-1] ≤ B[j]   // A左最大 ≤ B右最小
B[j-1] ≤ A[i]   // B左最大 ≤ A右最小

Step2二分法找 i

为了避免处理太多边界情况，我们规定 A 是短数组（m ≤ n）。

• 在 [0, m] 范围里二分查找 i
• 通过指针 left right 算出 i
• 计算 j = (m + n + 1)/2 - i （有一种向上取整的意味）
• 检查：
  • 如果 A[i-1] > B[j] → i 太大，向左移动
  • 如果 B[j-1] > A[i] → i 太小，向右移动
• 找到满足条件的 i，即划分完成

注意边界处理：

• i = 0 → left_A 为空 → A[i-1] = -∞
• i = m → right_A 为空 → A[i] = ∞
• j = 0 或 j = n 同理

另在 Java 中：

• 正无穷 → Integer.MAX_VALUE
• 负无穷 → Integer.MIN_VALUE

在C++中

• 正无穷 → INT_MAX（<climits> 中定义）

• 负无穷 → INT_MIN

Step3计算中位数

划分完成后：

max_of_left = max(A[i-1], B[j-1])
min_of_right = min(A[i], B[j])

• 如果总长度是奇数 → 中位数 = maxofleft
• 如果总长度是偶数 → 中位数 = (maxofleft + minofright) / 2

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    if (nums1.length > nums2.length) { //保证nums1是短数组
        return findMedianSortedArrays(nums2, nums1);
    }
    int m = nums1.length;
    int n = nums2.length;
    int left = 0,right = m;//表示可选择的空位

    while(left <= right){
        //i,j 表示切点
        int i = left + (right - left)/2;
        int j = (m + n + 1)/2 - i;

        int A_left = (i == 0) ? Integer.MIN_VALUE : nums1[i-1];// 左面没有元素
        int A_right = (i == m) ? Integer.MAX_VALUE : nums1[i]; // 右面没有元素
        int B_left = (j == 0) ? Integer.MIN_VALUE : nums2[j-1];
        int B_right = (j == n) ? Integer.MAX_VALUE : nums2[j];

        if( A_left <= B_right && B_left <= A_right){ //划分正确
            if ((m + n) % 2 == 0) {
                return (Math.max(A_left, B_left) + Math.min(A_right, B_right)) / 2.0;
            } else {
                return Math.max(A_left, B_left);
            }
        }
        if(A_left > B_right){ //A左最大 > B右最小 i太大 向左移
            right = i - 1; //通过i来影响right
        }
        if(B_left > A_right){// B左最大 > A右最小 i小 向右移
            left = i + 1;
        } 
    }
    return -1;
}

法二 直接二分

数学难度较大 写了一个还没 AC 的代码 比较头晕 后清清脑子再补 先贴一个题解

二分查找例用-二分答案

特征

答案空间可枚举 + 存在单调性函数 + 能通过函数值判断往左还是往右。

1. 答案在一个范围内，范围可枚举（通常是整数区间）
2. 可以定义一个单调性函数 f(x)，用来判断当前 x 是否「可行」或「过大/过小」。
   • 在2题：
     • 定义 count = # {nums[i] ≤ mid}。
     • 若 count > mid → 说明重复数一定在左半边。
     • 单调性：随着 mid 增大，count 只会变大或相等。
   • 在3题：
     • 定义 f(x) = sum(min(a, x))。
     • 单调性：随着 x 增大，f(x) 只会变大或相等。
3. 目标是找到某个最优点/最接近点，而不是直接找到某个精确位置。
   • 在2题：我们最终要精确锁定唯一的重复数。
   • 在3题：我们要让 f(x) 最接近 target，可能会停在两个候选解之间 → 需要比较。

1计算算术平方根

public int mySqrt(int x) {
    if (x == 0) {
        return 0;
    }
    int left = 1;
    int right = x / 2;

    while (left < right){
        int mid = (left + right + 1) / 2; //向上取整

        if (mid > x / mid) {
            // 大于等于mid的数一定不是解，下一轮搜索的区间为 [left, mid - 1]
            right = mid - 1;
        } else {
            left = mid;
        }
    }
    return left;
}

2寻找重复数

二分法

-> 在 值的范围 上做二分，而不是在数组下标上

public int findDuplicate(int[] nums) {
    int left = 1, right = nums.length - 1; // 搜索的值域范围 [1, n]
    while (left < right) {
        int mid = left + (right - left) / 2;
        int count = 0;
        // 统计 <= mid 的元素个数
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] <= mid) count++;
        }
        if (count > mid) {
            // 重复数在 [left, mid]
            right = mid;
        } else {
            // 重复数在 [mid+1, right]
            left = mid + 1;
        }
    }
    return left;
}

在没有重复的情况下： 在区间 [1, mid] 里，最多应该有 mid 个不同的数。 所以 count ≤ mid。

如果 count > mid： 说明在 [1, mid] 这个区间里，元素的数量超过了它本应能容纳的数量，这区间里一定有重复数。 → 因此我们缩小搜索区间到 [left, mid]。

如果 count ≤ mid： 说明 [1, mid] 内没有超过容量，重复数只能出现在 [mid+1, right]。

public int findDuplicate(int[] nums) {
    int left = 1, right = nums.length - 1; // 搜索的值域范围 [1, n]
    while (left < right) {
        int mid = left + (right - left) / 2;
        int count = 0;
        // 统计 <= mid 的元素个数
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] <= mid) count++;
        }
        if (count > mid) {
            // 重复数在 [left, mid]
            right = mid;
        } else {
            // 重复数在 [mid+1, right]
            left = mid + 1;
        }
    }
    return left;
}

链表思路-快慢指针

• 见链表章节(后续更新)

3转变数组后最接近目标值的数组和

• 第一遍写没有打上调试发现不太对劲 有两个错误 已标注在代码中

public int findBestValue(int[] arr, int target) {
    int len = arr.length;
    int left = 0,right = findMax(arr,len);
    while(left < right){
        int mid = left + (right - left)/2;
        int count = js(arr,len,mid);
        System.out.println(mid);
        System.out.println(count);
        if(target <= count) right = mid; 
        //错点一 原为right = mid - 1在「最接近目标」的题里，我们不是要严格排除 mid，而是要保留它作为候选值。
        else left = mid + 1;
    }
    int c1 = Math.abs(js(arr,len,left) - target);
    int c2 = (left > 0) ? Math.abs(js(arr, len, left - 1) - target) : Integer.MAX_VALUE;
    //错点二 int c2 = Math.abs(js(arr,len,left - 1) - target); left-1可能越界
    if(c1 == c2) return Math.min(left,left - 1);
    else if(c1 > c2) return left - 1;
    else return left;
}
private int js(int[] nums,int len,int mid){
    int count = 0;
    for(int i = 0;i < len;i++){
        count += Math.min(nums[i],mid);
    }
    return count;
}
private int findMax(int[] nums,int len){
    int max = 0;
    for(int i = 0;i < len;i++){
        max = Math.max(max, nums[i]);
    }
    return max;
}

该渲染由 Shiro API 生成，可能存在排版问题，最佳体验请前往：https://gwy.fun/posts/ACM/algorithm-foundation-p1-introduction

条件表达式 ? 表达式1 : 表达式2

printf("%.nf", x);

double x = 3.14159;
printf("%.2f\n", x);  // 输出：3.14
printf("%.3f\n", x);  // 输出：3.142
printf("%8.2f\n", x); // 输出：   3.14 （总宽8位，右对齐）

#include <iomanip>

double x = 3.14159;
cout << setprecision(3) << x;  // 输出：3.14（有效数字3位）

cout << fixed << setprecision(3) << x;  // 输出：3.142

cout << scientific << setprecision(2) << x;
// 输出：3.14e+00

cout << setw(8) << setfill('*') << fixed << setprecision(2) << x;
// 输出：***3.14

if (fabs(a - b) < 1e-9)

__int128 mul(__int128 a, __int128 b, long long mod) {
    return (a * b) % mod;
}

void print(__int128 x) {
    if (x == 0) return;
    print(x / 10);
    putchar(x % 10 + '0');
}

#define rd read()
inline long long read()
{
    long long x = 0, y = 1;
    char c = getchar();
    while (c > '9' || c < '0')
    {
        if (c == '-')
            y = -1;
        c = getchar();
    }
    while (c >= '0' && c <= '9')
        x = x * 10 + c - '0', c = getchar();
    return x * y;
}

//使用long long n = rd;

string s = "abc";
int num[26] = {0};
for (char c : s)
    num[c - 'a']++; // 统计字母出现次数
int cnt[256] = {0};
for (unsigned char c : s)
    cnt[c]++; // 统计所有 ASCII 字符出现次数

cin >> n;
getchar(); // 或 cin.ignore();
getline(cin, s); // 现在才能正确读入整行

看完了？说点什么呢

三个仓库 Remote Local Disk 将本地仓库想象成两个部分

流程

正常步骤

git clone 三仓库统一

git checkout -b my-feature 创建 feature branch 而不是往 main push code

“硬盘 Disk 不在意是源文件来自哪个 branch”

git diff 查看暂存区与disk区文件的差异

git add <chanssged_file>

git commit 将暂存区内容添加到local区的当前分支中

git push origin my-feature 提交

另外情况

git checkout main 不是修改状态

git fetch origin 拉取远端最新分支

git rebase main 这一步会让 Git 把在 my-feature 上的提交“搬到”origin/main 最新提交之后

假设当前分支与 main分支存在共同部分common，该指令用 main分支包括common在内的整体替换当前分支的common部分（原先xxx分支内容为common->diversityA，当前分支内容为common->diversityB，执行完该指令后当前分支内容为common->diversityA->diversityB）。

然后在 Github create pull request ->Squash and merge

删除远端 branch

删除本地 先切换git checkout main 再 git branch -D my-feature

git pull origin master

实际项目情况

main：生产环境，也就是你们在网上可以下载到的版本，是经过了很多轮测试得到的稳定版本。

release：开发内部发版，也就是测试环境。

dev：所有的feature都要从dev上checkout。

feature：每个需求新创建的分支。

1.从dev分支上checkout -b new-feature，进行开发

2.开发完后，经过自测没问题了，准备发版

3.merge到release分支上进行发版，并打tag

4.有bug就直接在release上进行修改，改完再次发版，打tag，直到测试人员验证完毕

5.这时可以将release分支合并到dev上，也可以删除掉feature分支了，并等待通知是否将此功能上线（在正式服务器上运行），如果上线，那就merge到main（master）分支。

• 参考 https://www.bilibili.com/video/BV19e4y1q7JJ