一、并查集学习一：
1、寻找根节点（两种）
int find(int x )
{
if(x!=city[x])
city[x]=find(city[x]);
return city[x];
}int find(int x)
{
return fa[x]==x ? x : fa[x]=find(fa[x]);
}2、合并不同集合
void merge(int x,int y)
{
int a=find(x);
int b=find(y);
if(a!=b)
city[a]=b;
}3、例题
题目描述
某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？
输入
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。
注意:两个城市之间可以有多条道路相通,也就是说
3 3
1 2
1 2
2 1
这种输入也是合法的
当N为0时，输入结束，该用例不被处理。
输出
对每个测试用例，在1行里输出最少还需要建设的道路数目。
样例输入
4 2 1 3 4 3 3 3 1 2 1 3 2 3 5 2 1 2 3 5 999 0 0
样例输出
1 0 2 998
实现代码
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
int city[N];
int find(int x )
{
if(x!=city[x])
city[x]=find(city[x]);
return city[x];
}
void merge(int x,int y)
{
int a=find(x);
int b=find(y);
if(a!=b)
city[a]=b;
}
int main()
{
int n,m;
while(cin>>n>>m&&n)
{
for(int i=1;i<=n;i++)
city[i]=i;
int x,y;
for(int i=0;i<m;i++)
{
cin>>x>>y;
merge(x,y);
}
int ans=0;
for(int i=1;i<=n;i++)
{
if(city[i]==i)
ans++;
}
cout<<ans-1<<endl;
}
return 0;
}
二、最小生成树学习一（kruskal算法）
1、理解
Kruskal算法将一个连通块当做一个集合。Kruskal首先将所有的边按从小到大顺序排序（一般使用快排），并认为每一个点都是孤立的，分属于n个独立的集合。然后按顺序枚举每一条边。如果这条边连接着两个不同的集合，那么就把这条边加入最小生成树，这两个不同的集合就合并成了一个集合；如果这条边连接的两个点属于同一集合，就跳过。直到选取了n-1条边为止。
Kruskal算法每次都选择一条最小的，且能合并两个不同集合的边，一张n个点的图总共选取n-1次边。因为每次我们选的都是最小的边，所以最后的生成树一定是最小生成树。每次我们选的边都能够合并两个集合，最后n个点一定会合并成一个集合。通过这样的贪心策略，Kruskal算法就能得到一棵有n-1条边，连接着n个点的最小生成树。
（引用自：https://blog.csdn.net/qq_43619271/article/details/109091314）
2、例题
题目描述
某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。
输入
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。
输出
对每个测试用例，在1行里输出最小的公路总长度。
样例输入
3 1 2 1 1 3 2 2 3 4 4 1 2 1 1 3 4 1 4 1 2 3 3 2 4 2 3 4 5 0
样例输出
3 5
实现代码
#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
struct city
{
int x,y,z;
}q[N];
int fa[N];
int n,u,v,w;
long long ans;
bool cmp(city a, city b)
{
return a.z<b.z;
}
int find(int x)
{
return fa[x]==x ? x : fa[x]=find(fa[x]);
}
int main()
{
while(cin>>n&&n)
{
int sum=0;
int m=n*(n-1)/2;
for(int i=1;i<=m;i++)
cin>>q[i].x>>q[i].y>>q[i].z;
for(int i=0;i<=n;i++)
fa[i]=i;
sort(q+1,q+1+n,cmp);
for(int i=1;i<=m;i++)
{
int x=find(q[i].x);
int y=find(q[i].y);
if(x==y)
continue;
fa[y]=x;
sum+=q[i].z;
}
cout<<sum<<endl;
}
return 0;
}
三、链表
1、单链表
（1）、概念
链表是一种物理存储结构上非连续、非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
注：用一维数组模拟链表时，数组下标并不代表链表中的位置，用指针表示，从链表中删除的元素也依然再数组中，只是不再有next链接
（2）、用一维数组实现
存储
head存储链表头（表头所指单元格，指向第一个元素）
e[ ]存储节点的值，
ne[ ]存储节点的next指针，
idx表示当前用到了哪个节点（数组用到第几个）
int head, e[N], ne[N], idx;初始化
// 初始化
void init()
{
head = -1;
idx = 0;
}将x插入头节点
// 在链表头插入一个数a
void insert(int a)
{
//idx指向本数据存储位置
e[idx] = a;//存储数据
ne[idx] = head;//本数据指向原来的开头
head = idx;//将开头更新到本数据
idx ++ ;//idx更新到下一个存储位置
}将x插入k节点后面
void add(int k, int x)
{
e[idx] = x;
ne[idx] = ne[k];//将本数据指向k的下一个
ne[k] = idx;//将k指向本数据
idx++;
}将下标是k的点后面的点删去
void remove(int k)
{
ne[k] = ne[ne[k]];//用k数据的下一位替代下一个数据的下一位
}将头结点删除，需要保证头结点存在
void remove()
{
head = ne[head];
}完整代码示意
#include<bits/stdc++.h>
using namespace std;
const int N = 1e7+10;
int head, idx,e[N],ne[N];
void init()
{
head = -1;
idx = 0;
}
void add_head(int x)
{
e[idx]=x,ne[idx]=head,head=idx++;
}
void add(int k, int x)
{
e[idx]=x,ne[idx]=ne[k],ne[k]=idx++;
}
void remove(int k)
{
ne[k]=ne[ne[k]];
}
int main()
{
int M;
scanf("%d",&M);
init();
while(M--)
{
int k,x;
char op;
cin>>op;
if (op == 'H')
{
cin >> x;
add_head(x);
}
else if (op == 'D')
{
cin >> k;
if (!k) head = ne[head];
else remove(k - 1);
}
else
{
cin >> k >> x;
add(k - 1, x);
}
}
for (int i = head; i != -1; i = ne[i])
cout << e[i] << ' ';
return 0;
}2、双链表
存储
int e[N], l[N], r[N], idx;初始化
让头节点为0；尾节点为1
void init()
{
r[0]=1,l[1]=0,idx=2;
}
在下标是k的点的右边插入x
void insert(int k, int x)
{
e[idx]=x;
r[idx]=r[k];
l[idx]=k;
l[r[k]]=idx;
r[k]=idx++;
}
cin >> k >> x;
insert(k + 1, x);//因为idx从2开始，所以第k个点idx=k+1
//若想在左边插入
//insert(l[k + 1], x);
//l[k + 1]就是在k的左边节点的右边插入，即在k的左边插入删除第k个点
void remove(int k)
{
r[l[k]]=r[k];
l[r[k]]=l[k];
}插入头节点
insert(0, x);//即k=0插入尾节点
insert(l[1], x);//即在尾节点左边插入x
四、栈
1、初始化
// tt表示栈顶
int stk[N], tt = 0;2、栈顶插入
stk[++tt] = x;3、栈顶弹出
tt -- ;4、判断栈是否为空
if (tt > 0)//>0为不空，否则为空
{
}5、返回栈顶的值
stk[tt];
五、普通队列
1、初始化
//hh表示队头 tt表示队尾
int q[N], hh = 0, tt = -1;2、队尾插入
q[ ++ tt] = x;3、队头弹出
hh ++ ;4、判断队列是否为空，如果 hh <= tt，则表示不为空
if (hh < tt)
{
}5、返回队头的值
q[hh];
六、单调栈
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10;
int stk[N],tt=0;
int main()
{
int n;
cin>>n;
while(n--)
{
int x;
cin>>x;
while(stk[tt]>=x) tt--;
if(tt==0) cout<<-1<<' ';
else cout<<stk[tt]<<' ';
stk[++tt]=x;
}
return 0;
}
七、单调队列
#include <iostream>
using namespace std;
const int N = 1000100;
//单调队列一般用双端队列保证其单调性
int a[N], q[N], n, k;
//队头和队尾，在队尾插入，队头获取
int front = 0, tail = -1;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
//先找每个窗口的最小值
for (int i = 0; i < n; i++) {
//如果当前队头在数组的下标小于当前窗口的最小下标，这个窗口就不包含这个元素了那么无论如何都要剔除队头这个元素
//所以要在队头删除这个元素
if (front <= tail && i - k + 1 > q[front]) front++;
//保证单调性，在队尾删除（为什么要在队尾删除，简单来说在队头删除不能保证单调
//比如-3 5为当前队列，当前的元素为3，如果在队头操作，那么按照a[i] <= a[q[front]，有3 > -3，因此不做删除操作
//但是接下来就出现问题了，3就要入队了。此时队列就是-3 5 3，不符合单调性了！
//但如果在队尾操作，按照a[i] <= a[q[tail]，有3 < 5，就要让5出队
//之后3入队，队列就是-3 3，满足单调性
while (front <= tail && a[i] <= a[q[tail]]) tail--;
q[++tail] = i;
//队头为窗口的最小值
if (i >= k - 1) printf("%d ", a[q[front]]);
}
printf("\n");
//这次找最大值，同理
front = 0, tail = -1;
for (int i = 0; i < n; i++) {
if (front <= tail && i - k + 1 > q[front]) front++;
while (front <= tail && a[i] >= a[q[tail]]) tail--;
q[++tail] = i;
if (i >= k - 1) printf("%d ", a[q[front]]);
}
}八、KMP
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10;
// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
int n,m;
char p[N],s[N];
int ne[N];
int main()
{
cin>>n>>p+1>>m>>s+1;
//求模式串的Next数组：
for(int i=2,j=0;i<=n;i++)
{
while(j&&p[i]!=p[j+1]) j=ne[j];
if(p[i]==p[j+1]) j++;
ne[i]=j;
}
匹配
for(int i=1,j=0;i<=m;i++)
{
while(j&&s[i]!=p[j+1]) j=ne[j];
if(s[i]==p[j+1]) j++;
if(j==n)
{
printf("%d ",i-n);
j=ne[j];
}
}
return 0;
}