算法模板

最新推荐文章于 2024-03-18 17:44:09 发布
最新推荐文章于 2024-03-18 17:44:09 发布
阅读量217 收藏 2
点赞数
文章标签： ACM算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14904619/article/details/107324677
版权

1. KMP算法

原理 : 获得 前缀和后缀 相同的长度 用数组保存
作用 : 求 文本串 中 模板串 的位置(没有则返回-1)

s[] 为文本串
p[] 为模板串
next[] 为前后缀相同长度
代码 :

char s[MAX],p[MAX];
int next[MAX]
void getnext(char p[])
{
       int i = 0,j = -1,l = strlen(p);
       next[0] = -1;
       while(i < l - 1)
       {
	if(j == -1 || p[i] == p[j])
	{
	        i++;
	        j++;
	       next[i] = j;
	}
	else
	{
	       j = next[j];
	}
       }
}
int kmp(char s[],char p[])
{
       int i = 0,j = 0,l1 = strlen(s),l2 = strlen(p),cnt;
       while(i < l1 && j < l2)
       {
	if(s[i] == p[j])
       	{
	       i++;
       	       j++;
       	}
	else j = next[j];
       }
       if(j == l2)return i - j;
       else return -1;
}

2. LCA算法

原理 : 用二维数组 fa[i][j] 保存 i 向上移动 1 << j 的祖先节点
作用 : 求共同祖先 or 点距(不成环)
代码 :

