并查集
#include<iostream>
using namespace std;
const int N=xxx;
int p[N];
int find(int x)//find(x)并查集模板函数
{
if(p[x]!=x) p[x]=find(p[x]);
return p[x];
}
int main()
{
int n=0,m=0,a=0,b=0;
scanf("%d %d",&n,&m);
while(n--) p[n]=n;//p[x]进行处理
while(m--)
{
scanf("%d %d",&a,&b);
p[find(a)]=find(b);//找到两个的父节点，再让他们相连
}
int q=0;
scanf("%d",&q);
while(q--)
{
scanf("%d %d",&a,&b);
puts(find(a)==find(b)?"Yes":"No");
}
return 0;
}
试题acwing1249
KMP
用KMP求next函数
void calc_next()//next数组存储的是最长相同前后缀的长度
{
next[1]=0;
for(int i=2,j=0;i<=n;i++)
{
while(j>0&&a[i]!=a[j+1]) j=next[j];
if(a[i]==a[j+1]) j++;
next[i]=j;
}
}
求f数组：
void calc_f()
{
for(int i=2,j=0;i<=n;i++)
{
while(j>0&&(j==n&&b[i]!=a[j+1])) j=next[j];
if(b[i]==a[j+1]) k++;
f[i]=j;
}
}
#include <iostream>
#include <cstring>
using namespace std;
const int N = 100010;
int ne[N];
int main()
{
string s, p;
cin >> s >> p;
int n = s.size(), m = p.size();
// 计算 ne 数组
for (int i = 2, j = 0; i <= m; i ++ )
{
while (j && p[i - 1] != p[j]) j = ne[j];
if (p[i - 1] == p[j]) j ++ ;
ne[i] = j;
}
// 在文本串中匹配模式串
for (int i = 1, j = 0; i <= n; i ++ )
{
while (j && s[i - 1] != p[j]) j = ne[j];
if (s[i - 1] == p[j]) j ++ ;
if (j == m)
{
// 匹配成功后的逻辑
cout << "Matched at position " << i - m << endl;
j = ne[j];
}
}
return 0;
}
在输入样例为 “hello, world!” 和 “world” 的情况下，上述代码的输出为：
Matched at position 7
i%(i-p[i])==0 这个条件判断 i-p[i] 是否能够整除 i。如果能够整除，说明在位置 i 之前的子串可以被分成若干个长度为 i-p[i] 的子串。
i/(i-p[i])>1 这个条件判断分成的子串个数是否大于 1。如果大于 1，说明存在循环节。
综上所述，当这两个条件同时满足时，说明在位置 i 之前的子串存在循环节。循环节的长度为 i-p[i]，循环次数为 i/(i-p[i])。
Trie树
const int N = 1000050;
int trie[N][26];
int cnt[N];
int id;
// 插入字符串s到Trie树中
void insert(string s)
{
int p = 0; // 初始化指针p为0
for (int i = 0; i < s.size(); i++) // 遍历字符串s中的每个字符
{
int x = s[i] - 'a'; // 计算字符在字母表中的位置
if (trie[p][x] == 0) trie[p][x] = ++id; // 如果不存在从节点p到其子节点的边，则创建一条新边并更新节点编号
p = trie[p][x]; // 将指针移动到下一个子节点
}
cnt[p]++; // 增加最终节点处的计数值
}
// 在Trie树中查找字符串s
int find(string s)
{
int p = 0; // 初始化指针p为0
for (int i = 0; i < s.size(); i++) // 遍历字符串s中的每个字符
{
int x = s[i] - 'a'; // 计算字符在字母表中的位置
if (trie[p][x] == 0) return 0; // 如果不存在从节点p到其子节点的边，则返回0表示未找到字符串
p = trie[p][x]; // 将指针移动到下一个子节点
}
return cnt[p]; // 返回最终节点处的计数值
}
dfs
void dfs(int step){
//detect the border
for(i=1;i<=n;i++){
if(){//judge whether used
//the current operation
dfs(step+1) //go into the next step
//backup
}
}
//return to the before step
}
举个例子:1-9可以组成多少xxx+xxx=xxx的式子？
#include<stdio.h>
int a[10],book[10],total;
void dfs(int step)
{
int i;
if(step==10){//restriction
if(a[1]*100+a[2]*10+a[3]+a[4]*100+a[5]*10+a[6]==a[7]*100+a[8]*10+a[9]){
total++;
printf("%d%d%d+%d%d%d=%d%d%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);//run out every method
}
return;
}
for(int i=1;i<=9;i++)
{
if(book[i]==0)//begin:the important part
{
a[step]=i;
book[i]=1;
dfs(step+1);
book[i]=0;
}//end:the important part
}
return;
}
int main(){
dfs(1); //dfs函数的开始
printf("%d",total/2);
return 0;
}
bfs
1.将起点入队
2.入新出旧
例题：求迷宫步数
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
// 基本参数
const int N = 101;
int a[N][N], b[N][N];
// 结构点参数
struct point
{
int x;
int y;
int step;
};
// 队列和操作相关设定
queue<point> r;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
int main()
{
int n, m, startx, starty, p, q; // n行,m列
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
{
scanf("%d", &a[i][j]);
}
scanf("%d%d%d%d", &startx, &starty, &p, &q);
// BFS
point start;
start.x = startx;
start.y = starty;
start.step = 0;
r.push(start);
b[startx][starty] = 1; // 表示已经走过
int flag = 0;
while (!r.empty()) // 队列是否为空
{
int x = r.front().x, y = r.front().y; /*取出队首元素*/
if (x == p && y == q)
{
flag = 1;
printf("%d", r.front().step);
break;
}
for (int k = 0; k < 4; k++)
{
int tx = x + dx[k], ty = y + dy[k];
if (a[tx][ty] == 1 && b[tx][ty] == 0) // 为空地且未访问过
{
point temp;
temp.x = tx;
temp.y = ty;
temp.step = r.front().step + 1;
r.push(temp);
b[tx][ty] = 1;
}
}
r.pop(); // 拓展结束，将队首出队
}
if (flag == 0)
printf("no answer\n");
system("pause");
return 0;
}
/*
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
*/
补充一下：
1.输入时从1开始的好处是可以让数据处理时按照题意直接进行，比如让求第二个数到第八个数的和九可以直接for(int i=2;i<=8;i++)了
2.queue的数据类型注意一下，这一次是struct,下一次可能就是pair了。
dijkstra
#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#define x first // 定义x为pair类型的第一个元素
#define y second // 定义y为pair类型的第二个元素
using namespace std;
typedef pair<int, int> PII; // 定义PII为int型的pair类型
const int N = 150010, M = N, INF = 0x3f3f3f; // 定义常量N、M和INF，分别表示点数、边数和无穷大
int n, m; // 定义变量n和m，分别表示点数和边数
int h[N], e[M], w[M], ne[M], idx; // 定义数组h、e、w、ne和变量idx，用于存储邻接表
int dist[N]; // 定义数组dist，用于存储每个点到源点的最短距离
bool st[N]; // 定义数组st，用于标记每个点是否已经确定了最短距离
void add(int a, int b, int c) // 定义函数add，用于向邻接表中添加一条边(a,b)，权值为c
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++; // 将边(a,b)插入到a的头部，并更新idx
}
int dijkstra() // 定义函数dijkstra，用于求解单源最短路径问题，并返回源点到终点的最短距离
{
priority_queue<PII, vector<PII>, greater<PII>> heap; // 定义一个小根堆heap，用于存储每个未确定最短距离的点及其当前距离
memset(dist, 0x3f, sizeof dist); // 初始化dist数组为无穷大
dist[1] = 0; // 将源点1的距离设为0
heap.push({0, 1}); // 将(0,1)压入堆中，表示源点1当前距离为0
while (heap.size()) // 当堆不为空时循环执行以下操作：
{
auto t = heap.top(); // 取出堆顶元素t，并赋值给自动类型变量t（t是一个PII类型）
heap.pop(); // 弹出堆顶元素t
int ver = t.second; // 取出t中的第二个元素ver，并赋值给整型变量ver（ver表示当前要处理的点）
if (st[ver])
continue; // 如果ver已经确定了最短距离，则跳过本次循环（即不再处理ver）
st[ver] = true; // 否则将st[ver]设为true，表示ver已经确定了最短距离（即不再处理ver）
for (int i = h[ver]; ~i; i = ne[i])
/* 遍历以ver为起点的所有边（i从h[ver]开始，
每次取i对应的下一条边ne[i]，
直到i不存在（即等于-1））*/
{
int j = e[i];
/* 取出i对应的终点j，并赋值给整型变量j*/
if (dist[j] > dist[ver] + w[i])
/* 如果j到源点的当前距离大于通过ver到源点的距离加上(ver,j)边权，
则说明找到了一条更优化路径*/
{
dist[j] = dist[ver] + w[i]; // 更新j到源点的最短距离为通过ver到源点的距离加上(ver,j)边权
heap.push({dist[j], j}); // 将(j,dist[j])压入堆中，表示j当前距离为dist[j]
}
}
}
if (dist[n] == INF)
return -1; // 如果终点n到源点的最短距离仍然是无穷大，说明不存在可行路径，返回-1
return dist[n]; // 否则返回终点n到源点的最短距离
}
int main()
{
int a, b, c; // 定义变量a,b,c，用于存储输入的边信息
scanf("%d %d", &n, &m); // 读入点数n和边数m
memset(h, -1, sizeof h); // 初始化h数组为-1，表示没有任何边
while (m--) // 循环m次执行以下操作：
{
scanf("%d %d %d", &a, &b, &c); // 读入一条边(a,b)，权值为c
add(a, b, c); // 调用add函数向邻接表中添加这条边
}printf("%d\n", dijkstra()); // 调用dijkstra函数求解单源最短路径问题，并输出结果
return 0; // 程序正常结束，返回0
}
这段代码可以作为模板，这段代码的意义是：
1.先输入了图
2.输入了从0到n的最短路径
floyd
#include <bits/stdc++.h> // 引入 C++ 标准库头文件，包含各种常用函数
using namespace std; // 使用命名空间 std
const int N = 200 + 10; // 定义图的节点数上限为 200
const int M = 20000 + 10; // 定义图的边数上限为 20000
const int INF = 0x3f3f3f3f; // 定义无穷大值为 0x3f3f3f3f
int n, m, Q; // n 表示节点数，m 表示边数，Q 表示查询次数
int g[N][N]; // g[i][j] 表示节点 i 到节点 j 的最短距离
void floyd() // Floyd 算法求任意两点之间的最短距离
{
for (int k = 1; k <= n; k++) // 枚举中间节点
{
for (int i = 1; i <= n; i++) // 枚举起点
{
for (int j = 1; j <= n; j++) // 枚举终点
{
g[i][j] = min(g[i][j], g[i][k] + g[k][j]); // 更新最短距离
}
}
}
return;
}
int main()
{
cin >> n >> m >> Q; // 输入节点数、边数、查询次数
for (int i = 1; i <= n; i++) // 初始化 g 数组，把所有距离赋为 INF
{
for (int j = 1; j <= n; j++)
{
if (i == j)
g[i][j] = 0; // 自己到自己的距离为 0
else
g[i][j] = INF; // 其他距离赋为 INF
}
}
for (int i = 1; i <= m; i++) // 输入每条边的信息，更新 g 数组
{
int x, y, w;
cin >> x >> y >> w; // x, y 表示边的起点和终点，w 表示边的长度
g[x][y] = min(g[x][y], w); // 更新距离
}
floyd(); // 调用 Floyd 算法求任意两点之间的最短距离
for (int i = 1; i <= Q; i++) // 输入每次查询的起点和终点
{
int x, y;
cin >> x >> y;
if (g[x][y] > INF / 2)
cout << "impossible" << endl; // 如果距离大于 INF 的一半，说明没有路径，输出 "impossible"
else
cout << g[x][y] << endl; // 否则输出最短距离
}
system("pause");
return 0; // 返回程序执行成功
}
spfa
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int INF = 1000000000; // 定义无穷大，表示距离为正无穷大的情况
const int maxn = 1000; // 定义图中节点的最大数量
int dis[maxn]; // 定义 dis 数组，存储从源节点到每个节点的最短距离
bool vis[maxn]; // 定义 vis 数组，标记节点是否已被访问
struct node
{ // 定义一个结构体，表示图中的一条边
int s1; // 目标节点
int side; // 边的权重
};
vector<node> mp[maxn]; // 定义 mp 数组，表示图的邻接表
void Spfa(int s)
{ // 定义 SPFA 函数，以源节点的索引作为输入
queue<int> v; // 定义一个队列，用于存储待访问的节点
vis[s] = 1; // 标记源节点为已访问
v.push(s); // 将源节点推入队列
dis[s] = 0; // 将源节点的最短距离初始化为0
while (!v.empty())
{ // 使用 while 循环处理队列中的节点
int q = v.front(); // 取出队列中的第一个节点
v.pop(); // 将第一个节点从队列中移除
vis[q] = 0; // 取消对该节点的访问标记
for (int i = 0; i < mp[q].size(); i++)
{ // 迭代当前节点的邻接表
if (dis[mp[q][i].s1] > dis[q] + mp[q][i].side)
{ // 如果通过当前节点到达邻居节点的距离比其当前距离短
dis[mp[q][i].s1] = dis[q] + mp[q][i].side; // 更新其距离
if (!vis[mp[q][i].s1])
{ // 如果邻居节点未被访问
v.push(mp[q][i].s1); // 将邻居节点推入队列
vis[mp[q][i].s1] = 1; // 标记该节点已被访问
}
}
}
}
}
// 主函数
int main()
{
int n, m; // n 表示节点数量，m 表示边的数量
cin >> n >> m;
// 初始化 dis 数组和 vis 数组
for (int i = 1; i <= n; i++)
{
dis[i] = INF;
vis[i] = 0;
}
// 读入每一条边，并将其加入邻接表中
for (int i = 1; i <= m; i++)
{
int u, v, w;
cin >> u >> v >> w;
mp[u].push_back({v, w});
}
// 调用 SPFA 函数，求解最短路径
Spfa(1);
// 输出每个节点的最短距离
for (int i = 2; i <= n; i++)
{
cout << "从节点1到节点" << i << "的最短距离为：" << dis[i] << endl;
}
system("pause");
return 0;
}
拓扑排序
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAXN = 1000; // 最大节点数
int n; // 节点数
int in[MAXN]; // 节点入度
vector<int> edge[MAXN]; // 节点之间的边
int main() {
cin >> n; // 输入节点数
for (int i = 0; i < n; i++) {
int x, y; // 输入边的起点和终点
cin >> x >> y;
edge[x].push_back(y); // 将边加入边集
in[y]++; // 更新节点入度
}
queue<int> q;
for (int i = 0; i < n; i++) {
if (in[i] == 0) {
q.push(i); // 将入度为0的节点加入队列
}
}
vector<int> ans; // 存储拓扑序列
while (!q.empty()) {
int p = q.front(); // 取队头元素
q.pop(); // 将队头元素弹出队列
ans.push_back(p); // 将队头元素放入拓扑序列中
for (int i = 0; i < edge[p].size(); i++) { // 遍历p的出边
int y = edge[p][i]; // 取出边指向的节点y
in[y]--; // 将y的入度减1
if (in[y] == 0) {
q.push(y); // 如果y的入度为0，将y入队列
}
}
}
if (ans.size() == n) { // 如果拓扑序列中的节点数等于n
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " "; // 输出拓扑序列
}
cout << endl;
} else {
cout << "No Answer!" << endl; // 否则无法构成拓扑序列
}
return 0;
}
DP
//经典背包问题
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int n=1010;
int v[n],w[n];
int f[n][n];
int main()
{
int N,V;
scanf("%d%d",&N,&V);
for(int i=1;i<=N;i++)
scanf("%d%d",&v[i],&w[i]);
for(int i=1;i<=N;i++)
for(int j=1;j<=V;j++)
if(v[i]>j) f[i][j]=f[i-1][j];
else f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
cout<<f[N][V]<<endl;
return 0;
}
Dp关键是把所要求的数据作为数组值，根据题意可以使用多重数组进行处理，比如acwing1212
图源：https://www.acwing.com/blog/content/1971/感谢大佬总结，如有不当立刻删除。(*￣︶￣)
求质数
bool st[N];//定义全局变量用于存储是否为质数
int cnt,prime[N];
int get_prime(int n)
{
// 初始化质数数组primes，标记数组st和质数计数器cnt
for(int i=2;i<=n;i++)
{
// 如果i是质数，则将其加入primes数组中
if(!st[i]) prime[cnt++]=i;
// 遍历primes数组中的质数，将其和i的乘积标记为合数
for(int j=0;prime[j]*i<=n;j++)
{
st[primes[j]*i]=true;
// 如果i可以整除prime[j]，则退出循环
if(i%prime[j]==0) break;
}
}
}
二分
int ef()
{
int l=1,r=n,ans;
while(l<=r)
{
int mid=(l+r)>>1;
if(check(mid))//check()用来检查mid是否满足题意，比如是否为要查找的值
{
ans=mid;
l=mid+1;
}
else r=mid-1;
}
return ans;
}
求所有约数
vector<int> get_divisors(int x)
{
vector<int> res;
for (int i = 1; i <= x / i; i ++ )
if (x % i == 0)
{
res.push_back(i);
if (i != x / i) res.push_back(x / i);
}
sort(res.begin(), res.end());
return res;
}
最大公约数
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
快速幂
求 m^k mod p，时间复杂度 O(logk)。
long long fastPower(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power & 1) {//也可写成if(power%2==1)
result = result * base % N;
}
power >>= 1;//也可写成power=power/2
base = (base * base) % N;
}
return result;
}
双指针
for(int i = 0,int j=0; i < n; i++){
sum+=s[j][r]-s[i-1][r];
while(sum>k)//像这样的条件对指针进行限制
{
sum-=s[j][l]-s[i-1][l];
l++;
}
res=r-r+1;
}
哈希表
//哈希表批量添加方法与使用
#include <iostream>
#include <unordered_map>//头文件
int main() {
// 创建一个空的哈希表
std::unordered_map<std::string, int> hash_table;//变量名由自己定义
// 批量添加元素到哈希表中
hash_table.insert({{"apple", 1}, {"banana", 2}, {"orange", 3}});
// 查找键对应的值
std::cout << hash_table["apple"] << std::endl; // 输出1
std::cout << hash_table["banana"] << std::endl; // 输出2
std::cout << hash_table["orange"] << std::endl; // 输出3
return 0;
}
//哈希表查找是否存在某个值的例子，.find().end()查找函数
std::unordered_map<std::string, int> myMap;
myMap["apple"] = 1;
myMap["banana"] = 2;
auto it = myMap.find("orange");
if (it == myMap.end()) {
std::cout << "Not found" << std::endl;
} else {
std::cout << "Found: " << it->second << std::endl;
}
翻转函数（在处理字符串或者日期问题时的方法）
int flip(int k) {
string str = to_string(k);
reverse(str.begin(), str.end());
return stoi(str);//将字符串转回整数型
}
Vector用法补充
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <string.h>
#include <vector>
using namespace std;
vector<int> VE;
int main()
{
VE.push_back(2);
VE.push_back(1);
if (find(VE.begin(), VE.end(), 2) == VE.end())//注意，如果检测不到，才会输出
cout << "2 is not here" << endl;
if (find(VE.begin(), VE.end(), 3) == VE.end())
cout << "3 is not here" << endl;
cout << find(VE.begin(), VE.end(), 1) - VE.begin() << endl;//输出1的位置，距离起始元素为1，所以输出1
return 0;
}
秦九韶算法(进制转换)
左移与右移符号可以用来求二进制变化
8>>2变成2，因为8/2/2=2
9616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
