OpticHong's Blog

Graduate Notes

2025-07-22T09:59:41.000Z

All the notes are based on Notion and cannot be accessed without magic.

Notes for Papers | Share some excellent papers that I read during my graduate studies

No.	Content	Date
1	分布式训练	07.25.2025
2	nanoVLM	09.27.2025

机式指南

2025-03-01T05:27:51.000Z

机式重点永远是树结构、图结构以及动态规划！！！

夏令营经典题型

结构体排序问题

这类问题往往都是一个模板，即待排序的数据都是结构体，排序规则涉及到结构体中的多个元素。

其中，结构体的构造部分尽可能使用struct而不是用class（这是因为，算法题中一般都只是涉及到“组织”的问题，因此完全不需要使用对“封装、继承”等相对完善的class）。

此外，排序规则需要构建一个返回值为bool，传递两个结构体元素的比较函数bool cmp(Elem e1,Elem e2)，具体函数内的返回规则需要根据题目所给的判断逻辑进行编写。

#include 
using namespace std;
cosnt int N =1e5+10;
struct Elem{
string str;// 如果不支持c++，则需要改成字符数组 char str[30];此外进行字符串比较时，需要利用strcmp(s1,s2)进行比较。
  int age;
  double socre;
}Stu[N];

bool cmp(Elem e1, Elem e2){
  if(e1.socre != e2.socre) return e1.socre < e2.socre;//这是升序排列
  else if(e1.str != e2.str) return e1.str < e2.str;
  else return e1.age < e2.age;
}

int main(){
  //首先是输入逻辑部分，对结构体进行填充。
  int n;
  cin>>n;
  for(int i=0;i>Stu[i].str>>Stu[i].age>>Stu[i].socre;
  //对结构体中的数据，利用内置函数sort进行排序。
  sort(Stu,Stu+n,cmp);
  //最后根据题目所给要求进行输出。
  cout<0].str<0].age<0].score;
  return 0;
}

# 定义结构体类
class Elem:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score

# 自定义比较函数
def cmp(elem):
    # 按照分数升序排列，如果分数相同，则按照名字升序排列，再按照年龄升序排列
    return (elem.score, elem.name, elem.age)

###
在 Python 中，sort 和 sorted 函数支持通过 key 参数指定排序规则，而 key 参数需要传入一个函数，该函数会对每个元素进行处理，返回一个可以比较的值（如数字或元组）。根据这个返回值，Python 会对所有元素进行排序。
###

def main():
    # 输入数据
    n = int(input())
    students = []
    for _ in range(n):
        name, age, score = input().split()  
        age = int(age)
        score = float(score)
        students.append(Elem(name, age, score))
    
    # 对数据进行排序
    students.sort(key=cmp)  #默认是整体升序排列，如果需要整体降序，参数reverse可以置为True。如果排序中的某一非数值属性需要降序，则将字符串进行反转[::-1]，数值属性需要降序直接加负号即可。如果需要按照字符串第一个字符进行排序可以使用ord()函数。
    
    # 输出第一个学生的信息
    print(students[0].name, students[0].age, students[0].score)

if __name__ == "__main__":
    main()

注意事项

这种题目的变体，多集中在模板中最关键的两步，即是否待排序的元素需要构建结构体，以及需要构建多个排序规则。

是否需要构建结构体？
当涉及到待排序元素有多个属性时，这个时候毫无疑问构建结构体是一种不错的结果方案；
但是，待排序元素就只用单一属性时，这个时候也可能需要构建结构体。此时，我们需要明白构建结构体的目的是为了更方便的排序，是因为但从其自身的属性上已经不好进行快速比较时，才将比较的逻辑单独抽离出来。比如说，字符串的排序，但排序的逻辑不再是字符串的字典序，而是其字符串的长度。
构建多个排序规则。
多个和单个排序规则本质上没有太大区别。注意到题目中如果有多种情况需要利用到不同的排序规则时，在代码中需要使用case进行实现。

日期类问题

这类问题往往属于模拟的大类，其最明显的特点就是没有难以理解的算法，更多的是进行模拟。

其中涉及到的知识点有：闰年判断、1年1月1日为星期一

额外需要注意的就是这几个周期和月份单词的拼写。

间隔时间

#include 
using namespace std;
int date[2][13]={{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}}; //首先定义每月天数，将闰月年区分开来，方便后面判断完闰年后的月份天数确定。
bool isLeap(int year){ //判断闰年的函数，被400整除或者被4整除但不被100整除
  return ((year%4==0)&&(year%100!=0)) || (year%400==0);
}

int main(){
  int time1,time2,y1,y2,m1,m2,d1,d2;
  while(cin>>time1>>time2){
    if(time1>time2){int tmp=time2;time2=time1;time1=time2;}
    //需要前面的数字就用除，需要后面的数字就用模
    y1=time1/10000,m1=time1%10000/100,d1=time1%100;
    y2=time2/10000,m2=time2%10000/100,d2=time2%100;
    int sum=1;
    while(y1//使用天数累加的方式进行模拟
      d1++;
      if(d1==date[isLeap(y1)][m1]+1){m1++;d1=1;}
      if(m1==13){y1++;m1=1;}
      sum++;
    }
    cout<
  }
  return 0;
}

date=[
    [0,31,28,31,30,31,30,31,31,30,31,30,31],
    [0,31,29,31,30,31,30,31,31,30,31,30,31]
]
def is_leap(year):
    return (year%4==0 and year%100!=0) or year%400==0

def main():
    sum_date=1
    while True:
        try:
            time1,time2=map(int,input().split())
            if time1>time2:
                time1,time2=time2,time1
            year1,month1,day1=time1//10000,time1%10000//100,time1%100
            year2,month2,day2=time2//10000,time2%10000//100,time2%100
            while year1or month1or day1
                day1+=1
                if day1==date[is_leap(year1)][month1]+1:
                    day1=1
                    month1+=1
                if month1==13:
                    month1=1
                    year1+=1
                sum_date+=1
            print(sum_date)
        except:
            break
                
main() 

判断星期