struct node
{
    ll to;
    ll next;
    ll val;
} edge[MAX * 2]; //存边
ll n, q;         //节点个数
ll head[MAX];    //head[i] 为 i 节点最后出现的 子节点 的 边序号
ll dis[MAX];
ll depth[MAX];                   //存深度
ll fa[MAX][21];                  //存 i 节点 向上移动 1 << j 的祖先节点
ll tol;                          //边个数
void add(ll from, ll to, ll val) //存边 可以加val
{
    edge[tol].to = to;
    edge[tol].val = val;
    edge[tol].next = head[from];
    head[from] = tol++;
}
void dfs(ll u, ll f)
{
    fa[u][0] = f;
    for (int i = head[u]; ~i; i = edge[i].next)
    {
        ll To = edge[i].to;
        if (To != f)
        {
            dis[To] = dis[u] + edge[i].val;
            depth[To] = depth[u] + 1;
            dfs(To, u);
        }
    }
}
void init(ll root) //main函数里调用init初始化
{
    depth[root] = 1;
    dis[root] = 0;
    dfs(root, -1);
    for (long long i = 1; i < 20; i++)
        for (long long j = 1; j <= n; j++)
            fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
ll lca(ll x, ll y)
{
    if (depth[x] > depth[y])
        swap(x, y);
    for (long long i = 0; i < 20; i++)
        if ((depth[y] - depth[x]) >> i & 1)
            y = fa[y][i];
    if (x == y)
        return x;
    for (long long i = 19; i >= 0; i--)
    {
        if (fa[x][i] != fa[y][i])
        {
            x = fa[x][i];
            y = fa[y][i];
        }
    }
    return fa[x][0];
}

3. RMQ算法


原理 : 二维数组p[i][j] 保存 a[i]到 a[i + (1 << j) - 1]的最值
作用 : 求区间内的最值

n 数据长度
a[] 数据
p[][] 用于保存最值
代码 :

int n,a[MAX],p[MAX][40];
void init()
{
    for(int i = 1; i <= n; i++)p[i][0] = a[i];
    for(int j = 1; 1 << j <= n; j++)
    {
        for(int i = 1; i + (1 << j) - 1 <= n; i++)
        	p[i][j] = max(p[i][j - 1],p[i + (1 << (j - 1))][j - 1]);
        	//max改成min也可以
    }
}
int RMQ(int l,int r)   //返回[l,r]区间的最值
{
    int tem = log2(r - l + 1);
    return max(p[l][tem], p[r - (1 << tem) + 1][tem]);
}

4. 并查集

代码 :

int find(int x){
    if(fa[x]!=x) fa[x]=find(fa[x]);
    return fa[x];
}
void conbine(int x,int y){
     int temp1=find(x);
     int temp2=find(y);
     fa[temp2]=temp1;
}

5. 线段树

原理 : tree[i].l 为左边界 tree[i].r 为右边界 tree[i].val 为区间权值(求和 or 最值)
作用 : 修改 + 查找区间权值
代码 :

struct node
{
    int l, r;
    ll v, lazy;
} tr[MAX * 4];
int a[MAX];
int n, q;
void update(int i) { tr[i].v = tr[i << 1].v + tr[(i << 1) + 1].v; }
void push(int i)
{
    if (tr[i].lazy != 0)
    {
        tr[i << 1].v += tr[i].lazy * (tr[i << 1].r - tr[i << 1].l + 1);
        tr[(i << 1) + 1].v += tr[i].lazy * (tr[(i << 1) + 1].r - tr[(i << 1) + 1].l + 1);
        tr[i << 1].lazy += tr[i].lazy;
        tr[(i << 1) + 1].lazy += tr[i].lazy;
        tr[i].lazy = 0;
    }
}
void build(int i, int l, int r)
{
    tr[i].l = l;
    tr[i].r = r;
    tr[i].lazy = 0;
    if (l == r)
    {
        tr[i].v = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(i << 1, l, mid);
    build((i << 1) + 1, mid + 1, r);
    update(i);
}
void change1(int i, int pos, int v)
{
    if (tr[i].l == tr[i].r)
    {
        tr[i].v = v;
        return;
    }
    if (tr[i << 1].r >= pos)
        change1(i << 1, pos, v);
    else
        change1((i << 1) + 1, pos, v);
    update(i);
}
void change2(int i, int l, int r, int v)
{
    push(i);
    if (tr[i].l >= l && tr[i].r <= r)
    {
        tr[i].v += v * (tr[i].r - tr[i].l + 1);
        tr[i].lazy += v;
        return;
    }
    if (tr[i << 1].r >= l)
        change2(i << 1, l, r, v);
    if (tr[(i << 1) + 1].l <= r)
        change2((i << 1) + 1, l, r, v);
    update(i);
}
ll search(int i, int l, int r)
{
    ll ans = 0;
    push(i);
    if (tr[i].l >= l && tr[i].r <= r)
    {
        return tr[i].v;
    }
    if (tr[i << 1].r >= l)
        ans += search(i << 1, l, r);
    if (tr[(i << 1) + 1].l <= r)
        ans += search((i << 1) + 1, l, r);
    update(i);
    return ans;
}

6. 树状数组


原理 : tree[i] = a[i - 2^k + 1] + … + a[i] 其中2^k = i&(-i); k为i二进制末尾不为零的长度
作用 : 在部分情况中 可以替代线段树
代码 : 

#define lowbit(x) x&(-x);
void update(int i,int k)	//定点更新
{
    while(i <= n)
    {
        c[i] += k;
        i += lowbit(i);
    }
}
int getsum(int i)		//求和
{
    int res = 0;
    while(i > 0)
    {
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

7.1 最短路 - Dij


原理 : 贪心思想 从 起点 找最短距离点(走一次 标记一次)走完 所有点
作用 : 求最短距离
vis 为标记
mp[i][j] 为题目所给 俩点 距离不通则为 INF
dis[j] 为 s(起点) 到 j 的距离
代码 (未优化) : 

int vis[MAX],mp[MAX][MAX],dis[MAX];
void Dij(int s) // s为起点
{
    memset(vis, 0, sizeof(vis));
    vis[s] = 1;
    for(int i = 1; i <= n; i++)dis[i] = mp[s][i];
    int v,mn;
    for(int i = 1; i <= n; i++)
    {
        mn = INF;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && dis[j] < mn)
            {
                mn = dis[j];
                v = j;
            }
        }
        vis[v] = 1;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && (mn + mp[v][j]) < dis[j])dis[j] = mn + mp[v][j];
        }
    }
}

7.2 最短路 - Dij 优化

优化 : 优化找最小值过程

前向星 + 优先队列(重载)

代码 :

int n, q, vis[MAX], dis[MAX], head[MAX], tol;
struct edge
{
    int to, next, v;
} eg[MAX * 2];
struct node
{
    int id, len;
    node(int id1, int len1)
    {
        id = id1;
        len = len1;
    }
    bool operator<(const node &rhs) const
    {
        return len > rhs.len;
    }
};
void add(int x, int y, int v)
{
    eg[++tol].to = y;
    eg[tol].v = v;
    eg[tol].next = head[x];
    head[x] = tol;
}
void dij(int s) // s为起点
{
    for (int i = 1; i <= n; i++)
    {
        dis[i] = INF;
        vis[i] = 0;
    }
    priority_queue<node> q;
    dis[s] = 0;
    q.push(node(s, 0));
    while (!q.empty())
    {
        node p = q.top();
        q.pop();
        int v = p.id;
        if (vis[v])
            continue;
        vis[v] = 1;
        for (int i = head[v]; i != 0; i = eg[i].next)
        {
            int to = eg[i].to;
            if (!vis[to] && dis[to] > dis[v] + eg[i].v)
            {
                dis[to] = dis[v] + eg[i].v;
                q.push(node(to, dis[to]));
            }
        }
    }
}

