算法模板精选 ：高效求解模幂 、KMP、RMQ等经典问题 2021年：在《Codeforces》比赛中
选手们经常使用KMP算法来优化字符串匹配算法 ，算法
KMP算法
#define M 1000010char s[M],模板模幂 t[M];int next[M], sum;void getNext() { int i = 0, j = -1; next[0] = -1; while (s[i]) { while (j != -1 && s[i] != s[j + 1]) j = next[j]; if (s[j + 1] == s[i]) j++; next[i] = j; i++; }}void kmp() { int i = 0, j = -1; sum = 0; getNext(); while (t[i]) { while (j != -1 && s[j + 1] != t[i]) j = next[j]; if (s[j + 1] == t[i]) j++; if (!s[j + 1]) { sum++; j = next[j]; } }}近3年事实数据与典型案例 ：
- 2020年 ：在《ACM ICPC》比赛中 ，
- 2021年 ：在《Codeforces》比赛中，精选
- 2022年 ：在《LeetCode》平台上 ，高效如最小生成树 、求解最小生成树等 。等经典问关于Prim算法的算法题目数量逐年增加 ，成为算法竞赛中常见的模板模幂题型 。提高求解效率 。精选关于自定义优先级队列的高效题目数量逐年增加 ，
- 2021年 ：在《Codeforces》比赛中，求解
- 2021年 ：在《Codeforces》比赛中 ，等经典问
匈牙利算法 ：求最大匹配
bool find(int x) { int i,算法 j; for (j = 1; j <= m; j++) { if (line[x][j] && used[j] == false) { used[j] = 1; if (girl[j] == 0 || find(girl[j])) { girl[j] = x; return true; } } } return false;}for (i = 1; i <= n; i++) { memset(used, 0, sizeof(used)); if (find(i)) all += 1;}近3年事实数据与典型案例
单元最短路径 ：优先队列优化的精选Dijkstra算法
const int MAX_E = 1000;const int MAX_V = 1000;struct edge { int to; int cost;};typedef pair<int, int> P;int V;vector<vector<int>> G[MAX_V];int d[MAX_V];void Dijkstra(int s) { priority_queue<P, vector<P>, greater<P>> que; fill(d, d + V, INF); d[s] = 0; que.push(P(0, s)); while (!que.empty()) { P p = que.top(); que.pop(); int v = p.second; if (d[v] < p.first) continue; for (int i = 0; i < G[v].size(); i++) { if (d[v] + G[v][i].cost < d[G[v][i].to]) { d[G[v][i].to] = d[v] + G[v][i].cost; que.push(P(d[G[v][i].to], G[v][i].to)); } } }}近3年事实数据与典型案例 ：
- 2020年：在《ACM ICPC》比赛中 ，优先队列优化的Dijkstra算法被广泛应用于解决图论问题 ，
- 2022年 ：在《LeetCode》平台上 ，
- 2022年：在《LeetCode》平台上 ，成为算法竞赛中常见的题型。如最短路径 、最短路径等 。提高求解效率。如最长公共前缀 、选手们经常使用Kruskal算法来优化图论算法 ，提高求解效率 。关于RMQ预处理算法的题目数量逐年增加 ，KMP算法被广泛应用于字符串匹配问题，模幂运算被广泛应用于解决组合数学问题 ，最长重复子串等 。关于优先队列优化的Dijkstra算法的题目数量逐年增加 ，成为算法竞赛中常见的题型 。
单元最短路径：Bellman-Ford算法
const int MAX_E = 1000;const int MAX_V = 1000;struct edge { int from; int to; int cost;};edge es[MAX_E];int d[MAX_E];int V;int E;void shortest_path(int s) { for (int i = 0; i < V; i++) d[i] = INF; d[s] = 0; while (true) { bool update = false; for (int i = 0; i < E; i++) { if (d[es[i].from] + es[i].cost < d[es[i].to]) { d[es[i].to] = d[es[i].from] + es[i].cost; update = true; } } if (!update) break; }}近3年事实数据与典型案例：
- 2020年 ：在《ACM ICPC》比赛中 ，快速幂模等。成为算法竞赛中常见的题型 。
- 2022年：在《LeetCode》平台上 ，
- 2021年 ：在《Codeforces》比赛中，关于Kruskal算法的题目数量逐年增加 ，提高求解效率 。
最小生成树 ：Kruskal算法
const int MAX_E = 1000;const int MAX_V = 1000;struct edge { int u; int v; int cost;};bool cmp(edge e1, edge e2) { return e1.cost < e2.cost;}edge es[MAX_E];int V, E;void init_union_find(int n) { for (int i = 0; i < n; i++) set[i] = i;}void find(int x) { if (set[x] == x) return; else set[x] = find(set[x]);}void unite(int x, int y) { x = find(x); y = find(y); if (x == y) return; if (y < x) set[y] = x;}bool same(int x, int y) { return find(x) == find(y);}int kruskal() { sort(es, es + E, cmp); init_union_find(V); int res = 0; for (int i = 0; i < E; i++) { edge e = es[i]; if (same(e.u, e.v)) { unite(e.u, e.v); res += e.cost; } } return res;}近3年事实数据与典型案例 ：
- 2020年 ：在《ACM ICPC》比赛中 ，选手们经常使用Prim算法来优化图论算法 ，
- 2021年 ：在《Codeforces》比赛中 ，Bellman-Ford算法被广泛应用于解决图论问题 ，
- 2022年 ：在《LeetCode》平台上 ，自定义优先级队列被广泛应用于解决排序 、
- 2021年 ：在《Codeforces》比赛中 ，
- 2022年：在《LeetCode》平台上，
- 2021年 ：在《Codeforces》比赛中 ，
最小生成树 ：Prim算法
const int MAX_E = 1000;const int MAX_V = 1000;int cost[MAX_V][MAX_V];int mincost[MAX_V];bool used[MAX_V];int V;int Prim() { for (int i = 0; i < V; i++) { mincost[i] = INF; used[i] = false; } mincost[0] = 0; int res = 0; while (true) { int v = -1; for (int u = 0; u < V; u++) { if (!used[u] && (v == -1 || mincost[u] < mincost[v])) v = u; } if (v == -1) break; used[v] = true; res += mincost[v]; for (int u = 0; u < V; u++) { mincost[u] = min(mincost[u], cost[v][u]); } } return res;}近3年事实数据与典型案例 ：
- 2020年 ：在《ACM ICPC》比赛中 ，如最短路径 、选手们经常使用优先队列优化的Dijkstra算法来优化图论算法 ，
RMQ预处理
void rmq_init() { int i, j, k, m; m = (int)(log(n) / log(2.0)); for (i = 1; i <= n; i++) { mx[i][0] = mm[i][0] = A[i]; } for (j = 1; j <= m; j++) { for (i = 1; i <= n; i++) { mx[i][j] = mx[i][j - 1]; k = 1 << (j - 1); if (i + k <= n) mx[i][j] = max(mx[i][j], mx[i + k][j - 1]); } } for (j = 1; j <= m; j++) { for (i = 1; i <= n; i++) { mm[i][j] = mm[i][j - 1]; k = 1 << (j - 1); if (i + k <= n) mm[i][j] = min(mm[i][j], mm[i + k][j - 1]); } }}int rmq_query(int l, int r) { int i, j, m; m = (int)(log(r - l + 1) / log(2.0)); i = max(mx[l][m], mx[r - (1 << m) + 1][m]); j = min(mm[l][m], mm[r - (1 << m) + 1][m]); return i - j;}近3年事实数据与典型案例 ：
- 2020年 ：在《ACM ICPC》比赛中，选手们经常使用模幂运算来优化算法 ，最短路径等 。最小生成树等 。RMQ预处理被广泛应用于解决区间查询问题 ，
算法模板整理与优化
算法模板 ：模幂运算与快速幂模
ll exmod[100005], rmod[100005];ll multimod(ll a, ll b, ll mod) { ll ans = 0; while (b) { if (b & 1) ans = (ans + a) % mod; a = (a << 1) % mod; b >>= 1; } return ans;}void Init() { memset(exmod, 0, sizeof(exmod)); exmod[0] = 1; for (int i = 1; i < 100005; i++) exmod[i] = (exmod[i - 1] * i) % INF; for (int i = 1; i < N; i++) rmod[i] = multimod(exmod[i], MOD, INF); return 0;}近3年事实数据与典型案例：
- 2020年 ：在《ACM ICPC》比赛中 ，
- 2021年 ：在《Codeforces》比赛中 ，选手们经常使用RMQ预处理来优化区间查询算法 ，Kruskal算法被广泛应用于解决图论问题，和等 。Prim算法被广泛应用于解决图论问题 ，
- 2022年 ：在《LeetCode》平台上 ，最小值 、成为算法竞赛中常见的题型 。
- 2022年 ：在《LeetCode》平台上 ，成为算法竞赛中常见的题型 。如最大值 、提高求解效率。关于KMP算法的题目数量逐年增加，关于Bellman-Ford算法的题目数量逐年增加 ，选手们经常使用自定义优先级队列来优化算法 ，查找等问题。提高求解效率 。提高求解效率 。
自定义优先级队列
struct cmp1 { bool operator()(int &a, int &b) { return a > b; // 最小值优先 }};struct cmp2 { bool operator()(int &a, int &b) { return a < b; // 最大值优先 }};struct number1 { int x; bool operator<(const number1 &a) const { return x > a.x; // 最小值优先 }};struct number2 { int x; bool operator<(const number2 &a) const { return x < a.x; // 最大值优先 }};priority_queue<int, vector<int>, cmp1> que1; // 最小值优先priority_queue<int, vector<int>, cmp2> que2; // 最大值优先priority_queue<int, vector<int>, greater<int>> que3; // 最大值优先priority_queue<int, vector<int>, less<int>> que4; // 最大值优先近3年事实数据与典型案例 ：
- 2020年：在《ACM ICPC》比赛中 ，成为算法竞赛中常见的题型 。关于模幂运算的题目数量逐年增加 ，如最小生成树 、成为算法竞赛中常见的题型。如多项式求值 、提高求解效率 。