#include 
using namespace std;
bool isleap(int y) { return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0; }
int m[2][13] = {{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
                {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
string week[7] = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
string mouth[13] = {"","January","February","March","April","May","June","July","August","September","October","November","December"};
int main() {
  int d2, m2, y2, d1 = 1, m1 = 1, y1 = 1;
  string mm;
  cin >> d2 >> mm >> y2;
  for (int i = 1; i <= 12; i++)
    if (mm == mouth[i]) {m2 = i;break;}
  int sum = 1;
  while (d1 < d2 || m1 < m2 || y1 < y2) {
    d1++;
    if (d1 == m[isleap(y1)][m1] + 1) {d1 = 1;m1++;}
    if (m1 == 13) {m1 = 1;y1++;}
    sum++;
  }
  cout << week[sum % 7] << endl;
  return 0;
}

C/C++快速入门

绝对值在$10^9$范围以内的整数都可以定义为int型。其他情况，使用typedef long long ll;类型，以及unsigned long long (ull)类型。
const int INF=0x3fffffff;
cout<设置输出x的宽度为7，其中小数部分占2位。
浮点数比较大小：
const double eps=1e-8;
等于：#define equ(a,b) fabs(a-b)
大于：#define more(a,b) (a-b)>eps
小于：#define less(a,b) (a-b)<-eps
大于等于：#define more_eq(a,b) (a-b)>-eps
小于等于：#define less_eq(a,b) (a-b)
π值：const double pi=acos(-1.0);
如果两个操作数都是整数类型（例如 int、long、long long 等），则进行的是整数除法，结果将是一个整数，并且会向下取整（截断小数部分）。
在C语言中，scanf("%s", str1)用于从标准输入中读取一个字符串，并将其存储到字符数组str1中。然而，scanf函数在读取字符串后会在缓冲区中留下一个换行符（’\n’），这可能会导致后续的输入函数（如fgets或另一个scanf）出现问题。为了解决这个问题，可以在scanf之后添加一个getchar()函数调用，以读取并消耗掉缓冲区中的换行符。这样可以确保下一个输入函数从清空了缓冲区的状态开始读取。
大规模输入输出时，不要用cin和cout，否则时间真的会超限！
long long 和int不要混用！

mex(arr) 表示数组arr中末出现过的最小非负整数。例如[0,1,2,4]的mex为3。

int mex(const vector<int>& arr) {
    unordered_set<int> s(arr.begin(), arr.end());
    int mex = 0;
    while (s.count(mex)) mex++;
    return mex;
}

`Python快速入门`

Python构建二维数组的方法：[[0] * (n + 1) for _ in range(m + 1)]，这样构建的二维数组，在修改任意元素时不会造成其他位置的元素被修改。

Python的排序函数：sorted()，可用于对任何可迭代对象（如列表、元组、字符串等）进行排序。sorted()返回排序后的新列表，不会改变原列表。

 1
2
3
4
numbers = [5, 2, 9, 1, 5, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出：[1, 2, 5, 5, 6, 9]
print(numbers)         # 输出：[5, 2, 9, 1, 5, 6]（原列表未改变）
 此外，list.sort()可以实现就地排序。
 1
2
3
numbers = [5, 2, 9, 1, 5, 6]
numbers.sort()
print(numbers)  # 输出：[1, 2, 5, 5, 6, 9]

Python获取子字符串只需要通过切片就行。字符串的拼接和复制也只需通过简单的数学运算符+和*实现。

`入门模拟`

`日期计算`

有两个日期，求两个日期之间的天数，如果两个日期是连续的，则规定它们之间的天数为两天。

#include 
using namespace std;
int date[2][13]={{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,31,31,30,31,30,31}};
bool isLeap(int year){
  return ((year%4==0)&&(year%100!=0)) || (year%400==0);
}
int main(){
  int time1,time2,y1,y2,m1,m2,d1,d2;
  while(cin>>time1>>time2){
    if(time1>time2){int tmp=time2;time2=time1;time1=time2;}
    //需要前面的数字就用除，需要后面的数字就用模
    y1=time1/10000,m1=time1%10000/100,d1=time1%100;
    y2=time2/10000,m2=time2%10000/100,d2=time2%100;
    int sum=1;
    while(y1
      d1++;
      if(d1==date[isLeap(y1)][m1]+1){m1++;d1=1;}
      if(m1==13){y1++;m1=1;}
      sum++;
    }
    cout<
  }
  return 0;
}

由日期换算成星期时，也是需要用两日期的差值进行计算的。记1年1月1日为星期一，创建周期数组（注意第一个值为Sunday）：

string week[7]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};

`进制转换`

两种非十进制需要借助十进制进行转换。如果涉及到小数，只能用字符串存储，然后根据整数部分除基取余和根据小数部分乘基取整完成运算。

#include 
using namespace std;
typedef long long ll;
char alpha[6]={'A','B','C','D','E','F'};
int main(){
    int a,b;char n[80];
    while(scanf("%d%s%d",&a,n,&b)!=EOF){
        ll res_10=0; int len=strlen(n);
        for(int i=0;i'9'? n[i]-'0': n[i]<='F'? n[i]-'A'+10: n[i]-'a' + 10);
        if(b==10) cout<
        else{
            char res_b[80]; int cnt=0;
            memset(res_b,0,sizeof(res_b));
            do{
                res_b[cnt++]= res_10%b <= 9 ?res_10%b + '0': alpha[res_10%b-10];
                res_10/=b;
            }while(res_10);
            for(int i=cnt-1;i>=0;i--) cout<
            cout<
        }
        memset(n,0,sizeof(n));
    }
    return 0;
}

当需要转换的是“大数”时，就应该仔细地去分析进制转换的具体实现细节！

#include 
using namespace std;
char str1[37],str2[37],str3[100010];
//其中str1用来存储被除数，str2用来存储除数，str3用来存储二进制结果。
bool isEmpty(char str[]){
    int len=strlen(str);
    for(int i=0;iif(str[i]!='0') return false;
    return true;
}
int main(){
    while(scanf("%s",str1)!=EOF){
        int idx1=0,idx2=0,len=strlen(str1);
        do{
            int num=0;
            while(idx1
                num=num*10+str1[idx1]-'0';
                str2[idx1++]=num/2 + '0';
                num%=2;
            }
            str3[idx2++]=num + '0';
            for(int i=0;i<=len;i++) if(str2[i]){idx1=i;break;}
            memset(str1,0,sizeof(str1));
            strcpy(str1, str2);  //交换被除数和除数
            memset(str2,0,sizeof(str2));
        }while(!isEmpty(str1));
        int len1=strlen(str3);
        for(int i=len1-1;i>=0;i--) cout<
        cout<
        memset(str3,0,sizeof(str3));
    }
  return 0;
}

[!caution]
这段代码对10进制以下的进制都是通用的，只需要把最里层while循环中的两个‘2’换成所需要转换的进制数即可。
当然对于11-16进制，只需要再添加一个char alpha[6]={'A','B','C','D','E','F'};这样的aplha转换表即可。

`字符串转数值`

这是一类经典的题目，不要再单独写一个函数用来str_to_int了

“123456789”转成对应的数值其实相当方便：

int sum=0,len=strlen(str);
for(int i=0;i
  sum=sum*10+str[i]-'0';

而数值转字符串就更加方便了：

int num=123456789;
char str[20];
sprintf(str,"%d",num);

`数学知识`

`质数`

`质数的判定`

时间复杂度为$O(\sqrt n)$

bool is_prime(int n){
  if(n<2) return false;
    for(int i=2;i<=n/i;i++){
            if(n%i==0) return false;
    }
  return true;
}

def is_prime(n):
    if n<2: return False
    i=2
    while i*i <=n:
        if n%i==0: return False
        i+=1
    return True

`分解质因子`

时间复杂度为$O(logn\sim \sqrt n)$

void divide(int n){
  for(int i=2;i<=n/i;i++){
      if(n%i==0) {
          int s=0;
          while(n%i==0){
              n/=i; s++;
            }
          printf("%d %d\n",i,s);
        }
    }
  if(n>1) printf("%d %d\n",n,1);
}

def divide(n):
    i=2
    while i*i <=n:
        if n%i==0:
            s=0
            while n%i==0:
                n//=i
                s+=1
            print(i,s)
        i+=1
    if n>1: print(n,1)

`埃氏筛`

时间复杂度$O(nloglogn)$

const int N=1e5+10;
int primes[N],cnt;
bool st[N];
void get_primes(int n){
  for(int i=2;i<=n;i++){
      if(!st[i]){
          primes[cnt++]=n;
          for(int j=2*i;j<=n;j+=i) st[j]=true;
        }
    }
}

`欧拉筛`

时间复杂度$O(n)$，每个数只会被其最小质因子筛掉。

const int N=1e5+10;
int primes[N],cnt;
bool st[N];
void get_primes(int n){
  for(int i=2;i<=n;i++){
      if(!st[i]) primes[cnt++]=i;
      for(int j=0;primes[j]<=n/i;j++){
          st[primes[j]*i]=true;
          if(i%primes[j]==0) break;
        }
    }
}

`约数`

`分解约数`

vector<int> get_divisors(int n){
  vector<int> res;
  for(int i=1;i<=n/i;i++){
      if(n%i==0){
          res.push_back(i);
          if(i!=n/i) res.push_back(n/i);
        }
    }
  sort(res.begin(),res.end());
  return res;
}

`约数个数`

`约数之和`

`最大公约数`

int gcd(int a,int b){
  return b ? gcd(b,a%b) : a;
}

`算法初步`

`排序`

`冒泡排序`

冒泡排序通过多次比较和交换相邻元素的方式将待排序的数据按照升序或降序进行排序。时间复杂度：$O(n^2)$。

void BubbleSort(int arr[],int len){
    for(int i=1;i
        for(int j=0;j
            if(arr[j]>arr[j+1]){int tmp=arr[j];arr[j]=arr[j+1];arr[j+1]=tmp;}
}

`选择排序`

选择排序将待排序的数据序列分为已排序部分和未排序部分，每次从未排序部分选择最小（或最大）的元素，将其放置在已排序部分的末尾，直到整个序列排序完成。时间复杂度：$O(n^2)$。

void SelectionSort(int arr[],int len){
    for(int i=0;i
        int idx=i;
        for(int j=idx+1;jif(arr[j]
        int tmp=arr[idx]; arr[idx]=arr[i]; arr[i]=tmp;
    }
}

`直接插入排序`

插入排序将待排序的数据序列分为已排序部分和未排序部分，每次从未排序部分选择一个元素插入到已排序部分的合适位置，直到整个序列排序完成。时间复杂度：$O(n^2)$。

void InsertionSort(int arr[],int len){
    for(int i=1;i
        int idx=0;
        while(idx<= i){if(arr[i]int tmp=arr[i];arr[i]=arr[idx];arr[idx]=tmp;}idx++;}
    }
}

`希尔排序`

希尔排序（Shell Sort）是一种基于插入排序的排序算法，旨在提高插入排序在大规模数据集上的效率。它通过比较距离较远的元素来进行排序，从而减少了数据移动的次数。

分组排序：将整个待排序的数组按照一定的增量（gap）分成若干个子序列，对每个子序列分别进行插入排序。初始的增量较大，随着算法的进行逐渐减小，直到增量为1，此时整个数组被当作一个子序列进行插入排序。
增量序列：增量序列的选择对希尔排序的性能有很大影响。常用的增量序列有希尔增量（gap = n/2, n/4, …, 1）、Hibbard增量（1, 3, 7, 15, …）等。理想的增量序列可以减少比较次数和移动次数，从而提高排序效率。
排序过程：初始时选择一个较大的增量，将数组元素分组。对每个分组内的元素进行插入排序。减小增量，重复上述步骤，直到增量为1。

`快速排序`

快速排序是通过分治的策略将一个大问题分解为多个子问题，然后逐步解决子问题，最终达到整体问题的解决。

快速排序的基本思想可以概括为以下几个步骤：

选择一个基准元素：从待排序的数组中选择一个元素作为基准，通常选择第一个元素、最后一个元素或者随机选取。
分区：将数组中的其他元素按照与基准元素的大小关系分为两个子数组，一个子数组中的元素小于基准元素，另一个子数组中的元素大于基准元素。同时，基准元素所在的位置也确定了。
递归排序：对分区后的两个子数组递归地应用上述步骤，直到子数组的大小为1或0（即已经有序）。
合并结果：将所有子数组的结果合并起来，即得到最终的有序数组。

void QuickSort(int arr[],int l,int r){
    if(l>=r) return;  //递归出口
    int num=arr[l],front=l-1,rear=r+1; //注意前后两指针的初始位置
    while(front
        while(arr[++front]
        while(arr[--rear]>num);
        if(frontswap(arr[front],arr[rear]);
    }
    QuickSort(arr,l,rear);
    QuickSort(arr,rear+1,r);
}

[!IMPORTANT]
从快排中抽离出来的一个双指针的思想
1
2
3
4
5
while(front
while(Condition1) Action1; 
while(Condition2) Action2;
Action3;
}
Condition1用来确定左指针在一轮循环中什么时候停止，Action1是遍历左端序列时需要做的行为；
Condition2用来确定右指针在一轮循环中什么时候停止，Action2是遍历右端序列时需要做的行为；
Action3是完成一轮循环后需要执行的动作。

`归并排序`

归并排序是一种经典的、稳定的排序算法，其基本思想是将一个大问题分解为多个小问题，通过递归地将小问题排序并合并，最终得到整体问题的解决。

归并排序的基本思想可以概括为以下几个步骤：

分解：将待排序的数组递归地分解为较小的子数组，直到每个子数组只包含一个元素（即已经有序）或为空。
合并：将分解得到的子数组逐个合并，得到更大的有序子数组。合并过程是通过比较每个子数组的元素，选取最小（或最大）的元素放入新的数组中，并移动相应的指针。
递归排序和合并：重复执行步骤1和步骤2，直到所有的子数组合并为一个完整的有序数组。

void MergeSort(int arr[],int l,int r){
    if(l>=r) return;
    int mid=l+r>>1;
    MergeSort(arr,l,mid);
    MergeSort(arr,mid+1,r);
    int idx=0, idx1=l,idx2=mid+1;
    int tmp[100010];
    while(idx1<=mid && idx2<=r)
        if(arr[idx1]
        else tmp[idx++]=arr[idx2++];
    while(idx1<=mid) tmp[idx++]=arr[idx1++];
    while(idx2<=r) tmp[idx++]=arr[idx2++];
    for(int i=l,j=0;i<=r;i++,j++) arr[i]=tmp[j];
}

[!IMPORTANT]
从归并排序中抽离出来的一个双指针的思想，也就是说双路归并使用双指针即可。
假如是多路归并呢？想想数据结构这门课中所学的赢者树和败者树，其本质都是堆。因此多路归并完全可以用堆（优先队列）进行优化。
1
2
3
4
5
6
while(idx1
   if(Condition1) Action1;
   else Action2;
}
while(Condition2) Action3;
while(Condition3) Action4;
Condition1是两个数组进行比较的条件，Action1是对应条件为真执行的动作，Action2是对应条件为假执行的动作。
Condition2是对数组1进行的扫尾条件判断，Action3是对应的扫尾动作；
Condition3是对数组2进行的扫尾条件判断，Action4是对应的扫尾动作；
OJ例题：寻找两个正序数组的中位数

`sort函数`

在OJ的题目中，一般不会手动写排序函数，可以直接调用C++的sort函数进行排序！其中，最关键的点就是排序规则的定义。默认情况下是升序排序，可以通过在第三个参数填入greater()来实现降序排序，而且是针对一般的整数数组。要自定义排序规则，则需要实现一个自定义的比较函数bool cmp()。

[!Note]
如学生类比较函数的规则：先按分数升序排序，相同按名字字母序排序。

bool cmp(Student s1, Student s2){
  if(s1.score != s2.score) return s1.score > s2.score;
  else return strcmp(s1.name,s2.name) < 0;
}

`二分`

二分通过不断将搜索范围减半来快速定位目标元素。

[!CAUTION]
二分的主要思想不是单调性（当然序列满足单调性一定能二分做），而是能否根据某一性质划分为左右两个区间！
每进行一次二分就是把答案所在的区间给缩小，因此需要准确地判断出答案应该在哪个区间！当区间的长度为1时，那么该区间中的元素就是答案！

`整数二分`

无论是l+r>>1还是l+r+1>>1都是为了数组元素个数为奇时，处理好边界问题。

int bsearch_l(int l,int r){  //找左边边界
while(l
      int mid=l+r>>1;
      if(check(mid)) r=mid; //这个check函数需要严格考虑边界情况，以及方向是否正确
      else l=mid+1;
    }
  return l; //这里无论返回是l还是r都是一样的
}

int bsearch_r(int l,int r){  //找右边边界
while(l
      int mid=l+r+1>>1;
      if(check(mid)) l=mid;
      else r=mid-1;
    }
  return l;
}

[!Tip]
主要通过check函数判断应该递归哪个区间来判断使用哪个模板。二分找不到元素的情况是下标l对应的元素不等于需要查找的元素！

`单调性二分`

int search(vector<int>& nums, int target) {
    int l=0,r=nums.size()-1;
    while(l
        int mid=(l+r)>>1;
        if(nums[mid]>=target) r=mid; //需要严格注意边界和区间
        else l=mid+1;
    }
    if(nums[l]!=target) return -1;
    else return l;

}

`特性二分`

这个题目典型就是根据旋转之后，根据哪一边是有序的这一特性进行二分的。

int search(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1;
    while (left <= right) {
        int mid = left + right >> 1;
        if (nums[mid] == target) return mid;
        // 判断哪一半是有序的
        if (nums[left] <= nums[mid])// 左半部分是有序的
            if (nums[left] <= target && target < nums[mid]) 
                right = mid - 1; // 目标值在左半部分
            else 
                left = mid + 1; // 目标值在右半部分
        else // 右半部分是有序的
            if (nums[mid] < target && target <= nums[right]) 
                left = mid + 1; // 目标值在右半部分
            else
                right = mid - 1; // 目标值在左半部分
    }
    return -1; 
}

`非指针二分`

[!Note]
这里的非指针二分其实也是特性二分中的一种，只是这种二分更加抽象，以至于连left和right都不再只是表示区间两端的指针。
如这个题目中的，假设把left定义成子区间长度的下限，而right定义为子区间长度的上限，那么问题就变成，求解一个最小的区间长度，使得check满足条件。

//判断长度为mid的子数组和是否能够大于等于target
bool isOver(vector<int>& sum, int mid, int target){
    int n = sum.size();
    for(int i=mid; i
        if((sum[i]-sum[i-mid])>=target)
            return true;
    return false;
}
int minSubArrayLen(int target, vector<int>& nums) {
    int n = nums.size();
    vector<int> sum(n+1, 0);
    for(int i=1; i<=n; i++)
        sum[i] = sum[i-1]+nums[i-1];  //前缀和
    int left = 1;
    int right = n;  //子数组的长度范围为闭区间[1, n]
    while(left<=right){  //二分查找
        int mid = (left+right)>>1;
        if(!isOver(sum, mid, target)) left = mid+1;
        else right = mid-1;
    }
    return left==n+1 ? 0 : left;
}

`左右边界不一致`

[!NOTE]
在前面的举例中，无一例外都是左右边界一直的情况，所以无论是bsearch_l还是bsearch_r都能完成任务。但是一旦当左右边界不一致时，bsearch_l所求的是左边界，而bsearch_r所求的是右边界。

vector<int> searchRange(vector<int>& nums, int target) {
    if(nums.size()==0) return vector<int>{-1,-1};
    int l=0,r=nums.size()-1;
    while(l
        int mid=(l+r+1)>>1;
        if(nums[mid]<=target) l=mid;
        else r=mid-1;
    }
    int right=l;
    l=0;r=nums.size()-1;
    while(l
        int mid=(l+r)>>1;
        if(nums[mid]>=target) r=mid;
        else l=mid+1;
    }
  int left=l;
    if(target==nums[left]) return vector<int>{left,right};
    return vector<int>{-1,-1};
}

`浮点二分`

浮点二分常见于一些求实根的题目中。eg. xmu2024年人工智能实验室夏令营机式的第一题就是利用浮点二分求实根！需要额外注意的就是eps的精度问题，一般需要比保留的位数多两位。

double bsearch_1(double l,double r){
while(r-l>eps){
      double mid=(l+r)/2;
      if(check(mid)) r=mid;  
      else l=mid;
    }
  return l;
}

当然，如果一些题目只需要保留整数部分，那么也是可以用整数二分去求解的。

int mySqrt(int x) {
    int left = 0, right = x;
    while(left <= right){
        int mid = left + right >> 1;
        double p = 1.0 * mid * mid;
        if(p == x) return mid;
        else if(p < x) left = mid + 1;
        else right = mid - 1;
    }
    return right;
}

`大数运算`

注意大数在数组中的存储顺序：从低位存储到高位。

`大数加`

#include 
#include 
using namespace std;
vector<int> add(vector<int> &a, vector<int> &b){
    vector<int> res;int sum=0;
    for(int i=0;isize()||isize();i++){
        if(isize()) sum+=a[i];
        if(isize()) sum+=b[i];
        res.push_back(sum%10);
        sum/=10;
    }
    if(sum) res.push_back(1);
    return res;
}
int main(){
    string a,b; vector<int> A,B;
    cin>>a>>b;
    for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
    for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    auto res= add(A,B);
    for(int i=res.size()-1;i>=0;i--) cout<
    return 0;
}

`大数减`

#include 
#include 
using namespace std;
bool cmp(const vector<int> &a,const vector<int>&b){
    if(a.size()!=b.size()) return a.size()>b.size();
    else for(int i=a.size()-1;i>=0;i--) if(a[i]!=b[i]) return a[i]>b[i];
    return true;
}
vector<int> sub(vector<int> &a, vector<int>&b){
    vector<int> res;int sum=0;
    for(int i=0;isize();i++){
        sum+=a[i];
        if(isize()) sum-=b[i];
        res.push_back((sum+10)%10);
        if(sum<0) sum=-1;  //借位与否
        else sum=0;
    }
    while(res.size()>1 && res.back()==0) res.pop_back();  //去掉前导0
    return res;
}
int main(){
    string a,b;vector<int> A,B;
    cin>>a>>b;
    for(int i=a.size()-1;i>=0;i--) A.push_back(a[i]-'0');
    for(int i=b.size()-1;i>=0;i--) B.push_back(b[i]-'0');
    vector<int> res;
    if(cmp(A,B)) {res=sub(A,B); for(int i=res.size()-1;i>=0;i--) cout<
    else {res=sub(B,A); cout<<"-"; for(int i=res.size()-1;i>=0;i--) cout<
    return 0;
}

`大数乘`

vector<int> mul(vector<int> a,int b){
    vector<int> res;int sum=0;
    for(int i=0;isize() || sum;i++){
        sum+=a[i]*b;
        res.push_back(sum%10);
        sum/=10;
    }
    return res;
}

`大数除`

vector<int> div(vector<int> a,int b，int &c){  //c是余数
    vector<int> res; int sum=0;
    for(int i=a.size()-1;i>=0;i--){
        sum=sum*10+a[i];
        res.push_back(sum/b);
        sum%=b;
    }
  c=sum; reverse(res.begin(),res.end());
    while(res.size()>1 && res.back()== 0) res.pop_back();
    return res;
}

`哈希`

`整数哈希`

整数哈希的作用是将数据范围较大的值域转换到范围较小的值域空间。其中避免哈希冲突的方案有拉链法和开放地址法。

原数据大且稀疏，转到到小且稠密的空间上。

除了数据空间的映射之外，哈希还可能应用到一些在集合以$O(1)$时间复杂度去判断元素是否存在的场景。

`拉链法`

const int N=1e5+3;  // N一定要是素数且大于数据范围
int h[N],e[N],ne[N],idx; // 其中h是指针数组，e存储节点，ne存储指针
void init(){
  memset(h,-1,sizeof h);
  memset(ne,-1,sizeof ne);
}
void insert(int x){
  int k=(x%N+N)%N;
  e[idx]=x;ne[idx]=h[k];h[k]=idx++; // 这三句是头插法实现，如果用尾插法不要直接循环找末尾元素，可以增加一个尾指针。
}
bool find(int x){
  int k=(x%N+N)%N;
  for(int i=h[k];i!=-1;i=ne[i])
      if(e[i]==x) return true;
  return false;
}

N = 100003  # N 是素数且大于数据范围
h, e, ne, idx = [-1]*N, [0]*N, [-1]*N, 0     

def init():
    global h, ne, idx
    h = [-1] * N
    ne = [-1] * N
    idx = 0

def insert(x):
    global idx
    k = (x % N + N) % N  # 处理负数取模
    e[idx] = x
    ne[idx] = h[k]
    h[k] = idx
    idx += 1

def find(x):
    k = (x % N + N) % N  # 处理负数取模
    i = h[k]
    while i != -1:
        if e[i] == x:
            return True
        i = ne[i]
    return False

经典例题：1012.哈希表（链地址法处理冲突） - Problems | SWUST OJ

#include 
using namespace std;
typedef pair<int,int> PII;
int m,n,idx;
void insert(int h[],int e[],int ne[],int c){
    int k=(c%m+m)%m;
    int i=h[k];
    while(i!=-1 && ne[i]!=-1) i=ne[i];
    e[idx]=c;
    if(i==-1) {h[k]=idx++;}
    else {ne[i]=idx++;}
}
PII find(int h[],int e[],int ne[],int c){
    int k=(c%m+m)%m;int i=h[k];int sum=0;
    while(i!=-1){
        sum++;
        if(e[i]==c) return make_pair(k,sum);
        i=ne[i];
    }
    return make_pair(k,-1);
}
int main(){
    cin>>m>>n;
    int h[m],e[m],ne[m],num;
    memset(h,-1,sizeof h);
    memset(ne,-1,sizeof ne);
    for(int i=0;i
        cin>>num;
        insert(h,e,ne,num);
    }
    cin>>num;
    PII res=find(h,e,ne,num);
    if(res.second!=-1) cout<","<
    else cout<<"-1";
    return 0;
}

`开放地址法`

const int N=2e5+3;   //这个N需要是大于2到3倍数据范围的一个最小质数
const int INF=0x3f3f3f3f;  //约定改数表示位置无数据存储
int h[N];
void init(){
  memset(h,0x3f,sizeof h);
}

// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置。因此find的返回值还需要再进行一次if判断。
int find(int x){
  int k=(x%N+N)%N;
  while(h[k]!=INF && h[k]!=x){
      k++;
      if(k==N) k=0;
    }
  return k;
}

`最长连续序列`

也就是说是可以自己实现C++ STL容器unordered_set。

const static int maxn=2e5+3;
const int INF=0x3f3f3f3f;
int h[maxn];
void init(){
    memset(h,0x3f,sizeof h);
}
int find(int x){
    int k=(x%maxn+maxn)%maxn;
    while(h[k]!=INF && h[k]!=x){
        k++;
        if(k==maxn) k=0;
    }
    return k;
}
int longestConsecutive(vector<int>& nums) {
    init();
    for(auto item:nums){
        int idx=find(item);
        if(h[idx]==INF) h[idx]=item;
    }
    int res=0;
    for(auto item :nums){
        if(h[find(item-1)]==INF){
            int curnum=item;
            int curlen=1;
            while(h[find(curnum+1)]!=INF){curlen++;curnum++;}
            res=max(res,curlen);
        }
    }
    return res;
}

`字符串哈希`

核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

可以用来快速判断区间字符串是否一致。

字符串下标必须从1开始，可以更好地处理边界问题。

typedef unsigned long long ULL;  //用unsigned long long存储就避免了取模运算
const int N=1e5+10;
const int P=131; // P的经验值是131或13331
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化
void init(string str){  //这个字符串需保证下标从1开始
  p[0] = 1;
    for (int i = 1; i <= n; i ++ ){
        h[i] = h[i - 1] * P + str[i];
        p[i] = p[i - 1] * P;
    }
}

// 计算子串 str[l ~ r] 的哈希值
ULL strHash(int l, int r){
    return h[r] - h[l - 1] * p[r - l + 1];  // r-l+1是这两个位数之间差的值
}

`前缀和与差分`

前缀和的作用：能够快速求出原数组中一段的和。前缀和数组还有个最基本的性质，就是单调递增的。

差分的作用：可以用于处理区间修改和查询操作。通过对差分数组进行修改，可以在常数时间内更新原始序列的某个区间。这对于需要频繁修改某个区间的问题非常有用，如区间加法、区间减法等。

[!TIP]
数组下标必须从1开始，可以更好地处理边界问题。

`一维前缀和`

一维前缀和数组：sum[i] = sum[i - 1] + arr[i];

const int size=4;
int sum[size];
int main(){
    for (int i = 1; i <= size; i++)
        sum[i] = sum[i - 1] + arr[i];
    return 0;
}

`二维前缀和`

二维前缀和数组：sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + arr[i][j];

const int x_size = 4;
const int y_size = 4;
int sum[y_size][x_size];
int main(){
    for (int i = 1; i <= y_size; i++)
        for (int j = 1; j <= x_size; j++)
            sum[i][j] = sum[i][j - 1] + sum[i - 1][j] - sum[i - 1][j - 1] + arr[i][j];
    return 0;
}

`一维差分`

一维差分数组：dif[i] = arr[i] - arr[i - 1]

对差分数组进行前缀和运算可以获得原数组，但局限于多次操作单次(少次)还原

一维差分运算：

arr[L,R]+value

等价于

dif[L]+value,

dif[R+1]-value

const int size=4;
int dif[size];
int main(){
    for (int i = 1; i <= size; i++)
        dif[i] = arr[i] - arr[i - 1];
    return 0;
}

#include 
using namespace std;
const int N = 1e6+10;
int arr[N],dif[N];
void insert(int l,int r,int c){
    dif[l]+=c;
    dif[r+1]-=c;
}
int main(){
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>arr[i];
    for(int i=1;i<=n;i++) insert(i,i,arr[i]);  //这就是在初始化差分数组
    for(int i=0;i
        int l,r,c; cin>>l>>r>>c;
        insert(l,r,c);
    }
    for(int i=1;i<=n;i++) arr[i]=arr[i-1]+dif[i];
    for(int i=1;i<=n;i++) cout<" ";
    return 0;
}

`二维差分`

二维差分数组：dif[i][j]=arr[i][j]-arr[i-1][j]-arr[i][j-1]+arr[i-1][j-1]

二维差分运算：

arr[x1,x2][y1,y2]+value

等价于

dif[x1][y1]+value,

dif[x1+1][y1]-value,

dif[x1][y1+1]-value,

dif[x1+1][y1+1]+value

const int x_size = 4;
const int y_size = 4;
int dif[y_size][x_size];
int main(){
    for (int i = 1; i <= y_size; i++)
        for (int j = 1; j <= x_size; j++)
            dif[i][j] = arr[i][j] - arr[i][j - 1] - arr[i - 1][j] + arr[i - 1][j - 1];
    return 0;
}

#include 
using namespace std;
const int N=1e3+10;
int arr[N][N],diff[N][N];
void insert(int x1,int y1,int x2,int y2,int c){
    diff[x1][y1]+=c; diff[x1][y2+1]-=c; diff[x2+1][y1]-=c; diff[x2+1][y2+1]+=c;
}
int main(){
    int n,m,k;cin>>n>>m>>k;
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) cin>>arr[i][j];
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) insert(i,j,i,j,arr[i][j]);  //初始化dif数组
    for(int t=0;t
        int x1,y1,x2,y2,num; cin>>x1>>y1>>x2>>y2>>num; insert(x1,y1,x2,y2,num);
    }
    for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) arr[i][j]=arr[i-1][j]+arr[i][j-1]-arr[i-1][j-1]+diff[i][j];
    for(int i=1;i<=n;i++) {for(int j=1;j<=m;j++) cout<" "; cout<
    return 0;
}

`双指针`

双指针将$O(n^2)$的算法优化到$O(n)$ 。

双指针最重要的是找到某一种方案去更新两个指针。

双指针可以是从两端往中间靠（大部分情况），也可以是从中间往两端靠（eg. 最长回文子串），也可是同时从一边以不同速度走（大部分情况，eg. KMP算法、链表一趟遍历的删插操作），也可以是作用在不同的序列上（eg. 归并排序中的合并操作）。

`最长回文子串`

[!TIP]
首先确定回文串，找中心然后想两边扩散看是不是对称的就可以了。
一个元素可以作为中心点，两个元素也可以作为中心点。

int maxL=0,left=0,right=0;
void extend(const string& s,int i,int j,int n){
    while(i>=0 && j
        if(j-i+1>maxL){left=i,right=j,maxL=j-i+1;}
        i--;j++;
    }
}
string longestPalindrome(string s) {
    for(int i=0;isize();i++){
        extend(s,i,i,s.size());  //一个元素为中心点
        extend(s,i,i+1,s.size());  //两个元素为中心点
    }
    return s.substr(left,maxL);
}

`盛最多水的容器`

int maxArea(vector<int>& height) {
    int len = height.size();
    int i=0,j=len-1,maxA=0;
    while(i
        if((j-i)*min(height[i],height[j])>maxA)
            maxA=(j-i)*min(height[i],height[j]);
        if(height[i]>height[j]) j--; //移动短板
        else i++;
    }
    return maxA;
}

`三数之和`

vectorint>> threeSum(vector<int>& nums) {
    vectorint>> res;
    int len =nums.size();
    sort(nums.begin(),nums.end()); //进行排序是为了后面双指针进行双向更新提供条件
    for(int i=0;i
        if(i > 0 && nums[i] == nums[i-1]) continue; //防止遍历的i出现重复
        int l=i+1,r=len-1;
        while(l
            if(nums[l]+nums[r]==-nums[i]) {
                res.push_back({nums[i],nums[l++],nums[r]}); 
                while(nums[l-1]==nums[l] && l//防止双指针出现重复元素
            }
            else if (nums[l]+nums[r]>-nums[i]) r--;
            else l++;
        }
    }
    return res;
}

`位运算`

求n的2进制的第k位数字：n>>k & 1

提取一个整数 n 的二进制表示中最低位的 1 所代表的值：lowbit(n)=n & -n

`离散化`

离散化的本质是建立了一段数列到自然数之间的映射关系（value -> index)，通过建立新索引，来缩小目标区间，使得可以进行一系列连续数组可以进行的操作。eg：二分，前缀和等

[!caution]
离散化首先需要排序去重！

排序：sort(alls.begin(),alls.end()) 去重：alls.earse(unique(alls.begin(),alls.end()),alls.end())

vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素

// 二分求出x对应的离散化的值
int find(int x){ // 找到第一个大于等于x的位置
    int l = 0, r = alls.size() - 1;
    while (l < r){
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
}

`区间和`

#include 
using namespace std;
const int N = 3e5 + 10;
typedef pair<int, int> PII;
int n, m;
int arr[N], sum[N];
vector<int> odd;
vector add, query;

//value->key的映射函数(通过二分实现)
int find(int x) {
    int len = odd.size();
    int l = 1, r = len;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (odd[mid] >= x)
            r = mid;
        else
            l = mid + 1;
    }
    return l + 1;
}

int main() {
    cin >> n >> m;
    //读入数据，并将需要离散化的数据添加到odd中
    for (int i = 0; i < n; i++) {
        int x, c;
        cin >> x >> c;
        add.push_back(make_pair(x, c));
        odd.push_back(x);
    }
    for (int i = 0; i < n; i++) {
        int l, r;
        cin >> l >> r;
        query.push_back(make_pair(l, r));
        odd.push_back(l);
        odd.push_back(r);
    }
    //排序与去重，为了使用二分查找建立值到键的索引
    sort(odd.begin(), odd.end());
    odd.erase(unique(odd.begin(), odd.end()), odd.end());
  
  //将对原数的操作映射到对离散后数值的操作
    for (auto item : add) {
        int idx = find(item.first);
        arr[idx] += item.second;
    }
  //建立前缀和数组
    for (int i = 1; i <= odd.size(); i++) {
        sum[i] += sum[i - 1] + arr[i];
    }
   //利用前缀和求区间和
    for (int i = 0; i < m; i++) {
        int l = find(query[i].first), r = find(query[i].second);
        cout << sum[r] - sum[l - 1] << endl;
    }
    return 0;
}

`区间合并`

首先需要将所有的区间根据其左区间的值进行升序排序；然后遍历每一个区间进行合并；遍历期间需要维护一个用于合并的区间。

对于待合并的区间，只可能与维护的区间有三种可能性：

待合并区间完全包括在维护的区间中
无需更新维护区间
待合并区间与维护的区间有部分交集（且只可能是End端不在维护的区间中）
**将维护区间的End换成待合并区间的End**。
待合并区间与维护的区间完全无交集
当前维护的区间可以纳入答案中，将该待合并的区间作为新的维护区间。

typedef pair<int,int> PII;
void merge(vector &segs){ // 将所有存在交集的区间合并
    vector res;
    sort(segs.begin(), segs.end());  //默认以左区间进行排序
    int st = -2e9, ed = -2e9;  // 设置区间的边界
    for (auto seg : segs)
        if (ed < seg.first){  // 新的区间与维护的区间无交集
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second); 
    if (st != -2e9) res.push_back({st, ed});
    segs = res;
}

`KMP算法`

KMP算法用来解决子串与父串进行匹配的问题，可以将时间复杂度为$O(n^2)$的暴力匹配变成时间复杂度为$O(n+m)$。KMP算法的核心思想是利用已经匹配的信息来避免重复匹配，从而提高匹配效率。next数组记录了模式字符串中每个位置的前缀和后缀的最长公共部分的长度（最长相同前后缀or模式串匹配失败后应该重新开始匹配的位置）。

特别需要注意的是：主串和模板串都从第一个位置开始存储。

手算next数组

#include 
const int N=1e6+10,M=1e6+10;
char str1[N],str2[M];
int ne[M];
int n,m;
using namespace std;
void get_next(){  
    for(int i=2,j=0;i<=m;i++){ //从模式字符串的第二个字符开始遍历（因为部分匹配表的第一个值总是0）
        while(j && str2[i]!=str2[j+1]) j=ne[j]; //如果当前字符和前缀字符不匹配，并且j不为0，则回溯到前一个部分匹配的位置
        if(str2[i]==str2[j+1]) j++; //如果当前字符和前缀字符匹配，则j加1
        ne[i]=j;
    }
}
void kmp(){
    for(int i=1,j=0;i<=n;i++){
        while(j && str1[i]!=str2[j+1]) j=ne[j];
        if(str1[i]==str2[j+1]) j++;
        if(j==m){
            printf("%d ",i-m);
            j=ne[j];  //子串完全匹配后，下一个字符肯定不再相等，因此j需要重新回溯
        }
    }
}
int main(){
    cin>>n>>str1+1>>m>>str2+1;  //两个字符数组下标从1开始存储
    get_next();
    kmp();
    return 0;
}

`最短回文串`

理解KMP算法的关键一步是理解next数组的含义，即字符串中每个位置的最长相等前后缀的长度，这种特性能很好地与回文串结合。

将任意串baacbca翻转再拼接原串acbcaabbaacbca的next数组为00001100112345，很有意思的是next数组的最后一个值就是原串中存在的一个最长回文串[arr.end()-5+1,arr.end()]的长度。假若需要将原串在一个方向添加字符拼凑成新的回文串，则只需在原串的末尾拼凑上原串[arr.begin(),arr.begin()+arr.size()-5]的字符即可。

string shortestPalindrome(string s) {
    const static int maxn=1e5+10;
    int ne[maxn];
    string s1=" "+s+" "+string(s.rbegin(),s.rend());  //第一个空格是为了next数组计算，第二个空格是防止原串全为相同字符，导致回文串长度超过原串长度
    int len=s1.size();
    for(int j=0,i=2;i
        while(j && s1[i]!=s1[j+1]) j=ne[j];
        if(s1[i]==s1[j+1]) j++;
        ne[i]=j;
    }
    string s2=s.substr(0,ne[len-1]);
    string s3=s.substr(ne[len-1]);
    return string(s3.rbegin(),s3.rend())+s2+s3;
}

`重复的子字符串`

KMP算法在应用层面最重要的就是场景识别，即在具体问题中能够抽象出使用KMP算法的场景，即模式串匹配。

const static int maxn=2e4+10;
int ne[maxn];
void getnext(const string& s){
    int len=s.size();
    for(int j=0,i=2;i
        while(j && s[i]!=s[j+1]) j=ne[j];
        if(s[i]==s[j+1]) j++;
        ne[i]=j;
    }
}
bool repeatedSubstringPattern(string s) {
    string ss=s+s;
    int len = ss.size();
    s=" "+s;
    getnext(s);
    for(int j=0,i=1;i-1;i++){
        while(j && ss[i]!=s[j+1]) j=ne[j];
        if(ss[i]==s[j+1]) j++;
        if(j==s.size()-1) return true;
    }
    return false;
}

`基础数据结构`

`STL`

`vector`

`deque`

`stack`

`queue`

`priority_queue`

`list`

`集合系列`

`set`

底层结构：set底层是由红黑树实现（红黑树是一种平衡二叉树），存储空间不连续；
访问遍历：不支持随机访问迭代器，不能通过下标直接访问，支持按顺序迭代，迭代器遍历的顺序是从小到大的顺序；
操作效率：查询/插入/删除的效率都为$O(logn)$；
排序方式 : 默认使用less仿函数 , 即<运算符进行排序 ; 也可以自定义排序规则仿函数 ;
使用场景：需要集合有序且元素不重复的场景；

`multiset`

底层结构 : 底层由红黑树实现 , 红黑树是一种平衡二叉搜索树 , 存储空间不连续;
访问遍历 : 不支持随机访问迭代器 , 不能听过下标访问 , 支持按顺序迭代，迭代器遍历的顺序是从小到大的顺序；
操作效率：查询 / 插入 / 删除效率为 O(log n) 复杂度;
排序方式 : 默认使用less仿函数 , 即<运算符进行排序 ; 也可以自定义排序规则仿函数;
使用场景 : 需要集合有序且元素重复的场景;

`unordered_set`

底层结构 : 底层由哈希表实现 , 存储空间不连续;
访问遍历 : 不支持随机访问迭代器 , 不能听过下标访问;
操作效率：插入、删除和查找操作的平均时间复杂度为 O(1)，但在最坏情况下可能达到 O(n)；
使用场景 : 更适合频繁插入和查找操作且不关心元素顺序的场景；

`字典系列`

[!Tip]
字典容器与集合容器的区别是字典容器存储的是键值对元素 , 是 pair 对象；集合容器存储的是单纯的键单个元素 ;

`map`

底层结构 : 底层由红黑树实现 , 红黑树是一种平衡二叉搜索树 , 存储空间不连续 ; 存储的元素是键值对元素;
访问遍历 : 不支持随机访问迭代器 , 不能听过下标访问 , 只能通过迭代器进行访问;
操作效率：查询 / 插入 / 删除效率为 O(log n) 复杂度 ; 与 set 集合容器相同;
排序方式 : 默认使用less仿函数 , 即<运算符进行排序 ; 也可以自定义排序规则仿函数 ; map 映射容器不允许重复的键 , multimap 多重映射容器允许重复的键;
使用场景 : 需要有序键值对且元素不重复的场景;

`multimap`

底层结构: 底层由红黑树实现，红黑树是一种平衡二叉搜索树，存储空间不连续，存储的元素是键值对元素 ;
访问遍历: 不支持随机访问迭代器 , 不能听过下标访问 , 只能通过迭代器进行访问 ;
操作效率：查询 / 插入 / 删除效率为 O(log n) 复杂度 ; 与 set 集合容器相同 ;
排序方式：默认使用less仿函数 , 即<运算符进行排序 ; 也可以自定义排序规则仿函数 ; map 映射容器不允许重复的键 , multimap 多重映射容器允许重复的键;
使用场景: 需要有序键值对且元素重复的场景 ;

`unordered_map`

底层结构：set底层是由红黑树实现（红黑树是一种平衡二叉树），存储空间不连续，存储的元素是键值对元素 ;
操作效率：插入、删除和查找操作的平均时间复杂度为 O(1)，但在最坏情况下可能达到 O(n)；
使用场景 : 更适合频繁插入和查找操作且不关心元素顺序的场景；

`bitset`

`模拟链表`

`单链表`

const int N =1e6+10;
int head,idx; // head是链表的头结点，idx是当前链表指针
int e[N],ne[N]; // e静态链表数组，ne是链表指针数组。即e数组存储节点的值，而ne存储节点的next指针
void init(){
  head=-1; idx=0;
}
void add2head(int c){
  e[idx]=c;
  ne[idx]=head; 
  head=idx++;
}
void add(int k,int c){
  e[idx]=c;
  ne[idx]=ne[k];
  ne[k]=idx++;
}
void earse(int k){
  ne[k]=ne[ne[k]];
}

`双链表`

const int N=100010;
int e[N],l[N],r[N],idx;

//初始化
void init(){
    l[1]=0;r[0]=1;idx=2;
}

//在节点a的右边插入一个数x
void insert(int a,int x){
    e[idx]=x;
    l[idx]=a,r[idx]=r[a];
    l[r[a]]=idx,r[a]=idx++;
} 

//删除节点a
void remove(int a){
    l[r[a]]=l[a];
 
}

`邻接表`

int h[N], e[N], ne[N], idx;
void init(){
    idx = 0;
  memset(h, -1, sizeof h);
}
// 添加一条边a->b
void add(int a, int b){
    e[idx]=b;ne[idx]=h[a];h[a]=idx++;
}

`模拟栈`

const int N=1e6+10;
int stk[N],tt;
//push
stk[++tt]=x;
//pop
tt--;
//judge empty
if(tt>0) not empty
else empty
//top of stack
stk[tt];

`模拟队列`

const int N=1e6+10;
int que[N],hh,tt=-1;  //hh是队头，tt是队尾
//push
que[++tt]=x;
//pop
hh++;
//judge empty
if(hh<=tt) not empty
else empty
//front of queue
que[hh];

如果要实现循环队列，只需要每次在插入值时对tt进行判断，如果其等于N就将其赋值为0。或者直接que[++tt%N]=x;，当然这样就要注意操作次数，防止整数溢出。

const int N = 1e6 + 10;
int que[N], hh = 0, tt = 0;  // hh是队头，tt是队尾
bool isEmpty() {
  return hh == tt;
}
bool isFull() {
    return (tt + 1) % N == hh;
}
void push(int x) {
    que[tt] = x;
    tt = (tt + 1) % N;  // 更新队尾，使用取模实现循环
}
void pop() {
    hh = (hh + 1) % N;  // 更新队头，使用取模实现循环
}
int front() {
    return que[hh];
}

`单调栈`

[!Caution]
常见题型：找出区间每个数左边（右边）离它最近的比它大/小的数，特别是“最近”两字！
单调增栈求更大，单调减栈求更小
OJ例题：P5788 【模板】单调栈 - 洛谷

const int N=1e6+10;
int stk[N],tt = 0;
for (int i = 1; i <= n; i ++ )  //左边
{
    while (tt && check(stk[tt], i)) tt--;  // 单调栈就是始终需要维护一个单调的栈
  if(tt) find the value stk[tt];
  else not find;
    stk[++tt] = i;
}
for (int i = n-1; i >= 0; i -- )  //右边
{
    while (tt && check(stk[tt], i)) tt--;  // 单调栈就是始终需要维护一个单调的栈
  if(tt) find the value stk[tt];
  else not find;
    stk[++tt] = i;
}

pre.push_back(INT_MAX);  //这一步相当关键，这里push的值需要根据单调增还是减栈确定，增站用max，减栈用min
for (int i = 0; i <= len; i++) { //左右两边
    while (tt && pre[stk[tt]] <= pre[i]) { // 单调增栈
        int idx = stk[tt--];
        res1[idx] = (tt == 0 ? -1 : stk[tt]);  //左端
        res2[idx] = (i == len ? -1 : i);  //右端
    }
    stk[++tt] = i;
}

`接雨水`

const static int N = 2e4 + 10;
int stk[N], tt = 0;
int trap(vector<int> &height) {
    int res1[N], res2[N];
    int len = height.size();
    height.push_back(INT_MAX);
    for (int i = 0; i <= len; i++) {
        while (tt && height[stk[tt]] < height[i]) { // 单调增栈
            int idx = stk[tt--];
            res1[idx] = (tt == 0 ? -1 : stk[tt]);
            res2[idx] = (i == len ? -1 : i);
        }
        stk[++tt] = i;
    }
    int sum = 0;
    for (int i = 0; i < len; i++)
        if (res1[i] != -1 && res2[i] != -1)
        sum += (min(height[res1[i]], height[res2[i]]) - height[i])*(res2[i]-res1[i]-1);
    return sum;
}

[!WARNING]
这个LeetCode的题“接雨水 ”，看似可以利用左右两边比其大而形成蓄水部位的特性利用单调栈解题，但是忽略了“最近”这个局部的概念而导致很难正确求解。
补：利用这个局部也是能正确求解的，使用分层的思想。
height = [0,1,0,4,1,0,1,3,2,1,2,1]
假如把左/右没有比起更大的值记为-1，那么每个元素其左边最近更大的下标序列为：
-1 -1 1 -1 3 4 3 3 7 8 7 10
其右边最近更大的下标序列为：
1 3 3 -1 7 6 7 -1 -1 10 -1 -1
将左右两边序列结合观察，只有在2,4,5,6,9这几个位置蓄水（对应位置均不为-1）。第5个位置就暴露出“最近”这个局部概念的问题，其得到的左右两边更大的，能够形成的局部蓄水高度并不是其全局蓄水高度。
因此，想要从这直接计算每个位置的最大蓄水高度显然是不行的。但也很好解决，只要确定每个可蓄水位的最大蓄水高度就能够完成最终求解。
左侧最大蓄水高度：[0,1,1,4,4,4,4,4,4,4,4,4]
右侧最大蓄水高度：[4,4,4,4,3,3,3,3,2,2,2,1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
const static int N = 2e4+10;
int stk[N],tt=0;
int trap(vector<int>& height) {
    int lmax[N],rmax[N];
    vector<int> res1,res2;
    int len=height.size();
    lmax[0]=height[0],rmax[len-1]=height[len-1];
  
    for(int i=1;imax(lmax[i-1],height[i]); 
    for(int i=len-2;i>=0;i--) rmax[i]=max(rmax[i+1],height[i]); 
  
    for(int i=len-1;i>=0;i--){ //需要找右边离他最近且比他大or相等的元素
        while(tt && height[stk[tt]]<=height[i]) tt--;
        if(tt) res1.push_back(stk[tt]);
        else res1.push_back(-1);
        stk[++tt]=i;
    }
    tt=0;
    for(int i=0;i
        while(tt && height[stk[tt]]<=height[i]) tt--;
        if(tt) res2.push_back(stk[tt]);
        else res2.push_back(-1);
        stk[++tt]=i;
    }
    reverse(res1.begin(),res1.end());
    int sum=0;
    for(int i=0;i
        if(res1[i]!=-1 && res2[i]!=-1)
            sum+=min(rmax[res1[i]],lmax[res2[i]])-height[i];
    return sum;
}
上面的方法从左到右和从右到左用了两次单调栈来寻找左边和右边的更大元素。其实这是没必要的，可以只用一趟就能够同时完成寻找作用两边更大的元素。
模板还是一样，但思路有点不同。在两次单调栈中，我们每次都是将外循环for遍历到的元素当成基准元素来找寻离当前基准元素左/右边更大的元素。但是在一次单调栈中，当前遍历到的元素不在基准元素，反而是左/右边更大的元素。
我们假设外层的for循环是从左到右，且栈是单调增栈。当外循环遍历到元素i时，此时i为右边界，从内循环while出来后的栈顶元素为基准，下一个栈顶元素为左边界。此时寻找到左边界和右边界都是比基准元素更小且最近的值。
因此，上面的代码可以进一步优化为：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const static int N = 2e4 + 10;
int stk[N], tt = 0;
int trap(vector<int> &height) {
    int lmax[N], rmax[N];
    int res1[N], res2[N];
    int len = height.size();
    lmax[0] = height[0], rmax[len - 1] = height[len - 1];
    for (int i = 1; i < len; i++) lmax[i] = max(lmax[i - 1], height[i]);
    for (int i = len - 2; i >= 0; i--) rmax[i] = max(rmax[i + 1], height[i]);
    height.push_back(INT_MAX);  //这一步相当关键
    for (int i = 0; i <= len; i++) {
        while (tt && height[stk[tt]] <= height[i]) { // 单调增栈
            int idx = stk[tt--];
            res1[idx] = (tt == 0 ? -1 : stk[tt]);
            res2[idx] = (i == len ? -1 : i);
        }
        stk[++tt] = i;
    }
    int sum = 0;
    for (int i = 0; i < len; i++)
        if (res1[i] != -1 && res2[i] != -1)
        sum += min(lmax[res1[i]], rmax[res2[i]]) - height[i];
    return sum;
}
当然，尽管优化成一轮遍历，但其实如果按照这个思路求解，前面的找可蓄水位其实就是没必要的操作了！
因此我们尝试不去计算每个位置左右的最大蓄水高度，只用已求解的局部需水量进行分层计算。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const static int N = 2e4 + 10;
int stk[N], tt = 0;
int trap(vector<int> &height) {
    int res1[N], res2[N];
    int len = height.size();
    height.push_back(INT_MAX);
    for (int i = 0; i <= len; i++) {
        while (tt && height[stk[tt]] < height[i]) { // 单调增栈
            int idx = stk[tt--];
            res1[idx] = (tt == 0 ? -1 : stk[tt]);
            res2[idx] = (i == len ? -1 : i);
        }
        stk[++tt] = i;
    }
    int sum = 0;
    for (int i = 0; i < len; i++)
        if (res1[i] != -1 && res2[i] != -1)
        sum += (min(height[res1[i]], height[res2[i]]) - height[i])*(res2[i]-res1[i]-1);
    return sum;
}
类似的还有LeetCode柱状图中最大的矩形，这里构建的就是一个单调递减栈。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int largestRectangleArea(vector<int>& heights) {
    const int N=1e5+10;
    int stk[N],tt=0;
    int len = heights.size();
    int maxSize=0;
    heights.push_back(INT_MIN);  //单调递减栈，插INT_MIN；递增栈，插INT_MAX
    for(int i=0;i<=len;i++){
        while(tt && heights[stk[tt]]>=heights[i]) {  //最近更小，单调减栈，遍历元素需更小；最近更大，单调递增栈，遍历元素需更大
            int idx=stk[tt--];
            int left = (tt==0 ? -1 : stk[tt]);  //一般左边界都需要特判，右边界视题而定
            maxSize=max(maxSize,(i-left-1)*heights[idx]);
        }
        stk[++tt]=i;
    }
    return maxSize;
}
假如我们不使用单调栈，则可以想到使用双指针的算法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int trap(vector<int> &height) {
    int len = height.size();
    int l=0,r=len-1,maxl=0,maxr=0;
    int res=0;
    while(l<=r){
        int wal=min(maxl,maxr);
        if(height[l]<=wal){
            res+=wal-height[l++];
            continue;
        }
        if(height[r]<=wal){
            res+=wal-height[r--];
            continue;
        }
        maxl=max(maxl,height[l]);
        maxr=max(maxr,height[r]);
    }
    return res;
}

`单调队列`

常见题型：求滑动窗口（窗口大小固定）中的最值，求单调队列中的任意值也可用二分。

单调队列中存储的都是Index，而不是Value。

OJ例题：滑动窗口、滑动窗口最大值、和至少为 K 的最短子数组

const int N=1e6+10;
int n,k;  // n是数的个数，k是区间长度
int arr[N],que[N];  // arr用来存储数，que是单调队列，其中存储区间元素的下标
for(int i=0;i
    if(hh<=tt && i-que[hh]+1>k) hh++;  // 如果队列超过区间长度
    while(hh<=tt && arr[que[tt]]>=arr[i]) tt--; // 维护单调队列，如果当前元素要小于单调队列的队尾元素，则队尾元素弹出，确保队列单调递增，队头能够取到最小值。
    que[++tt]=i; // 将当前元素插入
    if(i>=k-1) printf("%d ", arr[que[hh]]);  //当窗口全部滑入数组上后判定
}

`和至少为 K 的最短子数组`

这个题目很好的将单调队列和前缀和融合在一起！

这个题目必须用前缀和的原因有两点：

1、前缀和在计算区间和时只需O(1)的代价

2、不用前缀和不能满足题目所要求的连续区间。因为在获取单调队列时，必然会导致队列中的元素不再连续（虽然相对位置关系依旧保留）。只有使用前缀和，其中的每一个值代表一个区间的和，才在以离散的状态构建单调队列的同时保持连续区间的要求（两个前缀和数组的值作差能表示一个区间的和）。

typedef long long ll;
const static int N =1e5+10;
int shortestSubarray(vector<int>& nums, int k) {
    int len=nums.size();
    ll sum[N];
    for(int i=1;i<=len;i++) sum[i]=sum[i-1]+nums[i-1];
    ll que[N],hh=0,tt=-1;
    ll minL=INT_MAX;
    for(int i=0;i<=len;i++){ //前缀和得从0开始！
        while(hh<=tt && sum[i]-sum[que[hh]]>=k) minL=min(minL,i-que[hh++]);
        while(hh<=tt && sum[que[tt]]>=sum[i]) tt--;
        que[++tt]=i;
    }
    return minL == INT_MAX ? -1 : minL;
}

`环形子数组的最大和`

环形问题拉直处理。依旧是前缀和+单调队列。

限制是区间长度不大于数组长度。

当然其实拉直处理，可以用模运算实现，而不是真实地再复制数组一遍。

const static int N = 6e4+10;
int maxSubarraySumCircular(vector<int>& nums) {
    int k = nums.size(),len=k*2;
    nums.insert(nums.end(),nums.begin(),nums.end());
    vector<int> sum(len+1);
    for(int i=1;i<=len;i++)sum[i]=sum[i-1]+nums[i-1];
    int maxV=INT_MIN;
    int que[N],hh=0,tt=-1;
    memset(que,0,sizeof que);
    for(int i=0;i<=len;i++){
        if(hh<=tt && i-que[hh]>k) hh++;
        while(hh<=tt && sum[que[tt]] > sum[i]) tt--;
        if(i>k-1) maxV=max(maxV,sum[i]-sum[que[hh]]);
        que[++tt]=i;
    }
    return maxV;
}

`堆`

堆是一棵完全二叉树，使用数组从1进行存储。堆可以动态的维护一个区间内的最小值/最大值。

向堆中插入一个数：heap[++size]=x;up(size);

求堆中最小值：heap[1];

删除堆中的最小值：swap(heap[1],heap[size]);size--;down(1);

删除堆中任意一个元素：swap(heap[k],heap[size]);size--;down(k);up(k);

修改任意一个元素：heap[k]=c;down(k);up(k);

堆的数组存储是从下标1开始的。

const int N=1e5+10;
int h[N],n,size;
void down(int x){
  int tmp=x;
  if(x*2<=size && h[x*2]2;
  if(x*2+1<=size && h[x*2+1]2+1;
  if(tmp!=x) {
      swap(h[tmp],h[x]);
      down(tmp);
    }
}
void up(int x){
  while(x/2 && h[x]2]) {swap(h[x],h[x/2]);x>>=1;}  //小根堆
}
void build(){  //建堆，时间复杂度为O(n)
  for(int i=n/2;i>0;i--) down(i); 
}
void push(int c){
  h[++size]=c;
  up(size);
}
void pop(){
  swap(h[1],h[size]);
  size--;
  down(1);
}
void pop_k(int k){
  swap(h[k],h[size]);
  size--;
  down(k);up(k);
}
void revise(int k,int c){
  h[k]=c;
  down(k);up(k);
}

`P3378 【模板】堆 - 洛谷`

#include 
using namespace std;
const int N=1e6+10;
int h[N],n,size;
void down(int k){
    int tmp=k;
    if(k*2<=size && h[tmp]>h[k*2]) tmp=k*2;
    if(k*2+1<=size && h[tmp]>h[k*2+1]) tmp=k*2+1;
    if(tmp != k) {swap(h[tmp],h[k]);down(tmp);}
}
void up(int k){
    while(k/2 && h[k/2]>h[k]) {swap(h[k],h[k/2]);k>>=1;}
}
void push(int x){
    h[++size]=x;
    up(size);
}
void pop(){
    swap(h[1],h[size]);
    size--;
    down(1);
}
int main(){
    scanf("%d",&n);
    int c,op;
    for(int i=0;i
        scanf("%d",&c);
        if(c==1){
            scanf("%d",&op);
            push(op);
        }else if(c==2){
            printf("%d\n",h[1]);
        }else{
            pop();
        }
    }
    return 0;
}

`Tire树`

Tire树是一种用来快速存储字符串集合，统计和排序大量的字符串前缀来减少查询时间，最大限度地减少无谓的字符串比较的数据结构。其特点是字符类别不多（一般就是小写字母、大写字母以及数字），即一般宽度上限为62=26+26+10，而深度上限是字符串的长度。

Trie树是一种多叉树的结构，每个节点保存一个字符，一条路径表示一个字符串。

#include 
const int N=1e6+10;
int son[N][26],cnt[N],idx;  //son是从0开始存储，而cnt是从1开始存储

//这个insert是求完全匹配的字符串数
void insert(char str[]){  
  int p=0;
  for(int i=0;str[i];i++){
      int u=str[i]-'a';
      if(!son[p][u]) son[p][u]=++idx; //son数组中存储的是idx
      p=son[p][u];
    }
  cnt[p]++;
}

//这个insert是求前缀匹配的字符串数
void insert(char str[]){  
  int p=0;
  for(int i=0;str[i];i++){
      int u=str[i]-'a';
      if(!son[p][u]) son[p][u]=++idx;
      p=son[p][u];
      cnt[p]++;
    }
}

//这个query是求完全匹配的字符串数
int query(char str[]){
  int p=0;
  for(int i=0;str[i];i++){
      int u=str[i]-'a';
      if(!son[p][u]) return 0;
      p=son[p][u];
    }
  return cnt[p];
}

//这个是求最长公共前缀
int cur=idx;
for(int i=cur;i>0;i--) if(cnt[i]>cnt[cur]) cur=i;
if(cnt[1]==len) cout<0].substr(0,cur);
else cout<< "";

`P8306 【模板】字典树 - 洛谷`

#include 
using namespace std;
const int N=3e6+10;
int son[N][65],cnt[N],idx;
char str[N];
int t,n,q;
void insert(char str[]){
    int p=0, u=0;
    for(int i=0;str[i];i++){
        if(str[i]<='9') u=str[i]-'0';
        else if(str[i]<='Z') u=str[i]-'A'+11;
        else u=str[i]-'a'+37;
        if(!son[p][u]) son[p][u]=++idx;
        cnt[son[p][u]]++;
        p=son[p][u];
    }
}
int query(char str[]){
    int p=0,u=0,sum=0;
    for(int i=0;str[i];i++){
        if(str[i]<='9') u=str[i]-'0';
        else if(str[i]<='Z') u=str[i]-'A'+11;
        else u=str[i]-'a'+37;
        if(!son[p][u]) return 0;
        p=son[p][u];
    }
    return cnt[p];
}
int main(){
    scanf("%d",&t);
    for(int j=0;j
        scanf("%d%d",&n,&q);
        for(int i=0;iscanf("%s",str);insert(str);}
        for(int i=0;i
            scanf("%s",str);
            printf("%d\n",query(str));
        }
        memset(son,0,sizeof son);
        memset(cnt,0,sizeof cnt);
        idx=0;
    }
    return 0;
}

`并查集`

并查集是一种用于处理集合合并与查询问题的数据结构。并查集通常用于解决一些与集合划分和连接相关的问题，例如：

连通性问题：判断两个元素是否属于同一个连通分量。
图的最小生成树：在构建最小生成树时，可以使用并查集来判断是否形成了环路，从而避免将边加入最小生成树中。
元素的分类和分组：将元素划分为不相交的组或分类，以便进行高效的组内操作。

并查集的p数组下标从0开始还是从1开始是根据节点编号从0开始还是从1开始确定的。

const int N=1e6+10;
int p[N],n;
void init(){
  for(int i=1;i<=n;i++) p[i]=i;
}
int find(int x){
  if(p[x]!=x) p[x]=find(p[x]);
  return p[x];
}
void join(int x,int y){
  p[find(x)]=find(y);
}

如果需要维护集合大小，需要重新开辟一个以每个节点为根树大小的数组

const int N=1e5+10;
int p[N],size[N],n;
void init(){
  for(int i=1;i<=n;i++){p[i]=i;size[i]=1;}
}
int find(int x){ 
  if(p[x]!=x) p[x]=find(p[x]);
  return p[x];
}
void join(int x,int y){
  if(find(x)!=find(y)) size[find(y)]+=size[find(x)];
  p[find(x)]=find(y);
}

`P3367 【模板】并查集 - 洛谷`

#include 
using namespace std;
const int N=1e4+10;
int p[N],n,m;
void init(){
    for(int i=1;i<=n;i++) p[i]=i;
}
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
void join(int x,int y){
    p[find(x)]=find(y);
}
int main(){
    scanf("%d%d",&n,&m);
    init();
    int c,x,y;
    for(int i=0;i
        scanf("%d%d%d",&c,&x,&y);
        if(c==1) join(x,y);
        else find(x)==find(y)?printf("%s\n","Y"):printf("%s\n","N");
    }
    return 0;
}

`树&图`

`遍历`

`树的深度优先遍历`

[!Note]
树的遍历有先根遍历和后根遍历，其中二叉树还有中根遍历，森林的遍历可以基于树的遍历，有先序遍历和中序遍历。
树的先根遍历序列和其对应的二叉树（左孩子右兄弟存储）的先根遍历序列一致，树的后根遍历序列和其对应的二叉树的中根遍历序列一致。
森林的先序遍历序列等价于每棵树按序先根遍历的序列，此外还可以将森林使用左孩子右兄弟表示法转化成二叉树再进行先序遍历。
森林的中序遍历序列等价于每棵树按序后根遍历的序列，此外还可以将森林使用左孩子右兄弟表示法转化成二叉树再进行中序遍历。

void preorder(TreeNode *root, vector<int> &res) {
    if (root == nullptr) return;
    res.push_back(root->val);
    preorder(root->left, res);
    preorder(root->right, res);
}

void midorder(TreeNode *root, vector<int> &res) {
    if (root == nullptr) return;
    preorder(root->left, res);
    res.push_back(root->val);
    preorder(root->right, res);
}

void postorder(TreeNode *root, vector<int> &res) {
    if (root == nullptr) return;
    preorder(root->left, res);
    preorder(root->right, res);
  res.push_back(root->val);
}

vector<int> preorderTraversal(TreeNode *root) {
    vector<int> res;
    preorder(root, res);
    return res;
}

`树的宽度优先遍历`

[!Note]
树的宽度优先遍历的实现逻辑和其二叉树的宽度优先遍历实现逻辑是一致的。

`深度优先搜索`

[!Note]
在搞懂DFS前，需要明白DFS是基于递归的，只有很好的理解递归，才能将DFS用到炉火纯青！
递归最终要的就是两个点：递归出口和递归点
递归出口即是什么时候截止。
假如遍历一颗BST，需要找到值为5的节点。那么递归出口就有两种情况：当递归到叶节点时终止和当递归找到值为5的节点终止。
递归点即需要找到当前问题如何转换成其子问题。
还是上面那个问题，需要找到值为5的节点。对于当前节点来说，找到值为5的节点有三种可能：当前节点本身值为5，值为5的节点在左子树中，值为5的节点在右子树中。因此问题就向其子空间（子问题）进行了转换，这就是递归点。
OJ例题：深度优先搜索知识点题库
如上面这道OJ例题，判断二叉树是否对称。
其递归出口就有四种情况：左右子树同时递归到叶子结点、左子树递归到叶子结点但右子树没有、右子树递归到叶子结点但左子树没有、左右子树都未递归到叶子结点，但当前存储的值不同。
递归点就是：左子树的左孩子与右子树的右孩子对称、左子树的右孩子与右子树的左孩子对称。
1
2
3
4
5
6
7
8
public boolean isSymmetric(TreeNode root) {
    return isSame(root.left, root.right);
}
private boolean isSame(TreeNode p, TreeNode q) {
    if (p == null && q == null) return  true;
    if ((p == null || q == null) || p.val != q.val) return false;
    return isSame(p.left, q.right) && isSame(p.right, q.left);
}

时间复杂度O(n+m)，n表示点数，m表示边数

深搜的关键在于本状态和下一状态的衔接以及递归出口的设置。

深搜在网格题目中备受关注！

int dfs(int u){
  if(u==n) return; //递归出口
    st[u] = true; //状态记录
    for (int i = h[u]; i != -1; i = ne[i]){
        if (!st[e[i]]) dfs(j); //进入dfs前有条件限制，则进行了剪枝
    }
  st[u] = false; //状态恢复
}

`B3621 枚举元组 - 洛谷`

#include 
using namespace std;
const int N=6;
int n,k,res[N];
void dfs(int t){
    if(t==n) {for(int i=0;i" ";cout<return;}
    for(int i=1;i<=k;i++){
        res[t]=i;
        dfs(t+1);  //这道题就没有涉及到状态恢复
    }
}
int main(){
    scanf("%d%d",&n,&k);
    dfs(0);
    return 0;
}

`P10448 组合型枚举 - 洛谷`

#include 
using namespace std;
const int N=26;
int n,k,res[N];
void dfs(int t){
    if(t==n+1) {for(int i=1;i<=n;i++) cout<" ";cout<return;}
    for(int i=1;i<=k;i++){
        if(i>res[t-1]){ // 确保递增顺序
            res[t]=i;
            dfs(t+1); 
        }
    }
}
int main(){
    scanf("%d%d",&k,&n);
    dfs(1);
    return 0;
}

[!IMPORTANT]
DFS往往有很多变种，无返回值的DFS，带返回值的DFS，无需状态记录的DFS和带状态记录的DFS等。其中，有无返回值和有无状态记录两者并不是冲突对立的。一个DFS的题目可能是无返回值需要状态记录的，也有可能是带返回值无状态记录的。
无返回值DFS模板：
1
2
3
4
void dfs(['search space',] 'current state parameters'){
  if('reach of terminal state') return;
  dfs('next state parameters');
}
OJ例题：岛屿数量
带返回值DFS模板：
1
2
3
4
int dfs(['search space',] 'current state parameters'){
  if('reach of terminal state') return value;
  return dfs('next state parameters')+1;
}
OJ例题：岛屿的最大面积

`岛屿数量`

const static int maxn=1e3+10;
bool sta[maxn][maxn];
int n,m;
void dfs(vectorchar>>& grid,int x,int y){
    if(x<0 || x>=n || y<0 || y>=m || sta[x][y] || grid[x][y]=='0') return;
    sta[x][y]=true;
    dfs(grid,x+1,y);
    dfs(grid,x-1,y);
    dfs(grid,x,y+1);
    dfs(grid,x,y-1);
}
int numIslands(vectorchar>>& grid) {
    n=grid.size(),m=grid[0].size();
    int res=0;
    for(int i=0;i
        for(int j=0;j
            if(grid[i][j]=='1'&& !sta[i][j]) {res++;dfs(grid,i,j);}
    return res;
}

`岛屿的最大面积`

const static int maxn=60;
bool sta[maxn][maxn];
int n,m;
int dfs(vectorint>>& grid,int x,int y){
    if(x<0 || x>=n || y<0 || y>=m || sta[x][y] || grid[x][y]==0) return 0;
    sta[x][y]=true; 
    return dfs(grid,x+1,y)+dfs(grid,x-1,y)+dfs(grid,x,y+1)+dfs(grid,x,y-1)+1;
}
int maxAreaOfIsland(vectorint>>& grid) {
    n=grid.size(),m=grid[0].size();
    int res=0;
    for(int i=0;i
        for(int j=0;j
            if(grid[i][j]==1 && !sta[i][j])
                res=max(res,dfs(grid,i,j));
    return res;   
}

[!Tip]
对于DFS搜索空间是网格的情况，往往需要遍历其上下左右四个访问，因此可以创建两个偏量数组dx和dy，通过for循环进行简便表示。

int dx={0,0,1,-1};
int dy={1,-1,0,0};
//void dfs
for(int i=0;i<4;i++){
  dfs(['search space',] x+dx[i],y+dy[i]);
}

//int dfs
int ans=1;
for(int i=0;i<4;i++){
  ans+=dfs(['search space',] x+dx[i],y+dy[i]);
}

`宽度优先搜索`

宽搜本身具备最短路的性质，当边权一致时，可以用来求最短路径。

const int N=1e5+10;
int st[N];
void bfs(){
  queue<int> q;
  st[1]=true;
  q.push(1);
  while(!q.empty()){
      int tmp=q.front();
      q.pop();
      for(int i=h[i];i!=-1;i=ne[i]){
          int node=e[i];
          if(!st[node]){
              st[node]=true;
              q.push(node);
            }
        }
    }
}

`除法求值`

这个题目很好的利用了宽度优先搜索的最短路特性！多个视角（并查集 | Floyd | DFS | BFS）看这道题。

[!Note]
顺便借着这个题目梳理一下图相关题目的做法。
首先，最重要的是能够识别出这题可以用图做。其实也很好判断，图最重要的就是结点与结点之间的关联，若题目能抽象出结点和结点之间的关联，且题目求解的答案也需要利用到结点之间的关系，那么这道题很大程度上就要用图解题。
那么下一步就要思考，答案的求解需要涉及到什么知识。基于图遍历的求解？最短路问题？最小生成树问题？拓扑排序问题？还是二分图问题？这一步就是问题建模的过程，因此相当关键。这需要我们对这些问题所涉及的模板特别熟悉，且能灵活的改动。
确定大体的解题思路之后，就要落足于题目实际。图需要用哪种结构进行存储？邻接矩阵、邻接表、还是结构体数组？这需要根据上一步确定的方法，以及题目数据规模共同敲定。是否需要用到额外的辅助数据结构？堆、队列、集合、哈希表？
最后就是编码的细节。是否需要状态记录？DFS的递归出口，返回值是否正确？数组下标从1开始还是从0开始？

const static int maxn= 30;
double g[maxn][maxn];
bool st[maxn];
unordered_map int> node;
int idx=0;
void init(){
    memset(st,0,sizeof st);
}
double dfs(int x,int y){  //这里用dfs是不合题意的，因为不是最短构造
    if(x==y) return 1;
    st[x]=true;
    for(int i=0;i
        if(g[x][i] && !st[i]) return dfs(i, y) * g[x][i];
    return -1.0;
}
double bfs(int x, int y) {
    double tmp[maxn];
    for (int i = 0; i < idx; i++) tmp[i] = 1;
    queue<int> q;
    q.push(x);
    st[x] = true;
    while (!q.empty()) {
        int top = q.front();
        q.pop();
        for (int i = 0; i < idx; i++)
            if (!st[i] && g[top][i]) {
                tmp[i] *= tmp[top] * g[top][i];
                st[i] = true;
                q.push(i);
            }
        if (top == y) return tmp[top];
    }
    return -1.0;
}
vector<double> calcEquation(vector>& equations, vector<double>& values, vector>& queries) {  //这个题是很明显的需要用邻接矩阵去存储的
    int len=equations.size();
    for(int i=0;i
        if(!node.count(equations[i][0])) {node.insert({equations[i][0],idx++});}
        if(!node.count(equations[i][1])) {node.insert({equations[i][1],idx++});}
        g[node[equations[i][0]]][node[equations[i][1]]] = values[i];
        g[node[equations[i][1]]][node[equations[i][0]]]=1/values[i];
    }
    vector<double> res;
    for(auto item:queries)
        if(node.count(item[0]) && node.count(item[1])){
            init();
            res.push_back(bfs(node[item[0]],node[item[1]]));
        }else res.push_back(-1.0);
    return res;
}

`拓扑排序`

有向图 | 宽度优先搜索的一种应用

const int N=1e5+10;
int dim[N],q[N],tp[N],n;
bool topsort(){
  int hh=0,tt=-1,idx=0; // 初始空队列
  for(int i=1;i<=n;i++) if(!dim[i]) q[++tt]=i; // 将入度为0的元素放入队列中
  while(hh<=tt){ // 队不空
      int tmp=q[hh++];  // 取出队头元素
      tp[idx++]=tmp; // 其实这里也没必要额外开一个tp存储，q中存储的就是拓扑序
      for(int i=h[tmp];i!=-1;i=ne[i])  // 遍历队头元素的出边
          if(--d[e[i]]==0) q[++tt]=e[i]; 
    }
  return tt==n-1;
}

`最短路`

`Dijkstra算法`

`朴素Dijkstra`

基于邻接矩阵存储的算法。

时间复杂度是$O(n^2)$，仅支持求正权边的最短路径。算法时间复杂度与边数无关，适用于稠密图。

算法的基本思想是通过逐步扩展已确定最短路径的顶点集合，从源点开始逐步确定源点到其他顶点的最短路径。Dijkstra算法使用了贪心策略，每次选择当前距离源点最近的顶点进行扩展，直到所有顶点都被扩展。

初始化：将源点的最短路径距离设置为0，其他顶点的最短路径距离设置为正无穷大（或一个足够大的值）。
选择最短路径顶点：从尚未确定最短路径的顶点中选择一个距离源点最近的顶点，将其标记为已确定最短路径。
更新最短路径距离：对于选择的顶点，遍历其所有邻接顶点，如果通过该顶点可以获得更短的路径，则更新邻接顶点的最短路径距离为源点经过选择顶点到该邻接顶点的距离。
重复进行步骤2和步骤3，直到所有顶点都被确定最短路径。

最短路径获取：通过记录每个顶点的前驱节点，可以从目标顶点逆向获取最短路径。

const int N=1e3+10;
int g[N][N],dist[N];
bool st[N]; // g存储每条边的权重，dist存储1号点到其他点的距离，st存储每个节点的最短路径是否确定。
int dijkstra(){
  memset(dist,0x3f,sizeof dist);
  dist[1]=0;
  for(int i=0;i-1;i++){ // 遍历剩余节点
      int d=-1;
      for(int j=1;j<=n;j++) // 在还未确定最短路的节点中，寻找距离最小的点
          if(!st[j]&&(d==-1||dist[d]>dist[j])) d=j;
      for(int j=1;j<=n;j++) // 根据寻找到的节点d更新其他点的距离
          dist[j]=min(dist[j],dist[d]+g[d][j]);
      st[d]=true; // 将节点d设置为最短路径确定的点
    }
  if(dist[n] == 0x3f3f3f3f) return -1;
  else return dist[n];
}

`堆优化Dijkstra`

基于邻接表存储的算法。

时间复杂度是$O(mlogn)$，仅支持求正权边的最短路径。算法时间复杂度与边数有关，适用于稀疏图。

typedef pair<int,int> PII;
int h[N],e[N],ne[N],w[N],n,idx,dist[N];
bool st[N]; // st存储每个节点的最短路径是否确定。
int dijkstra(){
  memset(dist,0x3f,sizeof dist);
  priority_queue,greater>heap;
  heap.push({0,1}); //插入距离和节点编号
  while(!heap.empty()){
      auto d=heap.top();
      heap.pop();
      int node=d.second,dis=d.first;
      if(st[node]) continue;
      st[node]=true;
      for(int i=h[node];i!=-1;i=ne[i]){
          int k=e[i];
          if(dist[k]>dist[node]+w[i]){
              dist[k]=dist[node]+w[i];
              heap.push({dist[k],k});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
  else return dist[n];
}

`Bellman-Ford算法`

基于结构体存储的算法。

算法的基本思想是通过不断地松弛边来逐步确定源点到其他所有顶点的最短路径。它使用了动态规划的思想，通过对所有边进行松弛操作，逐渐更新顶点的最短路径估计值，直到达到最优解。

初始化：将源点的最短路径估计值设置为0，其他顶点的最短路径估计值设置为正无穷大（或一个足够大的值）。
进行松弛操作：对图中的每条边进行松弛操作，即根据边的权值更新顶点的最短路径估计值。对于边(u, v)，如果通过 u 可以获得更短的路径，**则更新顶点 v 的最短路径估计值为 dist[u] + weight(u, v)**，其中 dist[u] 表示源点到顶点 u 的最短路径估计值。
重复进行步骤2：重复进行步骤2，执行 V-1 次松弛操作，其中 V 是图中顶点的数量。这样可以确保在最坏情况下，所有的最短路径都能被找到。
检测负权回路：进行第 V 次松弛操作后，如果仍然存在可以进行松弛操作的边，则说明图中存在负权回路，无法得到有效的最短路径。

const int N=1e3+10,M=1e5+10;
int n, m; // n表示点数，m表示边数
int dist[N],backup[N]; // dist[x]存储1到x的最短路距离
struct{ // 边，a表示出点，b表示入点，w表示边的权重
    int a, b, w;
}edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for (int i = 0; i < n; i ++ ){
      memcpy(backup,dist,sizeof dist);
        for (int j = 0; j < m; j ++ ){
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
           dist[b] = min(dist[b],backup[a]+w);
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    else return dist[n];
}

`SPFA算法 (Shortest Path Faster Algorithm)`

基于邻接表存储的算法。

SPFA算法通过不断地松弛边来逐步确定源点到其他所有顶点的最短路径。与Bellman-Ford算法不同的是，SPFA算法使用了一个队列来优化松弛操作的选择，减少了不必要的松弛次数，从而提高了算法的效率。

创建一个队列，将源点加入队列，并初始化源点到其他所有顶点的距离为无穷大（或一个足够大的值），源点到自身的距离为0。
当队列不为空时，执行以下操作：
a. 从队列中取出一个顶点作为当前顶点。
b. 遍历当前顶点的所有邻接顶点：如果通过当前顶点可以获得更短的路径，则更新邻接顶点的距离，并将其加入队列（如果尚未在队列中）。
当队列为空时，算法结束。此时，源点到所有其他顶点的最短路径长度已确定。

const int N=1e3+10;
int h[N],w[N],e[N],ne[N],dist[N],idx,n;       // 邻接表存储所有边
bool st[N];     // 存储每个点是否在队列中

int spfa(){ // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
    memset(dist, 0x3f, sizeof dist);dist[1] = 0;
    queue<int> q; q.push(1); st[1] = true;
    while (!q.empty()){
        auto node = q.front();
        q.pop();
        st[node] = false; //当一个点从队列中出队时，需要将对应的 st 数组中的标记设置为 false，表示该点不在队列中了。
        for (int i = h[node]; i != -1; i = ne[i]){
            int k = e[i];
            if (dist[k] > dist[node] + w[i]){
                dist[k] = dist[node] + w[i];
                if (!st[k]){  // 如果队列中已存在j，则不需要将j重复插入
                    q.push(k);st[k] = true;
                }
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    else return dist[n];
}

判断负环：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

const int N=1e3+10;
int h[N],w[N],e[N],ne[N],dist[N],cnt[N],idx,n;       // 邻接表存储所有边
bool st[N];     // 存储每个点是否在队列中

int spfa(){ // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
    queue<int> q;
  for(int i=1;i<=n;i++) {st[i]=true;q.push(i);}
    while (!q.empty()){
        auto node = q.front();
        q.pop();
        st[node] = false; //当一个点从队列中出队时，需要将对应的 st 数组中的标记设置为 false，表示该点不在队列中了。
        for (int i = h[node]; i != -1; i = ne[i]){
            int k = e[i];
            if (dist[k] > dist[node] + w[i]){
                dist[k] = dist[node] + w[i];
              cnt[k]=cnt[node]+1;
              if(cnt[k]>=n) return true;
                if (!st[k]){  // 如果队列中已存在j，则不需要将j重复插入
                    q.push(k);st[k] = true;
                }
            }
        }
    }
    return false;
}

`Floyd算法`

基于邻接矩阵存储的算法。

Floyd算法是一种经典的动态规划算法，用于求解所有节点对之间的最短路径。其基本思想是通过中转节点逐步更新路径，从而找到最短路径。

初始化距离矩阵：将每条边的权重存储在距离矩阵 dist 中，如果两个节点之间没有直接的边相连，则将其距离设置为一个较大的值（通常为无穷大）。
通过中转节点逐步更新路径：对于每一个节点k，考虑从节点i到节点j的路径，判断是否存在通过节点k的更短路径。如果存在，则更新距离矩阵中节点i到节点j的距离为节点i到节点k的距离加上节点k到节点j的距离。
重复执行第2步，直到所有节点对之间的最短路径都被计算出来。
最终，距离矩阵 dist 中存储的就是所有节点对之间的最短路径。

const int INF=0x3f3f3f3f,N=1e3+10;
int d[N][N];
void init(){
for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0; else d[i][j] = INF;
}
// 算法结束后，d[a][b]表示a到b的最短距离
void floyd(){
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

`最小生成树`

`Prim算法`

Prim算法是基于顶点的贪心算法。

给定一个连通的无向加权图$G = (V, E)$，其中$V$是顶点集合，$E$是边集合，每条边有一个权重 $w(u, v)$。Prim算法从一个初始顶点开始，逐步扩展生成树，每次选择具有最小权重的边并且该边连接了一个新的顶点。

初始化：
- 选择一个初始顶点，将其加入生成树。
- 创建一个集合$T$，用于存储生成树中的顶点，初始时包含初始顶点。
- 对于每个顶点，记录从$T$到该顶点的最小边权重（使用优先队列或最小堆来有效地获取最小边）。
扩展生成树：
- 从优先队列中选择权重最小的边，该边连接了一个在$T$中的顶点和一个不在$T$中的顶点。
- 将新顶点加入集合$T$。
- 更新优先队列中与新顶点相连的边的权重（如果这些边的权重比当前记录的最小权重小）。
重复：
- 重复上述步骤，直到所有顶点都被包含在生成树中。

`朴素Prim`

int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中
// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);
    int res = 0;
    for (int i = 0; i < n; i ++ ){
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
            t = j;
        if (i && dist[t] == INF) return INF;
        if (i) res += dist[t];
        st[t] = true;
        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }
    return res;
}

`Kruskal算法`

kruskal基于贪心策略，通过逐步选择权重最小的边来构建生成树。

给定一个连通的无向加权图$G = (V, E)$，其中$V$是顶点集合，$E$是边集合，每条边有一个权重 $w(u, v)$。Kruskal算法通过选择不形成环且权重最小的边来构建最小生成树。

初始化：
- 创建一个空集合$T$用于存储最小生成树中的边。
- 将图中的所有边按权重从小到大排序。
选择边：
- 从权重最小的边开始，逐条检查这些边。
- 如果当前边连接的两个顶点属于不同的连通分量（即不形成环），则将该边加入集合$T$。
- 使用并查集数据结构来高效地检测和合并连通分量。
重复：
- 重复上述步骤，直到集合$T$中包含$V-1$条边为止，此时$T$就是图的最小生成树。

int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组
struct Edge{    // 存储边
    int a, b, w;
    bool operator< (const Edge &e)const{
    return w < e.w;
}
}edges[M];
int find(int x){ // 并查集核心操作
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}
int kruskal(){
    sort(edges, edges + m);
    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集
    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ ){
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a), b = find(b);
        if (a != b){   // 如果两个连通块不连通，则将这两个连通块合并
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }
    if (cnt < n - 1) return INF;
    return res;
}

`二分图`

`染色法`

只要图不含有奇数个环，那么一定能被染色。

选择一个起始节点作为初始顶点，并将其染成一种颜色（例如红色）。
对于起始节点的每个邻居节点，将其染成与起始节点不同的颜色（例如蓝色）。
递归或迭代地对每个邻居节点进行步骤2，将其邻居节点的邻居节点染色，直到所有节点都被染色。
在染色的过程中，如果发现任意两个相邻节点被染成相同的颜色，说明该图不是二分图。
如果所有节点都被正确染色，并且没有相邻节点被染成相同的颜色，那么该图是二分图。

int n;      // n表示点数
int h[N], e[M], ne[M], idx;     // 邻接表存储图
int color[N];       // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
// 参数：u表示当前节点，c表示当前点的颜色
bool dfs(int u, int c)
{
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i]){
        int j = e[i];
        if (color[j] == -1)
        if (!dfs(j, !c)) return false;
        else if (color[j] == c) return false;
    }
    return true;
}
bool check(){
    memset(color, -1, sizeof color);
    bool flag = true;
    for (int i = 1; i <= n; i ++ )
        if (color[i] == -1)
        if (!dfs(i, 0)){
        flag = false;
        break;
    }
    return flag;
}

`匈牙利算法`

匈牙利算法是一种解决最大匹配问题的经典算法。它用于在二分图中找到一个最大的匹配，即将尽可能多的边匹配起来。匈牙利算法基于增广路径的思想，其基本思路是通过不断寻找增广路径来增加匹配的边数，直到无法找到增广路径为止。

初始化匹配：将所有的匹配边置为空。
对于二分图的每个未匹配顶点，尝试找到增广路径。
寻找增广路径：从一个未匹配的顶点开始，使用深度优先搜索或广度优先搜索的方法，依次访问与当前顶点相邻的未匹配顶点。如果找到一个未匹配的顶点，则将路径中的边进行翻转，即将原本匹配的边变为非匹配边，将原本非匹配的边变为匹配边。
重复步骤3，直到无法找到增广路径为止。
最终，得到的匹配即为二分图的最大匹配。

int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过
bool find(int x){
    for (int i = h[x]; i != -1; i = ne[i]){
        int j = e[i];
        if (!st[j]){
            st[j] = true;
            if (match[j] == 0 || find(match[j])){
                match[j] = x;
                return true;
            }
        }
    }
    return false;
}
// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ ){
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
}

`动态规划`

`背包问题`

`01背包`

`完全背包`

`多重背包`

`分组背包`

`线性DP`

`区间DP`

`计数DP`

`数位统计DP`

`状态压缩DP`

`树型DP`

`记忆化搜索`



一封跨越半个世纪的来信引发的思考
2024-11-12T18:10:37.000Z
                            Hey, password is required here.          
  



_._
2024-10-01T14:29:36.000Z
Preface
就像Cover中所描述的那样，我的推免之路并不是一帆风顺，中间有太多插曲，甚至一度做好了放弃的打算，但好在沉住了气，守得云开见月明！
BG
本科：山西大学-计算机科学与技术专业（第五轮学科评估B+）
专业排名：1/117（综合）、9/117（GPA）
英语：540（CET-6）、587（CET-4）
竞赛：国奖（国二、国三）、省奖（省一、省二……）
科研：一篇中科院二区TOP一作（RA-L）
夏令营：西工大CS（学硕优营）、电子科大深思（专硕优营）、电子科大CS（学硕优营）、厦大MAC（专硕优营）、浙大软院（放弃）、华东师范（放弃）、北邮5组（放弃）
预推免：中科院VIPL、同济CS（放弃）、中科大10系（offer）、西安交大软院（wl）
最终去向：中科大10系
我在山大的三年
过去三年的经历还是相当丰富的，但好像主旋律依旧是“学习”。
本人记性不是特别好，很难面面俱到地回想起前三年的点滴，因此后面主要以重要的时间阶段作为回忆的锚点，如果你对某些故事特别感兴趣亦或想了解更多，欢迎邮件。
本人并不是一个外向的人，这一路大多都是摸石头过河，很少参考往届学长学姐的经验。执笔此文也是希望，我这个样本，能给后面的SXUers提供更多的参考。希望诸位都能站在前人的肩膀上，能预见的更多，能有更多从容选择的机会。
春风得意马蹄疾，一日看尽长安花。
这个时期（大一）主持了年级的迎新晚会，尝到了成果的甜头，绩点稳中向好，有过一段短暂的恋爱经历……总之算是前三年最轻松的时段。
上大学之前，我可完全没有主持的经验，主打一个突破舒适区。可能是选拔有点水，反正我就顺利地成为了晚会的主持人，虽说顺利，但好像前前后后应该也是面了三次。也就是这一次经历，结识了一个特别有趣、努力的天津姑娘，古力博坤（晚会主持人之一）。
    
这是晚会前一天去柳巷租完礼服后路边拍的，摄影师是古力博坤。你就说，这人物，这构图，是不是满昏😳。特殊时期，也是乖乖地戴好口罩。
    
这应该快到晚会闭幕式时拍的。emmm，除了略显局促，其他完美🤪！
这个成果指的是一套基于兴趣聚类的宿舍分配系统。这是由我们辅导员老高牵头，我作为负责人完成的一个项目，也是我大学第一个接手的项目。虽然这个过程中出现了很多小插曲，但总算顺利地按我承诺的期限和质量完成了这个项目。这段经历真正让我以“做好产品”的角度去思考问题，也让我开始去思考一个团队如何高效地进行合作（敏捷开发模式中提倡的小而精的开发团队是很有必要的）。
    
这个项目之后，也是自信溢满。（主要也还是导员在那吹：什么一般的毕业生也就做一个小系统，你们能独立地弄出来已经快赶上毕业生的水平了。🌝balabala……）
其实回首观望，也就那么回事。只是说以当时的眼界、格局和心境，说“春风得意”也为之不过。
这个时期上课也是不敢懈怠（当然是什么课也不敢懈怠，不去就扣学分的Warning⚠️，在这个时候还是蛮具有威慑力的），所以绩点基本上也没什么大问题。
    
谁懂，之前没学过游泳，刚上游泳课跟不上进度，周末自费去游泳馆🐷……别问我构图为什么是斜的，emmm，可能当时候就喜欢这样拍🥲？
长路漫漫无尽处，迷雾重重向何方。
这段时期应该是我整个大学生涯最迷惘的时候。
特殊时期，我们有两场期末考试是在线上进行的（大一下和大二上），也就是大二上这场线上考试彻底击碎了我的心理防线。一场考试下来竟然有人把绩点稳稳地维持在4.0往上，简直离谱（不过三年下来，专业绩点最高也就3.87，是什么原因大家都心知肚明）。因为有这样一群“大牛”的存在，自然我的排名就掉到百米开外咯，也让我一度觉得保研这件事已经跟我没有太大关系。所以当时最纠结的一件事就是，是继续坚持保研这条路，还是直接放弃，提前准备考研。
这段记忆之所以那么深刻，是因为我始终记得那个每天晚上走在操场上，迷惘，不知所措的少年。
当然也就是这样一段时期，让我深刻地意识到，我的大学仿佛又活成了高中的模样。
长凤破浪会有时，直挂云帆济沧海。
随着所做的项目“基于2D虚拟人语音驱动算法的研究”在第十四届服务外包创新创业大赛中接连取胜，我也逐渐从迷失的状态慢慢过度到无问东西的状态。没错，前一个阶段我还是挺过去了，很庆幸当时并没有放弃！
                                                                                                                                
                        
No action? Refresh.
在逆境中重生，这个时期可以说是最艰难的时候，是身心俱疲但仍需向上求索，是逐渐重拾信心的阶段。也很感谢，身边一直有一个小团队在支撑着我前进。
竹杖芒鞋轻胜马，谁怕？一蓑烟雨任平生。
进度条来到大三，我的竞赛加分已经全部加满。也就是说，我的推免资格已经不成问题了，接下来需要做的就是被外校认可。也就是这一时期，开启了我的科研之路。我并不想把这一年描述的有多艰难，因为课题组的氛围实在太棒了，陈老师一直把我视为己出，各位师兄师姐都非常的友好，以至于很多时候都有被治愈到。
                
课题组经常会聚餐（哈哈哈，也是在这个过程，我学会了喝酒~白的哦！）和团建，这一学年里与大家留下来很多珍贵的回忆，承蒙各位师兄师姐关照。
当然，这一学年最令人激动的还是在6月13号，我的处女作被录用啦~
    
梦里寻他千百度，蓦然回首，那人却在，灯火阑珊处。
BG完善的差不多，这个阶段的主线任务就是利用手头的资源博取更大的收益。资料准备-夏令营-预推免-正式推免，从今年的四月份到九月份，应该是焦虑混杂着不安，让人睡不着觉的时候，也就是这个时期我的头发掉的最多。（当然，没秃啊！）
我们可以详细聊聊资料应该准备哪些！（下图仅供展示，所有能Share的资料已全部在主页展出，请不要再私聊索取资料！）
    
首先，最重要的是所有的资料都需要有条不紊。最好用一个方便文件管理的软件，当然系统的文件夹也是可行的，重要的不是工具，是意识。
其次，你应该着重准备的材料是：个人简历，相应的证明材料，Personal Presentation，这三项是最重要的；其次还有：推荐信，个人陈述（未来规划），各院校的官网、历年推免信息（建议有能力的同学，可以利用RSS进行管理）……
最后，你应该思考如何完成一场较为精彩的复试考核，eg.面试、机式、笔试。不是所有院校都会组织机式和笔试，但是面试是肯定有的。因此你必须做的是梳理前面三年的经历，可选择的是专业课复习（当然，其实面试时也很有可能涉及到专业课考核）、OJ复习。
西安
首次西安行是西工大，刘老师人很好。还没过去之前，跟刘老师说了我高铁时间的问题，老师也是直接帮忙解决了！
虽然，西工大（长安校区）确实是偏了些，但在同等条件下，第五轮CS评估A+对潜心科研的同学未免是一个坏事。
    
西工大还有一个正式的开营仪式，本来拍了几张照片，但是删掉了……下面几张还是借的同学的😬。
                                
西工大的考核也只有面试，组成是“Presentation+英语+政治+专业（BG）”。考核的时候，刘老师就坐在旁边，但是我还是挺紧张的。老师中途还提醒我声音大点，但是我没听清，忽略掉了😅。当然，最后还是拿到了优营（93.8/100）。
成都
成都一行太过仓促，只在成都待了一天，面完电子科大就撤了。当然撤之前去了趟太古里，去IFS看了那个熊猫屁股🤔。
        
成电的夏令营考核也只有面试，组成是“自我介绍+专业课+英语+BG”。
虽然过程挺仓促的，但是依旧成功拿下成电的CS学硕，我觉得是夏令营最大的成功。以至于后面我拿到中科大专硕的offer时，依旧犹豫如何做选择。
联系的王老师人也特别好。王老师是我夏令营的主面试官，后面拿到优营，也是第一时间给老师发去了邮件，老师看到后也是第一时间打电话过来确认，至此我有一个特别满意的保底院校。可是最后还是没能过去，挺对不起王老师的😭。
厦门
厦大是我夏令营的最后一程，后面陆陆续续还有其他学校的入营，但都拒绝了。厦大的夏令营考核包括机式和面试（当然，在此之前Mac实验室还有一轮的Paper Reading和线上汇报），机式就三道题，面试主要是BG。
其实我很清楚就算拿到了厦大Mac的offer可能也不会过去，之所以仍然附身前往，是因为之前和大师兄有个约定——沿沙滩而坐，海风习过，畅饮而谈。
    
    
    
    
    
    
    
    
    
好不容易来了趟海滨城市，怎么能不去游玩呢？第二天，鼓浪屿！
北京
北京之旅跟厦门之行很类似。中科院计算所的VIPL组也是发了预推免邀请，但是拿到了offer大概率也不会去的那种。选择前往有两方面原因：1、已经gap了近2个月之久，各种笔面机试的能力都要重新捡起来。2、去北师大看蒋xinxin。
需要注意的是，如果你特别想去中科院计算所，那么你最好参加他们的夏令营而不是预推免。VIPL的考核还是比较全面的，包括笔试、机式和面试。其中笔试也可以说是面面俱到了。
    
只有前一天的笔试和机式通过了，才能参加第二天的面试。
    
除了复试本身，最令人难忘的还是北京的物价！你敢相信这不到10平的房间一晚的价格是250人民币😂。
        
由于学校催交材料，本来计划打算在京多待一天的，结果改了下午的高铁，匆匆地走了。但是！走之前还是去找了趟蒋xinxin（左一），去她学校蹭了顿饭。临走的时候还碰到了另一个高中同学DR（右一）。
    
此外，不得不说中关村的互联网氛围还是挺浓厚的。落地北京，前往酒店的路上就碰到几个人在聊技术问题，码农无疑了。
        
最后还值得一提的是：计算所之旅还认识国际关系学院一个正能量满满的姑娘！相谈甚欢，挺欣赏她这种大大咧咧，个性独立的女生。可以跟大家分享一下她镜头下的贵州（人家保研成功后孤身前往~）。
                            
合肥
科大高新校区的环境一绝！特别是图书馆！以后机会很多，再更新！
    
    
    
    
又见西安
幸运的是，西交的兴庆校区不像西工大的长安校区一样偏！西交软院的复试就只有面试，而且是纯纯的BG面。10分钟，快节奏。但是录取并不是按分数择优录取，而是结合本科院校背景，分档择优录取，因此想要报考西交软院的需要特别注意！
之所以吐槽不了西交软院，是因为庞老师！庞老师和我院的梁老师是一个课题组的，两位老师都温文尔雅，都非常愿意提携后辈！从过初筛、正式复试到正式推免，庞老师帮我费尽心思，衷心感谢！同样也感谢梁老师的帮助！
    
最后，此趟西安行最印象深刻的是我住的酒店！艺龙海雅酒店(西安大雁塔雁翔路北口地铁站店)   ，百元价位中，住过最满意的酒店，强烈推荐！
真正去参加考核的院校就这些，但是表示愿意接收我的老师远远不至这些，很遗憾的是很多院校的初筛卡本科院校背景。没通过初筛意味着前期的努力全部变为一张废纸，但既然结局已定，也要输的体面！
    
eg.武大遥感国重的绝大部分老师表示愿意接收，其中李老师甚至在收到邮件后连夜打电话给我，涂老师也帮助我修改简历，董老师携课题组的认可等等；华科CS的陈老师也给予我极大的信心；中南CS的梁老师、奎老师；南开CS；南大智科；浙大工程师等等。
        
最遗憾的是同济CS，时间和科大冲突了，无赖放了刘老师的🕊。
个体的力量永远是有限的，积极地、诚恳地向外寻求合作是终极秘诀！再次感谢这一路来本校老师的帮助、外校老师的认可！
我的三年好像就这么告一段落了，但依旧还有很多值得复盘！我也在尝试将过去三年所经历的事一点点的总结，形成自己的方法论，与诸君共勉！


成功上岸 | 中科大 | 风雨同舟，我们阔步向前
2024-09-29T03:42:49.000Z
成功上岸，离不开各位家人、老师、朋友的帮助。这一路故事太多，后面我们茶话细谈。



Accepted | RA-L | Maiden work
2024-06-13T11:00:24.000Z
I’m so excited that my first paper has been accepted!



Film Record
2024-05-31T09:31:32.000Z
      Valuable works are always waiting to be discovered.
  
 《燃烧》：最全解读，你真的看懂《燃烧》了吗？（燃烧）影评 
 《深海》：读懂《深海》的故事与讲故事的方式（深海）影评 
 《默杀》：《默杀》深度解析：没懂的来看这篇解读，真相都藏在细节和彩蛋里（默杀）影评  Note：优缺点都很明显，6.9分很公允。
 《涉过愤怒的海》：《涉过愤怒的海》深度解析：没懂的来看这篇解读，开篇就隐藏伏笔（涉过愤怒的海）影评 、深度解析《涉过愤怒的海》：癫狂之下全是痛【对话曹保平】 
 《阳光普照》：如何评价电影《阳光普照》？ 
 《狗十三》：一条专访《狗十三》主创：我们终于活成了听话的狗（狗十三）影评 
 《走走停停》：《走走停停》影评：也许，只有中年人才能看懂吧（走走停停）影评 
 《路边野餐》&《地球最后的夜晚》：《路边野餐》：无法把握的人生（路边野餐）影评 、《地球最后的夜晚》全解析，长长长评来了！（地球最后的夜晚）影评 
很有意思的是，我是19年年初在影院看的《地球最后的夜晚》，然后于24年线上看的《路边野餐》。路野没看多久就意识到，平静却深刻的叙事方式、现实与梦幻的交织，跟记忆中的《地球最后的夜晚》风格很像，一查果然！原来都出自毕导之手。通过迭代的作品去观察一个人的阅历轨迹是一件很有意思的事！
 《二次呼吸》：关于虚无，自由意志和爱（二次呼吸）影评 
 《消失的爱人》、《搜索》（2012，陈凯歌）、旧闻评论｜事实核查在姜萍事件中如何遇阻？ 、“努力想要活下去”的她，最终留下一封遗书走了 
 《婚姻故事》：“当我们谈论婚姻时，我们在谈论什么？”（婚姻故事）影评 
 《魅杀》&《魅杀2》
 《瞬息全宇宙》
 《Duna》&《Duna 2》
 《某种物质》：《某种物质》深度解析：这部电影，是我今年看过尺度最大的片子（某种物质）影评 
 《姥姥的外孙》：《姥姥的外孙》深度解析：没懂的来看这篇解读，真相都藏在细节里（姥姥的外孙）影评 
 《因果报应》：评分飙升，口碑爆棚，今年最好的悬疑片！印度悬疑片《因果报应》 
 《浪浪山小妖怪》
在院线看的，一般，顶多7分吧。教训：甄别影片在院线上映期间的流媒体宣传。
 《银翼杀手2049》：反叛复制人取代人类？赛博朋克最强续作！万字拆解《银翼杀手2049》 
 《爱乐之城》：《爱乐之城》这个情人节，你是怎么过的呢？看看这部近年来最好的爱情歌舞片吧 
 《超体》：【万字细读】《超体》版“修仙”指南：吸毒成神，科学还是玄学？黑寡妇的科幻巅峰 


组内团建
2024-04-23T11:57:53.000Z
很幸运遇到这样一群有意思的人！



A thought-provoking sentence
2024-04-07T10:52:01.000Z
I was elated today because my instructor praised my dissertation proposal at the group meeting. Of course, I was not present because of the class. I learnt about it from senior sister apprentice Huai Yao. I instinctively told her, “Don’t make a fuss, you’ll make me shy”. Then Huai Yao said something very profound to me. 
I was thinking, it seems like we’ve always been taught to learn to be humble in our dealings with others. But this mellow wisdom in dealing with people is supposed to stay only in the world outside of ourselves. If our hearts are constantly infested with this kind of thinking, it’s easy to fail to recognise where we are.


XV6 File System
2024-01-13T14:00:51.000Z
Lab5 文件系统
1.文件系统
1.1.一些经典的文件系统
FAT文件系统（File Allocation Table）： FAT是一种简单而广泛使用的文件系统，最初用于MS-DOS和Windows操作系统。它具有相对简单的结构，容易实现和维护，但在处理大容量存储和提供高级功能方面存在一些限制。
NTFS（New Technology File System）： NTFS是由Microsoft开发的高性能文件系统，用于Windows NT及其后续版本。它支持更大的文件和分区大小，具有更先进的权限管理、日志记录和元数据特性。
ext文件系统：ext2： 是Linux中早期版本使用的文件系统，具有相对简单的结构，不支持日志。
ext3： 在ext2的基础上添加了日志功能，提供了更好的稳定性和可靠性。
ext4：是ext3的后继者，引入了一些性能改进和新特性，支持更大的文件和分区。
HFS和HFS+（Hierarchical File System）： HFS是由苹果公司用于Macintosh计算机的文件系统。HFS+是其后续版本，引入了更大的文件和卷支持，以及更先进的特性。
APFS（Apple File System）：是由苹果公司设计和推出的现代文件系统，用于替代HFS+（Hierarchical File System Plus），并首次引入于macOS High Sierra（10.13）操作系统。
1.2.xv6fs 文件系统
今天我们的主角是xv6fs，是一个教学用途的类 Unix 操作系统，设计简单，方便学生学习和理解操作系统的基本原理。
在 xv6 中，文件系统负责管理文件和存储设备上的数据。xv6 使用的文件系统是基于简化的 Unix 文件系统的，包括基本的文件和目录操作、inode 结构等。
xv6磁盘文件系统的分区图如下：
1.2.1.boot（引导块）
Lab2 中学过，这里就不再论述了。
1.2.2.superblock（超级块）
存有文件系统的元信息
1
2
3
4
5
6
7
8
9
10
11
//fs.h

struct superblock {
  uint size;         // 文件系统大小，也就是一共多少块
  uint nblocks;      // 数据块数量
  uint ninodes;      // i结点数量
  uint nlog;         // 日志块数量  
  uint logstart;     // 第一个日志块块号 
  uint inodestart;   // 第一个i结点所在块号
  uint bmapstart;    // 第一个位图块块号
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//mkfs.c

#define NINODES 200
// Disk layout:
// [ boot block | sb block | log | inode blocks | free bit map | data blocks ]

int nbitmap = FSSIZE/(BSIZE*8) + 1;
int ninodeblocks = NINODES / IPB + 1;
int nlog = LOGSIZE;
int nmeta;    // Number of meta blocks (boot, sb, nlog, inode, bitmap)
int nblocks;  // Number of data blocks

int fsfd;
struct superblock sb;
char zeroes[BSIZE];
uint freeinode = 1;
uint freeblock;
在我们进入xv6系统之后，会输出一段关于超级块sb中存储的信息：
我们可以看到，整个磁盘一共有1000块，其中有941块是用来存储数据的，有200个索引节点，索引项从第32个块磁盘块开始存储，30条日志记录，日志记录从第2个磁盘块开始存储，而位图区从第58个磁盘块开始存储。
1.2.3.logblock（日志区）
在 xv6 文件系统中，日志区是指用于事务日志（transaction log）的一部分存储区域。xv6 使用日志来确保文件系统的一致性，尤其是在面临系统崩溃或中断的情况下。日志区的主要目的是在进行文件系统更新时，首先记录要执行的所有操作，然后将这些操作一次性写入磁盘。这样，即使在执行过程中系统崩溃，可以通过日志来恢复到一致的状态。
1.2.4.inode（索引区）
我们现在想想，这个索引可能会存在的位置？
没错，肯定会在磁盘中出现，因为要在磁盘中组织这些文件，因此磁盘中一定会包含文件索引信息
那么还有可能就是在内存中了，因为进程对文件进行操作都是在内存中进行的，因此内存中必然包含文件的索引信息。
那么，我们现在讨论的索引区，准确来说是在磁盘中的索引。为了和内存中的索引相区分，我们将磁盘中的索引称为dinode（disk inode）。
在fs.h中包含对dinode的Definition：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//fs.h

#define NDIRECT 12
#define NINDIRECT (BSIZE / sizeof(uint))
#define MAXFILE (NDIRECT + NINDIRECT)
// On-disk inode structure
struct dinode {
  short type;           // File type
  short major;          // Major device number (T_DEV only)
  short minor;          // Minor device number (T_DEV only)
  short nlink;          // Number of links to inode in file system
  uint size;            // Size of file (bytes)
  uint addrs[NDIRECT+1];   // Data block addresses
};
type： 短整型（short），表示文件的类型。可能的取值包括：T_DIR：目录
T_FILE：普通文件
T_DEV：设备文件
major： 短整型（short），仅在文件类型为设备文件（T_DEV）时有意义，表示主设备号。
minor： 短整型（short），仅在文件类型为设备文件（T_DEV）时有意义，表示次设备号。
nlink： 短整型（short），表示指向该 inode 的硬链接数。
size： 无符号整型（uint），表示文件的大小（以字节为单位）。
addrs[NDIRECT+1]： 无符号整型数组，用于存储文件数据块的地址。NDIRECT 是一个常量，表示直接数据块的个数。这个数组包含了直接数据块和一级间接数据块的地址。如果文件很小，数据块地址可以直接存储在 addrs 数组中；如果文件较大，会使用一级间接块来存储更多的数据块地址。
了解了dinode，我们趁热打铁，继续了解内存中的inode。
内存中的inode被一个叫icache的结构所组织，在fs.c中进行定义：
1
2
3
4
5
6
//fs.c

struct {
  struct spinlock lock;
  struct inode inode[NINODE];
} icache;
struct spinlock lock： 自旋锁，用于对整个 icache 结构进行加锁。由于 inode 缓存是一个共享的数据结构，多个线程同时访问时需要使用锁来保护共享资源的一致性。
struct inode inode[NINODE]：inode数组 ，包含了 NINODE 个 struct inode 结构体。NINODE 是一个常量，表示 inode 缓存中可以缓存的 inode 的数量。每个 struct inode 表示一个文件或目录的元数据信息，包括文件类型、大小、指向数据块的地址等。
在file.h中对inode进行定义：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//file.h
// in-memory copy of an inode
struct inode {
  uint dev;           // Device number
  uint inum;          // Inode number
  int ref;            // Reference count
  struct sleeplock lock; // protects everything below here
  int valid;          // inode has been read from disk?

  short type;         // copy of disk inode
  short major;
  short minor;
  short nlink;
  uint size;
  uint addrs[NDIRECT+1];
};
我们可以看到，除了有跟dinode一致的数据项之外，还有一些额外数据项：
uint dev： 无符号整型（uint），表示该 inode 所在的设备的设备号。
uint inum： 无符号整型（uint），表示该 inode 的编号，即该 inode 在设备上的唯一标识符。
int ref： 整型（int），表示对该 inode 的引用计数。引用计数用于跟踪有多少个指针（例如，打开文件描述符）引用了这个 inode。当引用计数为零时，inode 可以被释放。
struct sleeplock lock： 一个睡眠锁（sleeping lock），用于保护 struct inode 中除了 lock 自身之外的其他字段。睡眠锁是一种同步机制，它允许线程在访问被锁定资源时进入睡眠状态。
int valid： 整型（int），表示该 inode 是否已经从磁盘读取并被标记为有效。当 valid 为 1 时，表示该 inode 包含的信息已经被读取到内存中。
Ex5-1 请解释为 icache 添加的锁 与 为 inode 添加的锁不同的原因？
1.2.5.bitmap（位图区）
在理论课中，我们学过，位图是一种磁盘空间管理的方案。
这里补充一个大家容易误解的知识点：数据块的分配和释放由位图来管理，但位图管理的区域不止数据区，而是整个文件系统。
位图块中每一位都代表着一块，该位置 1 表示相应的块正在使用，该位置 0 表示相应的块空闲。
1.2.6.data（数据区）
数据区没啥好说的，只要记住一个点：以块为单位进行存储，可能会产生块内碎片；数据区的存储由位图区进行管理。
到这里，我们就能对单个文件的检索过程有一个清晰的认知：
除了上述一些在磁盘分区中直接体现的结构之外，文件系统还有一些重要的结构需要我们去了解。
我们先试想一下，索引极大的方便了数据块的查找，但其依然是对于文件系统内部而言的。我们平常去检索一个文件从来没有说，通过索引项去找到该文件的吧。相反，我们总是通过文件的文件名去检索文件。因此，还必须有一个结构去实现这种 ”按名存取“ 的功能。这就是目录！
1.2.7.directory（目录）
在xv6中，跟目录有关的结构体被定义在fs.h中：
1
2
3
4
5
6
7
8
//fs.h
// Directory is a file containing a sequence of dirent structures.
#define DIRSIZ 14

struct dirent {
  ushort inum;
  char name[DIRSIZ];
};
ushort inum：无符号短整型，表示该目录项对应的 inode 号。
char name[DIRSIZ]：字符数组，表示目录项的名字。DIRSIZ 是一个常量，表示目录项名字的最大长度。
其中，每一个dirent结构体被称为目录项。在 xv6 操作系统中，目录项存储在磁盘的数据块中。每个目录都有一个对应的 inode，而目录项信息实际上被存储在该目录的数据块中。这个数据块包含了一系列的目录项，每个目录项都表示一个文件或子目录。
我们在xv6的终端中输入ls命令，既可以看到根目录的目录结构：
我们使用xv6提供的终端命令mkdir自己创建一个目录mydir，再在改目录下通过echo命令创建两个文件
之后我们在使用ls命令查看根目录的结构
我们来解释一下ls输出的内容：
第一列表示文件名，其中“.”表示本目录，”..“表示父目录（根目录的父目录就是其自身）
第二列表示文件类别，我们知道，在Unix操作系统中，”一切皆文件“的思想，在stat.h中，给出了三种文件类型：
1
2
3
#define T_DIR  1   // Directory
#define T_FILE 2   // File
#define T_DEV  3   // Device
其中1表示目录文件，2表示数据文件，3表示设备文件。
我们可以看到“.”和”..“以及我们创建的“mydir”都是目录文件，而console是设备文件
第三列表示inode编号，这是直接在目录项中存在的，其数值必然是唯一的。
第四列表示文件的大小，这是在目录项中没有的，因此我们可以推断，ls命令应该既访问了目录项，又访问了inode结点。
很显然，这种目录的组织结构就是我们熟知的树型结构
那么，假如我们要检索创建的“myfile1”文件，就需要按照树型结构的路径一层层往下找。当然，不同的起始出发点就会出现两种寻找策略：直接从根节点出发寻找和从当前目录项出发寻找。但是不管是哪一种策略，其都是一个递归的过程。
到这里，我们都还是介绍一些”共性“的结构，或者说概念。但是每一个文件肯定是不同，我们还需要一种能体现”特性“的结构体来表示每一个文件。
1.2.8.file（文件结构体）
1
2
3
4
5
6
7
8
9
10
11
//file.h

struct file {
  enum { FD_NONE, FD_PIPE, FD_INODE } type;
  int ref; // 引用计数
  char readable; // 文件是否可读
  char writable; // 文件是否可写
  struct pipe *pipe; // 管道文件
  struct inode *ip; // 关联的 inode
  uint off; // 读写位置
};
num { FD_NONE, FD_PIPE, FD_INODE } type： 表示文件类型的枚举。文件可以是普通文件（FD_INODE）、管道文件（FD_PIPE）或者无效的文件（FD_NONE）。
int ref： 引用计数，用于追踪有多少个文件描述符引用了这个文件。引用计数用于文件的释放，当引用计数为零时，文件可以被释放。
char readable 和 char writable： 标志文件是否可读和可写。这两个字段表示了文件的访问权限。
struct pipe \*pipe： 如果文件是管道文件，这个字段指向管道结构体。
struct inode \*ip： 指向文件关联的 inode 结构体，用于获取文件的元数据信息。
uint off： 当前文件的读写位置，表示下一次读写操作将在文件中的哪个位置发生。
接下来我们还得再了解一个概念：文件描述符，这是在进程中直接使用的一个结构。
1.2.9.文件描述符
进程使用文件并不使用file结构体或inode结构体，而是提供文件的路径名来打开文件并获得文件描述符，后续将使用文件描述符来指代这个打开的文件。xv6中，每个进程都有一个文件描述符表proc->ofile[]，最多可以使用NOFILE=16个文件描述符（也就是说一个进程最多同时打开16个文件），每个文件描述符都直接指向一个file结构体（系统管理的已打开的文件）。
1
2
3
4
5
6
7
8
9
//proc.c

// Per-process state
struct proc {
...
  struct file *ofile[NOFILE];  // Open files
  struct inode *cwd;           // Current directory
  char name[16];               // Process name (debugging)
};
现在，我们可以站在整个文件系统的层次对一个进程访问文件的整个过程有一个宏观的认知：
2.文件系统操作
2.1.盘块操作
文件系统的所有操作中，对盘块的操作是最底层的，是直接和硬件（设备驱动程序）打交道的。
在介绍盘块操作之前，我必须先指出大家可能模棱两可的问题：
对盘块的操作并不是直接在磁盘中对盘块进行操作，而是对映射到内存中的块缓存进行操作，至于原因，我觉得大家都明白。对一个盘块的多次读写操作都是在内存中完成的，直到换出到磁盘上才真正地执行写盘操作。
xv6fs只能通过块缓存来访问磁盘，而不允许直接访问。
2.1.1.盘块缓冲区
在xv6的buf.c中有对缓冲区的定义：
1
2
3
4
5
6
7
8
9
10
//buf.c

struct {
  struct spinlock lock;
  struct buf buf[NBUF];

  // Linked list of all buffers, through prev/next.
  // head.next is most recently used.
  struct buf head;
} bcache;
struct spinlock lock： 互斥锁，用于对整个缓冲区缓存进行加锁。由于缓冲区缓存是一个共享的数据结构，多个线程同时访问时需要使用锁来保护共享资源的一致性。
struct buf buf[NBUF]： 缓冲区数组，包含 NBUF 个 struct buf 结构体。每个元素表示一个缓冲区，用于缓存磁盘上的数据块。
struct buf head： struct buf 结构体，用作链表的头部。通过 head.next 和 head.prev 可以构建一个双向链表，用于管理所有缓冲区。head.next 指向最近使用的缓冲区，head.prev 指向最久未使用的缓冲区。
对每一个缓冲单元在buf.h中进行定义：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//buf.h

struct buf {
  int flags;
  uint dev;
  uint blockno;
  struct sleeplock lock;
  uint refcnt;
  struct buf *prev; // LRU cache list
  struct buf *next;
  struct buf *qnext; // disk queue
  uchar data[BSIZE];
};
#define B_VALID 0x2  // buffer has been read from disk
#define B_DIRTY 0x4  // buffer needs to be written to disk
int flags： 整型，用于表示缓冲区的状态标志。这些标志可能包括：B_VALID：缓冲区包含有效的数据。
B_DIRTY：缓冲区中的数据已经被修改，需要写回磁盘。
其他标志用于表示缓冲区的状态。
uint dev： 无符号整型，表示数据块所在的设备的设备号。
uint blockno： 无符号整型，表示数据块的块号。这是指在设备上的位置。
struct sleeplock lock： 一个睡眠锁（sleeping lock），用于对缓冲区进行加锁。睡眠锁是一种同步机制，它允许线程在访问被锁定资源时进入睡眠状态。
uint refcnt： 无符号整型，表示缓冲区的引用计数。引用计数用于跟踪有多少个指针引用了这个缓冲区。当引用计数为零时，缓冲区可以被释放。
struct buf *prev 和 struct buf *next： 指向双向链表中前一个和后一个缓冲区的指针。这些指针用于在缓冲区之间构建 LRU（Least Recently Used）缓存列表，以实现缓冲区的管理和替换。
struct buf *qnext： 指向缓冲区的下一个缓冲区，用于构建磁盘 I/O 队列。这个指针用于将缓冲区连接到待写回磁盘的队列中。
uchar data[BSIZE]： 字节数组，用于存储实际的数据块。BSIZE 是一个常量，表示数据块的大小。
2.1.2.初始化
1
2
3
4
5
6
7
8
9
//main.c

int
main(void)
{
...
  binit();         // buffer cache
  ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//bio.c

void
binit(void)
{
  struct buf *b;
  initlock(&bcache.lock, "bcache");
//PAGEBREAK!
  // Create linked list of buffers
  bcache.head.prev = &bcache.head;
  bcache.head.next = &bcache.hfead;
  for(b = bcache.buf; b < bcache.buf+NBUF; b++){
    b->next = bcache.head.next;
    b->prev = &bcache.head;
    initsleeplock(&b->lock, "buffer");
    bcache.head.next->prev = b;
    bcache.head.next = b;
  }
}
初始化就干两件事：
创建bcache自旋锁
将缓存块buf构成一个LRU双向链表
希望同学们不要把大部分精力陷入到代码的具体理解中，这没意义！
2.1.3.查找
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//bio.c

static struct buf*
bget(uint dev, uint blockno)
{
  struct buf *b;

  acquire(&bcache.lock);

  // Is the block already cached?
  for(b = bcache.head.next; b != &bcache.head; b = b->next){
    if(b->dev == dev && b->blockno == blockno){
      b->refcnt++;
      release(&bcache.lock);
      acquiresleep(&b->lock);
      return b;
    }
  }

  // Not cached; recycle an unused buffer.
  // Even if refcnt==0, B_DIRTY indicates a buffer is in use
  // because log.c has modified it but not yet committed it.
  for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
    if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) {
      b->dev = dev;
      b->blockno = blockno;
      b->flags = 0;
      b->refcnt = 1;
      release(&bcache.lock);
      acquiresleep(&b->lock);
      return b;
    }
  }
  panic("bget: no buffers");
}
根据设备号和盘块号查找块缓存。需要注意的是，盘块缓冲区是对磁盘空间进行了抽象，抽象成了一个连续的空间。而对磁盘缓冲块的查找也相当的粗暴，直接for循环遍历！
2.1.4.释放
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//bio.c

void
brelse(struct buf *b)
{
  if(!holdingsleep(&b->lock))
    panic("brelse");

  releasesleep(&b->lock);

  acquire(&bcache.lock);
  b->refcnt--;
  if (b->refcnt == 0) {
    // no one is waiting for it.
    b->next->prev = b->prev;
    b->prev->next = b->next;
    b->next = bcache.head.next;
    b->prev = &bcache.head;
    bcache.head.next->prev = b;
    bcache.head.next = b;
  }
  
  release(&bcache.lock);
}
//PAGEBREAK!
// Blank page.
释放的代码很简单，需要注意的就是进行b->refcnt--;操作。
后续还有很多函数，考虑到文章的篇幅，这里我们不再贴代码，会指明代码所在的文件，同学们自行查找即可！
2.1.5.盘块的读写
请注意，盘块的读写指的都是从缓存块和磁盘块直接交互的过程！
读写函数都定义在bio.c中，bread()先调用bget()查找对应的缓存块，然后调用iderw()将数据块从磁盘中写入缓存区中；而bwrite()就是调用iderw()将数据块写回磁盘。
1
2
3
4
5
6
7
8
9
10
11
struct buf*
bread(uint dev, uint blockno)
{
  struct buf *b;

  b = bget(dev, blockno);
  if((b->flags & B_VALID) == 0) {
    iderw(b);
  }
  return b;
}
这个读函数还是给大家贴出来，因为后面做实验要用到。
2.1.6.读入超级块
超级块的读入有点特殊（很正常，人家名字就已经很特殊了），有专门的在fs.c中的readsb()。
嘿嘿，要不同学猜猜，为什么要抽离出来，定义一个专门的函数来读这个盘块？
Ex5-2 请解释为什么要单独定义一个超级块的读入函数？
骚微提示一下，同学们想想这个盘块是在什么时候开始读的，哈哈哈，只能提示这么多了。
2.1.7.其他函数
还有几个比较重要的函数是bzero、balloc、bfree，具体干嘛的，同学们自行查阅相关资料。
2.2.索引节点操作
对索引节点的操作是抽象在对磁盘操作的基础之上的，具体有对索引节点管理的文件的读写，以及对节点自身的分配，删除和修改。
2.1.1.对索引节点自身的操作
主要的函数有iget、iupdate、idup、itrunc、stati、ilock、iunlock、iput，都在fs.c中。
iget()根据设备号dev和索引节点inum在索引节点缓存中查找，返回所匹配的索引节点缓存，或者分配一个空闲的索引节点缓存。
iupdate()将inode缓存的内容更新到磁盘的dinode上，最后写回磁盘中。
idup()增加索引节点缓存的引用计数，将其成员变量ref++即可。
itrunc()将索引节点管理的文件数据（直接块和间接块）都释放掉，每个盘块通过bfree()释放
stati()将索引节点缓存中的基本信息复制到stat结构体中并返回。
iput()减少索引节点缓存的引用计数，将其成员变量ref–，若小于0则itrunc。
2.1.2.对文件的操作
主要的函数有readi、bmap、writei，都在fs.c中。
readi()
用于从 inode 对应的磁盘文件的偏移 off 处，读入n个字节到 dst 指向的数据缓冲区。如果是设备文件(T_DEV)，则使用设备的读操作函数 devsw[ip->major]。read()完成读入操作,否则将执行磁盘文件的读入操作,该操作略微有些复杂。
磁盘文件需要逐个盘块读入数据,但首先要知道文件偏移量对应的物理盘块号是哪个,这是通过 bmap()完成的。
确定盘块号之后,将会调用前面讨论过的 bread()完成磁盘盘块的读人。由于 bread()将数据读入到块缓存中,因此还需要用 memmove()将数据复制到用户空间缓冲区。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int
readi(struct inode *ip, char *dst, uint off, uint n)
{
  uint tot, m;
  struct buf *bp;

  if(ip->type == T_DEV){
    if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
      return -1;
    return devsw[ip->major].read(ip, dst, n);
  }

  if(off > ip->size || off + n < off)
    return -1;
  if(off + n > ip->size)
    n = ip->size - off;

  for(tot=0; tot
    bp = bread(ip->dev, bmap(ip, off/BSIZE));
    m = min(n - tot, BSIZE - off%BSIZE);
    memmove(dst, bp->data + off%BSIZE, m);
    brelse(bp);
  }
  return n;
}
这个读函数还是给大家贴出来，因为后面做实验要用到。
bmap()
由于进程发出的文件读写操作使用的是字节偏移(转换成文件内部的逻辑盘块号bn)，而磁盘读写 bread()和 bwrite()使用的是物理盘块号，因此需要 bmap()将文件字节偏移对应的逻辑盘块号 bn 转换成物理盘块号。其转换过程需要借助索引节点的 dinode.addrs[]或 inode.addrs[]，并且需要考虑直接盘块和间接盘块。
如果对应的数据盘块不存在,则 bmap() 会调用 balloc() 分配一个空闲盘块,然后再修改索引，使得 ip->addrs[bn] 指向新分配的盘块；如果该偏移落人间接索引区,则可能还需要分配间接索引盘块,然后才能分配盘块号bn所对应的数据盘块并建立索引关系。
writei()
writei()需要逐个盘块写出数据,因为有块缓存的存在,其会先调用 bread()将磁盘盘块读入到块缓存，然后才是将数据复制到块缓存中，最后由 log_write()向日志系统写出。writei()也是借用 bmap()，通过查找 dinode.addrs[]完成文件偏移量到磁盘盘块号的转换。
如果是设备(T_DEV),则需要通过它自身的读函数 devsw[ip->major].read 完成。
2.3.目录操作
这一部分我们直接略过了，其主要函数都在fs.c中，如用于目录查找的函数：dirlookup、skipelem；用于创建和删除的函数：dirlink；用于文件定位的函数：namex、namei、nameiparent，其均在fs.c中实现。
2.4.文件操作
2.4.1.文件打开表初始化
在file.c中有fileinit的定义：
1
2
3
4
5
6
7
//file.c

void
fileinit(void)
{
  initlock(&ftable.lock, "ftable");
}
1
2
3
4
5
6
7
int
main(void)
{
...
  fileinit();      // file table
  ...
}
用于对系统中已打开文件列表ftable[]进行初始化，即初始化ftable.lock自旋锁
2.4.2.分配、关闭和复制
filealloc分配一个空闲的file对象
filedup当用户进程对某个文件描述符进行复制时，将引起对应的file对象引用次数加一
fileclose类似iput
filestat读取文件的元数据
2.4.3.文件读写操作
fileread()是通用的文件读操作函数，当文件的type为FD_PIPE将调用piperead()进行读，而为FD_INODE时，调用readi()进行读。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//file.c

int
fileread(struct file *f, char *addr, int n)
{
  int r;

  if(f->readable == 0)
    return -1;
  if(f->type == FD_PIPE)
    return piperead(f->pipe, addr, n);
  if(f->type == FD_INODE){
    ilock(f->ip);
    if((r = readi(f->ip, addr, f->off, n)) > 0)
      f->off += r;
    iunlock(f->ip);
    return r;
  }
  panic("fileread");
}
这个读函数还是给大家贴出来，因为后面做实验要用到。
filewrite()是通用的文件写操作函数，与读操作类似，也通过type分别调用具体的写函数。
2.5.系统调用
系统调用在Lab4中已经讲过，为此我们不再做过多赘述。本节课的系统调用的重点就是关注那些与文件操作相关的系统调用，如sys_open、sys_close、sys_read、sys_write、sys_mkdir、sys_mknod等
1
2
3
4
5
6
7
8
9
10
11
int
sys_read(void)
{
  struct file *f;
  int n;
  char *p;

  if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
    return -1;
  return fileread(f, p, n);
}
由于我们后面的实验会用到sys_read()，因此各位重点了解一下这个函数。
3.实验
文件系统的内容相当庞大，涉及的概念多吗，因此容易弄混是很常见的事。笔者在上理论课的时候也就在这块理解的不是特别丝滑，因为诸位应该秉着从全局到末端的策略，反复理解。
那么，我们现在结合一个简单的实验，帮助同学们从进程、文件系统（内存到外存）到设备驱动，这整个文件读的操作理解清楚。
3.1.gdbinit配置文件断点设置
1
2
3
4
5
6
7
layout src

break sysfile.c:sys_read
break file.c:fileread
break fs.c:readi
break bio.c:bread
break ide.c:iderw
3.2.编译xv6&启动gdb
1
2
make qume-nox-gdb
gdb
3.3.具体过程
Step1：在gdb中：通过info breakpoints检查断点
Step2：取消断点2,3,4,5
1
disable 2 3 4 5
Step3：continue
在gdb中输入一个c之后，程序执行到第一个断点位置，此时xv6终端呈现如下，但依旧不能输入。
在输入第二个c后，程序进入死循环，此时终端可以使用，即开中断已打开。
Step4：在xv6中输入cat README，即读README文件，并将内容输出到终端中。
此时，产生中断，截停在sys_read函数中
Step5：此时我们在gdb中恢复断点2,3,4,5
1
enable 2 3 4 5
然后，我们逐行调试，在第78行进入函数fileread中。
再接着逐行调试，会在107行进入readi函数中。
再继续，此时可能会读写多个缓存块。在470行进入bread函数中。
最后，通过设备驱动程序读取文件，在103行进入iderw函数中。
Step7：当你继续c后，直到xv6终端中出现这么一大段字符，就说明已经从磁盘中读取了一个块的内容。
1
2
3
4
5
6
7
8
9
10
11
12
NOTE: we have stopped maintaining the x86 version of xv6, and switched
our efforts to the RISC-V version
(https://github.com/mit-pdos/xv6-riscv.git)

xv6 is a re-implementation of Dennis Ritchie's and Ken Thompson's Unix
Version 6 (v6).  xv6 loosely follows the structure and style of v6,
but is implemented for a modern x86-based multiprocessor using ANSI C.

ACKNOWLEDGMENTS

xv6 is inspired by John Lions's Commentary on UNIX 6th Edition (Peer
to Peer Communications; ISBN: 1-57398-013-7; 1st edition (June 14
读者可以数一下，这一共多少个字符。如果是512个，那么恭喜，你数对了。字符数就是一个块的大小（512B）。
当然，读者再继续c几下还会出现更多的内容。我们直到README文件的大小为2286B，那么算下来，读者应该会执行5次c命令才算把这个文件读完。
Step8：做到这里，基本上这个小实验就算完成了。做完这些，读者应该大致对这个文件读的过程有了一个宏观的了解。至于这个后面，文件名是如何传递的，索引号是如何检索的，读者如果感兴趣，可以自行探索。
最后，我们再留一个小作业。我们刚带诸位了解了文件读的过程，那么文件写的执行过程是怎样的，请同学们自行实验探索。
Ex5-3 请分析echo “0” > /mydir/myfile3这条命令的执行过程，要求对执行过程经过的几个关键的写函数进行分析和截图，并绘制如下，关于写过程的流程图。



ChatGPT 打开潘多拉魔盒，行业壁垒逐步瓦解
2023-10-06T14:43:39.000Z
前言
作为一名非专精于NLP算法的同学，去详细论述ChatGPT的底层原理是很困难的。但好在最近为了搭建一个轻量化的RGM(Robotic Grasp Model)，接触到了一部分的图像注意力机制。想着CV、NLP本是一家亲，更何况ChatGPT的前世还可以追溯到《Attention is all you need》，为此斗胆写了一篇《ChatGPT 打开潘多拉魔盒，行业壁垒逐步瓦解》的爽文（对！爽文，让你轻松拿捏这个庞然大物），仅供同学们交流学习！
在本文中你将会了解到一些人工智能的前置知识、ChatGPT的概念、Transformer的基本原理、还有我关于ChatGPT的见解~
人工智能的前置知识
ChatGPT作为一个人工智能LLM (Large Language Model) 大语言模型，细盘之前，我们先了解一下一些基本的人工智能知识。
机器学习
机器学习，作为计算机专业研一同学必修的一门课程，足以体现其在人工智能领域举足轻重的地位。虽然现在学术前沿领域都在深度学习这条赛道上一发不可收拾，但是搞深度学习前还是得了解一些机器学习哦。smooth_l1_loss、sigmoid都会吧，同学？这些在用pytorch搞深度学习时常用的损失函数、激活函数可都是机器学习的知识哦。撇开HMM(Hidden Markov Model)、CRF(Conditional Random Field)等一些集成方法不谈，无论是决策树、K-means聚类、支持向量机、梯度提升树还是朴素贝叶斯，这些经典的机器学习模型也都是一些工业应用领域的常青树哦！（别问我为什么，去问度娘~）。
讲了一大堆机器学习的重要性，都还没说这到底是个啥。来，上概念。
机器学习(Machine Learning，ML)是指从有限的观测数据中学习(或“猜测”)出具有一般性的规律，并将这些规律应用到未观测数据样本上的方法。主要研究内容是学习算法。基本流程是基于数据产生模型，利用模型预测输出。目标是让模型有较好泛化能力。
什么？太抽象了，不好理解？
举一个经典的例子，我们挑西瓜的时候是如何判断一个西瓜是否成熟的呢？每个人一开始都是不会挑选的，但是随着我们耳濡目染，看了很多挑西瓜能手是怎么做的，发现可以通过西瓜的颜色，大小，产地，纹路，敲击声等等因素来判断，那么这个就是一个学习的过程。
那么人工智能、机器学习以及深度学习的关系是什么呢？或者说这个家族的族谱应该怎么画呢？
别急，一张图搞明白他们的关系。
不知道你有没发现，这些方法的进化过程就是人类专精于摸鱼的过程。从以前纯人工作业到现在半人工、甚至全智能作业，从需要繁琐的数据预处理和客制化的特征提取手段的机器学习过渡到让机器自己去学特征的深度学习，从有监督任务过渡到自监督任务、多阶段深度学习算法过渡到端到端的算法，从手动搭建合适的深度网络模型到NAS(Neural Architecture Search) ……
哇，果然人类摸鱼的潜能是无限的~
参数 / 权重：
前文我们说过，ChatGPT是一个LLM。对于任何模型而言，无非就两种表示形式，即y=f(x)型和P(y|x)型。前者是确定性模型(也称非概率模型)，后者是概率模型。无非是哪一种，其中不可或缺的就是参数。
我们举几个例子说明参数的重要性。
如y=f(x)模型中最简单的y=wx+b。先不引入任何机器学习的概念，这就是我们小学学的二元一次方程，只不过我们当时w和b往往是给定的，我们最关注的就是如何解得x和y。但在机器学习中，往往x是给定的，需要我们求解出(拟合出)w和b的值。按照我们小学课本里教的，w就是斜率，b就是截距。说到这里不知道你意识到没，这就是知识啊！我们知道了其特定的含义就能在一个二维平面中可视化这条直线，机器知道了就能做一个简单的yes和no的回答。又如P(y|x)模型中的

无论是初始概率分布，状态转移矩阵还是观测矩阵都是HMM主要的参数来源啊，而这三个部分也正是HMM的核心。
而我们所津津乐道的ChatGPT就是一个除了参数还是参数的大怪物，其拥有这可怕的1750亿的参数规模(本来还想说一下其所需的浮点运算次数的，emmm，找了半天没找到)。要训练一个千亿参数量级的模型，所需要支持的算力那也应该不是我们能设想的。再加上human in the loop的机制，哇，烧钱的嘞。
过拟合、欠拟合与模型退化
如果你已经把所有的菜都备齐了，炒菜的设备也上齐了，那么接下来就应该是生火开炒了——这里具体如何炒，先加盐还是先放醋针对不同的菜应该有不同的策略，正如机器学习针对不同的任务需要设计不同的特征提取策略一样，为此这里我们还是用深度学习的黑箱模型来说事(其实主要是我不会炒菜……)。最理想的状态肯定就是炒完后菜的口感最能满足你挑剔的嘴，但是事情往往并不会向我们所期待的那样，炒焦了和没炒熟都是很常见的情况。模型的训练也正如这个做菜的过程，稍不留神就过拟、欠拟。但这还是好的，最崩溃的情况是你拿一只大锅发现怎么样也炒不出小锅的味道，而且每次用大锅颠勺都还让你累的够呛。这也就是模型的退化现象，好像这就是自然界的规律，过犹而不及。正如Google的PaLM(5400亿参数)，微软和英伟达合作的MT-NLG(5300亿参数)跟ChatGPT比起来都差点意思。
人类反馈强化学习（RLHF）
人类反馈强化学习，一听到这个名词是不是就感觉特别高大尚。害其实也没什么，就是智能还不够智能，还需要人类从中插一脚。RLHF最本质的特点就是human in the loop，也就是人在回路。当然认真看过流浪地球2的同学们应该还是不太陌生的。
RLHF 主要包括三个步骤：
使用监督学习训练语言模型；
根据人类偏好收集比较数据并训练奖励模型；
使用强化学习针对奖励模型优化语言模型。
它使模型能够通过从人类获取反馈，从而不断改进自身学习技能，从而有效地适应实际环境。都说到这个份上了，养过猫猫狗狗的同学应该就能get到了，你驯化它的过程就是RLHF。
神经网络
神经网络，都以“神经”这两个字命名了，那肯定就和人的神经元系统相当类似咯。无论是你眼镜接收到的视觉信息、皮肤感知到的触觉信息还是耳朵获取的听觉信息都需要从感受器通过电信号(和化学信号)的形式传导到神经中枢，而这就跟输入向量在神经网络的传导过程十分类似。对于冲动传输链路上的每一个神经元扮演了一个节流阀的作用(激活还是抑制)，类似于神经网络的前向传播过程，每一层的每个节点都能决定通过其这条沿线的权重大小。
神经网络的结构正如图五所示，最基本形式的人工神经网络有三层神经元。信息从一层神经元流向另一层，就像在人脑中一样：
输入层：数据进入系统的入口点
隐藏层：处理信息的地方
输出层：系统根据数据决定如何继续操作的位置
ChatGPT 的概念
哇，终于写到正题了，eight hours later……
GPT 对应的是三个单词：Generative，Pre-Training，Transformer。
Generative：生成式，比较好理解，通过学习历史数据，来生成全新的数据。请注意，这里是全新的哦！不过全新也要看你怎么理解，如果想说它能所回答你的每一个字是不是全新的，那肯定是不现实的。这种新应该是一种全新的、带有人类语言逻辑的语句组合。更直观地去理解Generative，那肯定就得提及DALL-E(emmm，这家伙也是OpenAI的)，这个东西能够根据一段场景描述性的文字来生成一张与之对应的、全新的图片(类似于上面对全新概念的理解，你总不能要0-255的像素值是全新的吧)。从这个角度去理解ChatGPT，那它就一个词生成器啊。例如ChatGPT已经生成了“今天晚上我们去打”，那么下一个生成的字/词就有可能是“台球”、“篮球”、“羽毛球”、“乒乓球”、“游戏”，它的生成逻辑就是从这些候选的单元中选出一个概率最大值。如果你使用过ChatGPT，并且详细观察过它回答你的方式，你可能会对「逐字」这个概念有更深的感触。
Pre-Training：预训练，顾名思义就是预先训练的意思，说白了就是一个特征提取的过程。“预训练“方法的诞生是出于这样的现实：标注资源稀缺而无标注资源丰富(某种特殊的任务只存在非常少量的相关训练数据，以至于模型不能从中学习总结到有用的规律)。
举个简单的例子，现在有一个对英语一窍不通的同学和一个英语基础尚佳的同学同时去完成翻译并总结一篇英语技术文章的任务。对前者来说就需要先学会英文 26 个字母，进而学会单词语法等，再去了解这篇文章相关的技术，最后才能去完成我们指派的任务。但是对后者来做这个任务就相对简单的多，他只需要去大致了解一下这篇文章所涉及到的技术，便能很好的总结出来。
这就是预训练，先把一些通用能力提前训练出来。人工智能本身就是一个不断训练参数的过程，如果我们可以提前把通用能力相关的参数提前训练好，那么在一些特殊的场景，发现通用能力不能完全适配时，只做简单的参数微调即可，这样做大幅减少了每个独立训练预测任务的计算成本。反映在具体模型上就是：
模型参数不再是随机初始化，而是通过一些任务(如语言模型)进行预训练
将训练任务拆解成共性学习和特性学习两个步骤
Transformer：这是 ChatGPT 的灵魂，它是一个神经网络架构。后文再进行详细的说明。
以上就是 ChatGPT 的基本概念，结合起来就是一个采用了预训练和强化学习策略的生成式神经网络模型，它能够对人类的对话进行模拟。
Transformer基本知识
因为介绍Transformer的文章很多啊，在此我就直接搬运王正学长在《让非算法同学也能了解 ChatGPT 等相关大模型 》文章中论述的了。别看Transformer(变形金刚，很漫威)这个名字很玄乎，其实大致也就三个主要部分：Embedding、Self-Attention以及Softmax。
Embedding很好理解，就是要把输入的自然语言转换成机器能理解的向量表示。当然为了充分利用语言的序列特性，因此还需要加入额外的位置编码。
Self-Attention也就是我们常说的自注意力机制，emmm有点复杂，好像一句话不怎么讲的清楚，其实也就是"What do I care most about myself"。
Softmax这个好理解，直接上公式：

这东西的本质就像我上面举的“今天晚上我们去打”的例子，就是选出一个最大概率呗。
第一步：embedding
embedding 的过程可以简单的理解为向量化。因为输入是一个个的词(token)，那需要把它映射成一个向量，embedding就是给定任何一个词，用一个向量来表示它。
在 embedding 的过程中，每个 token 都用一个单层神经网络转化为长度为 768(对于GPT-2)或 12288(对于ChatGPT的GPT-3)的 embedding 向量。
同时，模块中还有一个“辅助通路”(secondary pathway)，用于将 token 的整数位置转化为 embedding 向量。最后，将 token 值和 token 位置的 embedding 向量加在一起，生成最终的 embedding 向量序列。
那么为什么要将 token 值和 token 位置的 embedding 向量相加呢？只是尝试了各种不同的方法后发现这种方法似乎可行，而且神经网络的本身也认为，只要初始设置“大致正确”，通过足够的训练，通常算法可以自动调整细节。
以字符串“湖人”为例，在 gpt-2 中它可以将其转化为一系列长度为 768 的 embedding 向量，其中包括从每个 token 的值和位置中提取的信息。
第一张图中就是 token embedding，纵向一列代表一个向量，可以看到最先排列的是“湖”所代表的向量，然后是“人”所代表的向量。第二张图是位置的 embedding，代表着这两个字的位置信息。将这两两个 embedding 相加得到了最终的 embedding 序列。
第二步：Attention
Attention 是整个 transformer 的主要部分，其内部结构是非常复杂的，我作为一名非专业人士，无法面面俱到的将其中的细节完全解释清楚，因此只能把它的核心能力简单叙述一二。
在进行 embedding 之后，需要对一系列的“注意力块”进行数据操作(gpt3 中有 96 个注意力块)，而每个“注意力块”中都有一组 attention heads，每个 attention head 都独立地作用于 embedding 向量中不同值的块。
attention head 的作用就是对历史的 token 序列进行回顾，这里的历史 token 序列就是已经生成的文本，之后将这些信息进行打包，以便找到下一个 token。稍微具体的来说，attention head 的作用是重新组合与不同 token 相关的 embedding 向量的块，并赋予一定的权重。
举个例子：
用 ChatGPT 翻译句子“蚂蚁集团”到“ant group”举例，首先进行上一步 embedding 操作，将句子向量化并吸收句子位置信息，得到一个句子的初始向量组。
由于样本每个句子长短不同，所以每个句子都会是一个 512 x 512 的矩阵，如果长度不够就用 0 来代替。这样在训练时，无论多长的句子，都可以用一个同样规模的矩阵来表示。当然 512 是超参，可以在训练前调整大小。
接着，用每个字的初始向量分别乘以三个随机初始的矩阵W^Q,W^K,W^V分别得到三个量Qx，Kx，Vx，这样就得到了三个量：Qx，Kx，Vx，比如用“蚂”这个字举例：
然后，计算每个单词的 Attention 数值，比如“蚂”字的 Attention 值就是用“蚂”字的 Q蚂Q蚂 分别乘以句子中其他单词的 K 值，两个矩阵相乘的数学含义就是衡量两个矩阵的相似度。
第三步：将向量转为概率
继续用上面翻译的例子：用计算出的每个单词的 Attention 值，通过一个 SoftMax 转换(这里不必关注是怎么转换的)，计算出它跟每个单词的权重，这个权重比例所有加在一起要等于 1。再用每个权重乘以相对应的 V 值。所有乘积相加得到这个 Attention 值。
这个 Attention 数值就是除了“蚂”字自有信息和位置信息以外，成功的得到了这个句子中每个单词的相关度信息。
在计算 Attention 之后，每个单词根据语义关系被打入了新的高维空间，这就是 Self-Attention(自注意力机制)。
但在 transformer 里，并不是代入了一个空间，而是代入了多个高维空间，叫做 Multi-Head Attention (多头注意力机制)。将高维空间引入模型训练的主要原因是它在训练时表现出很好的效果，这是人工智能科研论文的一个常见特点，研究人员凭借着极高的科研素养和敏感性，发现一些方向，并通过测试证明其有效性，但不一定有完美的理论支持。这为后续研究者提供了进一步完善的余地。
事实证明，如何提升Attention(Q，K，V)效率是 transformer 领域迭代最快的部分。
这就是 transformer 的大致原理，有一些细节我个人也没有深入研究，有兴趣的人可以自行去搜索。
！！！开始夹带私货！！！
正如王正学长文章中所提到的——“如何提升Attention(Q，K，V)效率是 transformer 领域迭代最快的部分”，我是真的深有同感！之前还没那么多，但真的就是自己开始去跑代码的时候就知道，Attention是有多慢！！！特别是，我做的轻量化网络，就是那种除Self-Attention之外的部分占三分之一，Self-Attention占三分之二，参数量如此，GFLOPs更是如此……
既然都说到这里了，那我们也来倒腾一下CV领域的Attention呗。
将Self-Attention机制引入CV领域相当重要的一篇文献就是《Non-local Neural Networks》。与对文本进行的Transformer类似，只不过由对文本的Embedding操作不再需要了，转而需要对完整的图像进行切块处理和对每一个小块进行位置编码(传统的CNN本来含有位置信息，因此没必要添加额外的位置信息)，接下来的操作和NLP中的Self-Attention大差不差了。
如图所示的Self-Attention，这可怕的参数量……
后面还有一篇《CCNet: Criss-Cross Attention for Semantic Segmentation》是对NLNet的优化。强烈推荐看一下CCNet–于”阡陌交通”处超越恺明Non-local 这篇博客，写的也是相当好(主要是标题挺吸引^_^)。
为什么说ChatGPT打开了潘多拉魔盒
前置内容说得太多了，终于开始说和标题有关的内容了，再拖拖都成标题党了。
不过在谈这个话题之前我还是想多说两句。要不是得完成课题作业，我也不至于议论这样的话题，确实以一个本科生的角度去观望整个行业确实有点管中窥豹。不过气氛都烘托到这了，放弃不再执笔也很难受啊！！权当给未来的我剖析当下精神状态的样本吧……
先引用几位大佬的话来镇镇场。
微软创始人比尔盖茨曾表示：“ChatGPT的诞生丝毫不亚于个人电脑的诞生。”英伟达创始人黄仁勋也表示：“ChatGPT只是起点，我们正处于AI的iPhone时刻。”谷歌前AI团队成员、deeplearning.ai创始人吴恩达曾在推特上发表言论，认为ChatGPT等大型语言模型是“人工智能领域最为激动人心的进展之一。”
之所以说ChatGPT打开了潘多拉魔盒是因为其影响足以推动各行各业的变革。
首先找我来说说作为一个学生，ChatGPT到底给我带来哪些影响。
ChatGPT代写课程作业(本来这个课程作业就想用它快速解决的)啥的就不多赘述了，不符合核心价值观，更多的想谈一谈ChatGPT对我知识检索习惯的改变。相信大学数学生跟我一样，在没有ChatGPT之前，我们都基于一个问题打开度娘/Google/Bing，然后输出问题的描述性语句，在通过关键词检索的词条中去检索自己需要的答案。正如我描述的一样，这一套流程下来是相当繁琐的，这意味着知识的检索成本相当之高。从这里就会给绝大部人形成一种习惯，或者是一种刻板印象：检索知识的过程是比较繁琐的，不能做到对陌生知识一遇一检。然后我们细化对知识的分类，很多陌生知识的复杂程度是不一样的，比如说你在冲浪时遇到一个陌生概念“NAS”，如果你只是想知道这个名词是个什么东西，那这个陌生知识就很轻量，因此你期待所消耗在这个陌生知识上的时间成本就应该很小，但是在ChatGPT出现之前，你还是得经历上面那个过程。但其实这么轻量的搜索，很多检索系统也能直接在第一个词条给到你想要的答案，但真正迈不出一遇一检的原因其实是你大脑对这个检索过程的定义。
基于ChatGPT的内容式问答检索，这些轻量的知识检索过程完全可以以极低的时间成本实现，真正能够做到一遇一检。这虽然不能将你的知识网络的深度延伸到一个新的层次，但是拓展你知识网络的阔度是完全没有任何问题的。
由于我大二暑假做过一个“基于2D虚拟人语音驱动”的项目，通过现有的深度学习技术已经完全可以实现模仿一个虚拟的你出来了，再配合上语音克隆的技术和ChatGPT作为对话的中转站。一个在样貌、声线、甚至是语气与微表情都和你如出一辙的虚拟人完全可以应用到生产生活的方方面面。未来注定是元宇宙的时代！
而ChatGPT对一些传统行业的打击也同样是致命的，如翻译(包括同声翻译)、在线客服等，甚至我在想，ChatGPT结合具身智能在不远的将来能否替代掉那些以时间量度作为价值换算的行业。
那么说回程序员，本来这个职业还是有蛮高的技术门槛的，一门编程语言的学习，以及其周边技术的掌握确实都是需要时间花费的。而矛盾的是，一般的人想要用到编程这项技术往往只是希望用它来减轻一些重复工作，他们是没有强烈的通过编程生产变现需求的。因此对于他们来说编程只是工具不是目的，如果可以以其他方式达到他们的目的，这个工具是可有可无的。ChatGPT的出现，完全满足了这一需求。一个脚本、一个前端界面、一个数据处理分析程序，这种轻量的编程需求，ChatGPT完全可以胜任。因此无形之中，编程好像也变得不再是程序员的专利，行业的门槛无形之中就被连根拔起。
当然对于程序员来说，这个工具的出现也是利好的。只是从我的经历看来，我完全可以将重心全放在业务功能的如何实现上，而不用太多地去考虑如何用代码实现。现在基于ChatGPT的代码补全工具也层出不穷，虽然我体验下来也还是感觉没多大作用，但我们也还是需要给这项技术足够的包容，毕竟它刚出来还不到一年。
写到这里，实在江郎才尽了！Happy Ending~
参考文章/文献
让非算法同学也能了解 ChatGPT 等相关大模型 
教你深入理解“预训练” 
Attention Is All You Need 
Transformer模型详解（图解最完整版）