7.3 最短路-SPAF


代码 : 

int head[MAX],dis[MAX],vis[MAX];
int n,tol;
struct node
{
    int to, next, val;
} edge[MAX];
void add(int from,int to,int val)
{
    edge[++tol].to = to;
    edge[tol].val = val;
    edge[tol].next = head[from];
    head[from] = tol;
}
void SPAF(int x)
{
    memset(dis, INF, sizeof(dis));
    memset(vis, 0, sizeof(vis)); //初始化两个数组
    queue<int> q;
    q.push(x);
    dis[x] = 0;
    vis[x] = 1;
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        vis[now] = 1;
        for (int i = head[now]; i != 0;i=edge[i].next)
        {
            if(dis[edge[i].to] > dis[now] + edge[i].val)
            {
                dis[edge[i].to] = dis[now] + edge[i].val;
                if(!vis[edge[i].to])
                {
                    q.push(vis[edge[i].to]);
                    vis[edge[i].to] = 1;
                }
            }
        }
    }
}

8. 最小生成树 - Kruskal算法

原理 : 连接n个点只需要n - 1条边 + m条边的长度排序
作用 : 求连接n个点的最小路径和
代码 :

struct node
{
    int x, y, l;//x,y为两点 l为连接的长度
} edge[MAX];
int cmp(node a,node b)
{
    return a.l < b.l;
}
int find(int x)
{
    if(x != fa[x])
        return fa[x] = find(fa[x]);
    else
        return x;
}
int main()
{
    int n, m, k = 0, ans = 0;
    for (int i = 1; i <= n; i++)fa[i] = i;//初始化数组
    sort(edge, edge + m, cmp);
    for (int i = 0; i < m; i++)
    {
        int a = find(edge[i].x);
        int b = find(edge[i].y);
        if(a != b)
        {
            ans += edge[i].l;
            fa[a] = b; //连接两点
            k++;
        }
        if(k == n - 1)break;
    }
    if(k == n - 1)//ans就是路径长
    else //不存在
}
狡狐
关注
acwing基础算法模板整理
02-27
"acwing基础算法模板整理"是一个集合，包含了各种基础算法、数据结构、图论和数学知识的详细讲解和实例，旨在帮助学习者巩固和提升这些核心技能。 首先，我们来深入探讨一下**基础算法**。基础算法通常涵盖排序、...
常用算法模板——汇总
m0_66689823的博客
10-03 4278
本篇文章主要包含了算法与数据结构的一些常用模板，可适用于算法小白学习，也适用于有一定基础的同学用来复习！！
常见算法模板
Conqueror_demons的博客
03-17 584
文章目录快速幂快读马拉车最小生成树最短路字典树优先队列中国剩余定理线段树唯一分解定理网络流之最大流完全背包贪心拓扑排序约瑟夫环欧拉函数树状数组三分区间查质数强连通分量欧拉回路记忆化优先搜索字符串哈希哈希表割点二分图最大匹配多重背包01背包kmpRMQ倍增求LCA并查集尺取法叉乘差分约束系统uowei 快速幂 //求a^k的前三位和后三位 #include <cstdio> #include <cmath> #include <cstring> #include <a
常用算法模板
m0_46200713的博客
03-18 1016
常用算法与数据结构 文章目录常用算法与数据结构1. 树先序遍历中序遍历后序遍历前缀树并查集2. 图拓扑排序最短路径DijkstraBellman-FordFloyd最小生成树primkruskal3. 单调栈4. 链表快慢指针翻转链表5. 十大排序算法冒泡排序选择排序插入排序希尔排序归并排序**快速排序**堆排序计数排序桶排序基数排序 1. 树 先序遍历 // 递归 void preOrder(Node * root){ if(!root){ visit(root);
算法模板——常用方法（未完待更）
Aries_young的博客
05-04 1504
常用方法1. 双指针1.1 快慢指针1.1.1 有环链表的问题1.1.2 无环线性表1.1.3 Reference 1. 双指针 1.1 快慢指针 快慢指针的核心思想就是： 慢指针每次移动一格，快指针每次移动两格 1.1.1 有环链表的问题 最典型的就是弗洛伊德的龟和兔子 bool hasCycle(ListNode *head) { ListNode *tortoise = head; ...
最全算法模板-更新ing
weixin_40446266的博客
07-14 577
笔记
STUACM算法模板_算法模板_
10-01
在编程领域，尤其是在参加ACM（国际大学生程序设计竞赛）或者进行算法训练时，拥有一个良好的算法模板是非常重要的。这个名为“STUACM算法模板”的资源提供了C/C++语言的经典算法模板，对于提升编程效率和解决问题...
算法模板1
08-08
【算法模板1】：在编程竞赛或算法设计中，算法模板是解决一类问题的通用框架。这可能包括数据结构如线段树、树状数组，或者特定问题的解法如DFS（深度优先搜索）、FFT（快速傅里叶变换）。算法模板帮助程序员快速地...
算法模板.zip
05-18
ACM算法模板，基础的30个模板 ，加了些注释方便理解点，/* Dinic算法，可以看作是两种方法的结合体，它进行了一定的优化，对于某些横边多的图，运行速度方面得到了大幅提升 Dinic算法的基本思路: 根据残量网络计算...
算法模板大全
少吃点肉的博客
02-05 616
二分查找 二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。 常用案例：有序数组插入 /** * @param {number[]} nums * @param {number} target * @return {number} */ var searchInsert = function(nums, target) { let left = 0, right = nums.length - 1 while (left <= right) {
ACM算法模板集史上最完整收藏版
02-11
ACM算法模板集史上最完整收藏版,绝对可靠有帮助，
算法模板整理
最新发布
toytoytelecar的博客
03-18 733
裴蜀定理：若 a,b 是整数,且 (a,b)=d，那么对于任意的整数 x,y, ax+by 都一定是 d 的倍数，特别地，一定存在整数 x,y，使 ax+by=d成立。解决方法：mid指针取(l+r+1)/2,小于等于这个数的解时左指针取mid，不再取mid+1，右指针取mid-1，循环条件为l<r,这样当跳出循环时l指向的数就是最小值。1.每一个集合用树来维护，每一个集合的编号是根节点，查找是去看他爸爸是不是根节点，不是再向上，所以每一个节点都要存储他的父节点，p[x]就是x的父节点。
ACM算法模板总结（分类详细版）
热门推荐
wait
02-27 2万+
本文模均引用于y总的算法模板，网址：AcWing (本文属于持续更新ing.......)
五大超常用Java算法模板，七分理解，三分记忆，唯快不破
暴雪的博客
07-05 2765
前言 整理了一些，常见算法的通用模板写法，针对不同的数据结构， 都可以针对性的选择使用。 BFS （Breadth-First-Search）广度优先 代码模版 其实他属于一种盲目搜索方法，也是很基础的一种搜索方式，主要目的是系统地彻底的展开（暴力）并检查结构中的所有节点。比如：树中，可以理解为层序的遍历的方式。图中先找到第一节点，再找到第一个节点的所有相连节点，按次序再找到每个节点的所有相连节点，逐步扩散，很明显，他需要依赖队列的结构，保证先进先出。 模板代码如下： public void bfs(Nod
蓝桥杯常用模板
weixin_51568657的博客
04-10 5503
文章目录蓝桥杯算法模板最大公约数（GCD）拓展欧几里得(EXGCD)最小公倍数（LCM）多个数的GCD和LCM判断闰年整数快速幂（用于快速求幂）快速幂取模快速乘(O(logn))对于一个大数最后结果只需要部分结尾数字，则在过程中取模即可逆元筛选素数01背包(每个物品只有一件)完全背包(每个物品有无数件)组合数模板前缀和与差分全排列函数next_permutation(arr,arr+n)全排列（递归）无重复元素有重复元素并查集迪杰斯特拉算法弗洛伊德算法BFSDFS合并区间平方数判断记忆化搜索二分查找 蓝桥杯
算法模板大全-超详细~
DGGGGGGggghggg的博客
02-07 1660
涵盖了大部分基础算法模板以及清晰的代码书写吗
算法 {算法代码模板,算法模板编写规范}
qq_66485519的博客
09-17 441
1
【算法模板】高精度模板（带图详解）
Z1tai的博客
11-04 1696
高精度模板（加减乘除）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值