C++算法模板

已于 2024-07-10 16:46:54 修改
阅读量123 收藏 5
点赞数 2
分类专栏： c++算法 文章标签： 算法 c++ 开发语言
于 2024-03-27 21:32:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57360189/article/details/137089627
版权

01背包

//朴素算法
const int N = 1010;
int dp[N][N];
int v[N],w[N];
int n,m; //物品数量  和  背包体积

int main(){
    cin >> n >> m;
    
    for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];
    
    
    for(int i = 1 ; i <= n ; i++){
        for (int j = 1; j <= m; j ++ ){
            if(j < v[i])
                dp[i][j] = dp[i-1][j];
            else{
                dp[i][j] = max(dp[i-1][j-v[i]] + w[i],dp[i-1][j]);
            }
        }
    }
    cout<<dp[n][m];
    
    return 0;
}
//优化算法（一维）
const int N = 1010;
int n,m; // m为背包容量
int f[N],v[N],w[N];

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    for (int i = 1; i <= n; i++){
        for (int j = m; j >= v[i]; j--){
            f[j] = max(f[j],f[j-v[i]] + w[i]);
        }
    }
    cout<<f[m];
    
    return 0;
}

完全背包

//二维背包
const int N = 1010;
int n,m; // m为背包容量
int f[N][N],v[N],w[N];

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    
    for (int i = 1 ; i <= n ; i++){
        for (int j = 0; j <= m; j ++ ){
            f[i][j] = f[i-1][j];
            if(j >= v[i])
                f[i][j] = max(f[i][j],f[i][j-v[i]] + w[i]);
        }
    }
    
    cout<<f[n][m];
    
    return 0;
}
//优化算法（一维）
const int N = 1010;
int n,m; // m为背包容量
int f[N],v[N],w[N];

int main()
{
    cin >> n >> m;
    
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    for (int i = 1; i <= n; i++){
        for (int j = v[i]; j <= m; j++){
            f[j] = max(f[j],f[j-v[i]] + w[i]);
        }
    }
    cout<<f[m];
    
    return 0;
}

并查集

int find(int x) {  // 并查集
    if (fa[x] != x) fa[x] = find(fa[x]);
    return fa[x];
}

快速幂

ll qpow(ll a, int b){ //需要取模时记得模p
    ll res = 1;
    while(b){
        if(b & 1) res = res * a;
        b >>= 1;
        a = a * a;
    }
    return res;
}

费马小定理

(a / b) % p == (a * b^(p - 2)) % p

ll qmi(ll a,ll b,ll c) {
	ll ans=1;
	a %= c;
	while(b){
		if(b&1) ans=ans*a%c;
		a=a*a%c;
		b>>=1;
	}	
	return ans%c;
}

ll divi(ll a,ll b,ll p){
	b=qmi(b,p-2,p);	//b的逆元
	return a*b%p; 
}

二分查找

int l = 0 , r = n + 1;
while(l < r){
    int mid = (l + r + 1) / 2; //有加
    if(check(mid)) l = mid;
    else r = mid - 1; //必有减
}

前缀和

while(n--){
	int l,r;
	cin >> l >> r;
	cout << s[r] - s[l - 1] << endl;
}

埃氏筛

/*
    埃式筛
*/

int prime[maxn];  
bool is_prime[maxn];

int sieve(int n){
    int p = 0;
    for(int i = 0; i <= n; ++i)
        is_prime[i] = true;
    is_prime[0] = is_prime[1] = false;
    for (int i = 2; i <= n; ++i){
        if(is_prime[i]){
            prime[p++] = i;
            for(int j = i + i; j <= n; j += i)
                is_prime[j] = false;
        }
    }
    return p;   //返回素数个数
}

for (int i = 0; i < cnt; i ++){
    int p = prime[i];
    int s = 0, t = n;
    while(t) s += t / p , t /= p; //求出质因子p的次数是多少
    cout<<p<<" "<<s<<endl;
}

最大公约数、最小公倍数

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

int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

Dijkstra--迪杰斯特拉算法

/*
    Dijkstra算法
*/

struct node {  
    int v, len;  
    node(int v = 0, int len = 0) :v(v), len(len) {}  
    bool operator < (const node &a)const {  //  距离从小到大排序  
        return len > a.len;  
    }  
};  

vector<node>G[maxn];  
bool vis[maxn];  
int dis[maxn];

void init() {  
    for (int i = 0; i<maxn; i++) {  
        G[i].clear();  
        vis[i] = false;  
        dis[i] = INF;  
    }  
}  
int dijkstra(int s, int e) {  
    priority_queue<node>Q;  
    Q.push(node(s, 0)); //  加入队列并排序  
    dis[s] = 0;  
    while (!Q.empty()) {  
        node now = Q.top();     //  取出当前最小的  
        Q.pop();  
        int v = now.v;  
        if (vis[v]) continue;   //  如果标记过了, 直接continue  
        vis[v] = true;  
        for (int i = 0; i<G[v].size(); i++) {   //  更新  
            int v2 = G[v][i].v;  
            int len = G[v][i].len;  
            if (!vis[v2] && dis[v2] > dis[v] + len) {  
                dis[v2] = dis[v] + len;  
                Q.push(node(v2, dis[v2]));  
            }  
        }  
    }  
    return dis[e];  
}

LIS--最长上升子序列

/*
    |最长上升子序列|
*/

void solve(){ 
    for(int i = 0; i < n; ++i){  
        dp[i] = 1;  
        for(int j = 0; j < i; ++j){  
            if(a[j] < a[i]){  
                dp[i] = max(dp[i], dp[j] + 1);  
            } 
        } 
    }
}  

/* 
    优化方法：
    dp[i]表示长度为i+1的上升子序列的最末尾元素  
    找到第一个比dp末尾大的来代替 
*/
void solve() {  
    for (int i = 0; i < n; ++i){
        dp[i] = INF;
    }
    for (int i = 0; i < n; ++i) {  
       *lower_bound(dp, dp + n, a[i]) = a[i];  //  返回一个指针  
    }  
    printf("%d\n", *lower_bound(dp, dp + n, INF) - dp;  
}

LCS--最长公共子序列

/*
    求最长公共子序列
    递推形式
*/

void solve() {  
    for (int i = 0; i < n; ++i) {  
        for (int j = 0; j < m; ++j) {  
            if (s1[i] == s2[j]) {  
                dp[i + 1][j + 1] = dp[i][j] + 1;  
            }else {  
                dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);  
            } 
        } 
    }
}

kmp--克努特-莫里斯-普拉特操作

/*
    kmp算法
*/

void getnext(char str[N], int nextt[N]) {
    int j = 0, k = -1;
    nextt[0] = -1;
    while (j < m) {
        if (k == -1 || str[j] == str[k]) {
            j++;
            k++;
            nextt[j] = k;
        }
        else
            k = nextt[k];
    }
}

void kmp(int a[N], int b[N]) {    
    int nextt[N];    
    int i = 0, j = 0;    
    getnext(b, nextt);    
    while (i < n) {    
        if (j == -1 || a[i] == b[j]) { // 母串不动，子串移动    
            j++;    
            i++;    
        }    
        else {    
            // i不需要回溯了    
            // i = i - j + 1;    
            j = nextt[j];    
        }    
        if (j == m) {    
            printf("%d\n", i - m + 1); // 母串的位置减去子串的长度+1    
            return;    
        }    
    }    
    printf("-1\n");
}

树状数组

acwing数星星

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
int n;
const int N = 15010, M = 32010;
int tr[M],ans[N];

int lowbit(int x)  //二进制中最后一位1
{
    return x & -x;
}

void update(int x, int c)  // 位置x加c
{
    for (int i = x; i < M; i += lowbit(i)) tr[i] += c;
}

int query(int x)  // 返回前x个数的和
{
    int res = 0;
    for (int i = x; i; i -= lowbit(i)) res += tr[i];
    return res;
}

int main(){
    cin >> n;
    for(int i=1;i<=n;i++){
        int x,y;

        scanf("%d%d",&x,&y);//其实这里 y 并没有什么用

        x++;/*为了防止出现0的情况，给它全体横坐标加上 1 就好了。
        这其实是一个很小的细节，作者但是做的时候没考虑到然后就wa了，而给每个 x 都加上 1 并不会影响结果*/

        update(x,1);//更新一下树状数组，每次都给 x 后面的数据加上 1 

        ans[query(x)]++;/*然后查一下它的前缀和是多少，前缀和是多少就意味着是多少级
        这是一个动态变化的过程，而且后面的一定比前面高
        所以要实时计算*/
     }

     for(int i=1;i<=n;i++){
         printf("%d\n",ans[i]);//输出每一个等级的数量
     }
    
    return 0;
}

线段树

// 建树，分别代表当前节点，区间左端点，区间右端点
void build(int id, int l, int r) {
    if (l == r) {
        pmx[id] = pre[l];
        nmx[id] = nxt[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(id * 2, l, mid);
    build(id * 2 + 1, mid + 1, r);
    pmx[id] = max(pmx[id * 2], pmx[id * 2 + 1]);
    nmx[id] = max(nmx[id * 2], nmx[id * 2 + 1]);
}

//前缀和最大值
int preMax(int id, int l, int r, int s, int t) {
    if (s <= l && t >= r) return pmx[id];
    int mid = (l + r) >> 1;
    int res = -8e18;
    if (s <= mid) res = max(res, preMax(id * 2, l, mid, s, min(t, mid)));
    if (t > mid) res = max(res, preMax(id * 2 + 1, mid + 1, r, max(s, mid), t));
    return res;
}

//后缀和最大值
int nxtMax(int id, int l, int r, int s, int t) {
    if (s <= l && t >= r) return nmx[id];
    int mid = (l + r) >> 1;
    int res = -8e18;
    if (s <= mid) res = max(res, nxtMax(id * 2, l, mid, s, min(t, mid)));
    if (t > mid) res = max(res, nxtMax(id * 2 + 1, mid + 1, r, max(s, mid), t));
    return res;
}

signed main() {
    IOSCC;
    cin >> n >> q;
    rep(i, 1, n) {
        cin >> w[i];
        pre[i] = pre[i - 1] + w[i];
    }
    per(i, 1, n) nxt[i] = nxt[i + 1] + w[i];
    build(1, 1, n);

    
    while (q--) {
        
    }
}

（持续更新。。。）

小冯不摆烂
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用算法模板_C++.zip
04-27
常用算法模板_C++.zip AC自动机，Dijkstra，Floyd，GCD，KMP，KMP扩展，Kruskal，LCM，LCS，LIS，Prim，SPFA，埃氏筛，背包，并查集，多边形面积，二分搜索，高精度加法，高精度阶乘，级角排序，进制转换，快速幂，...
C++常用算法模板
06-04
这是C++常用算法模板，内含常用排序、图的各种算法等。
C++——STL标准模板库——常用算法归纳
qq_42106610的博客
02-01 1062
STL 提供的部分常用算法归纳。
【C++算法模板】字符串哈希，超详细注释带例题
qq_63586399的博客
03-12 1396
字符串哈希即把不同的字符串映射成不同的整数把字符串映射成一个p进制数字，对于一个长度为n的字符串s，定义其HashHashHash函数为：$ h(s)=\sum_{i=1}^n s[i]×p^{i-1}(mod M)$
【C++算法模板】快速幂
见见大魔王
04-07 1177
正好在复习算法，总结一下！ 快速幂的优点在于比起暴力枚举，快速幂每次计算的是平方操作，将算法的时间复杂度从 O(n²) 下降到 O(logn)。 原理 我们可以把任意一个幂运算的幂次展开乘二进制表示，从而列出一个幂次是二进制权重的乘法式子（如图中等号右边），我们只要计算这个式子，就相当于求了幂运算了。每次循环对a进行平方（a, a², a⁴...），然后根据幂次的二进制表达，我们对其...
C++模板 —— 万字带你了解C++模板（蓝桥杯算法比赛必备知识STL基础）
兴趣使然的编程菜鸟
11-09 2278
函数模板利用关键字 template使用函数模板有两种方式：自动类型推导、显示指定类型模板的目的是为了提高复用性，将类型参数化使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T类模板中的成员函数并不是一开始就创建的，在调用时才去创建。
【C++算法模板】矩阵快速幂
见见大魔王
04-07 1149
适用题目 适用于类斐波那契数列问题。需要递推来确定关系。 综上所述，我们需要做的是列出初始条件的 F 矩阵，如F(1) = 1, F(2) = 1等初始情况；然后找到 A 矩阵 ，用于求幂，最后我们算好 即可。 矩阵快速幂模板 这里使用了斐波那契数列为例子。 #include<bits/stdc++.h> using namespace std; typedef l...
C++学习笔记——标准模板库
华数云图小分队的博客
01-13 1179
C++标准模板库（STL）是C++的一个重要组成部分，它提供了一套丰富的通用数据结构和算法。STL以其高度模块化、可复用的特性，在C++编程中发挥着重要作用。本篇博客将带你深入了解STL，并介绍其常见的组件和使用方法。C++标准模板库（STL）是C++语言的一个标准库，它提供了一套通用的数据结构和算法，以支持高效的编程。STL的设计目标是使程序员能够以简洁、高效和可复用的方式开发代码。// 输出vector的大小return 0;
C++ 函数模板基础
英雄哪里出来
05-22 3859
C++ 函数模板基础
c++常见算法
qq_51691366的博客
04-16 4752
find 查找自定义数据类型 需要重载==private:int num;public:Person(){}//find 查找自定义数据类型 需要重载==if(ret!cout
【算法】KMP模板（C++）
xhd0728的博客
04-24 2023
C++实现基础KMP匹配算法模板
蓝桥杯个人赛的一些常考的(C++)算法模板
04-14
在准备蓝桥杯个人赛的过程中，掌握一些常用的C++算法模板是至关重要的。这些模板涵盖了比赛常见的问题类型，包括但不限于排序、搜索、图论、动态规划等。下面将详细讲解这些算法及其应用。 1. **排序算法** - **...
算法模板.zip
05-18
ACM算法模板，基础的30个模板 ，加了些注释方便理解点，/* Dinic算法，可以看作是两种方法的结合体，它进行了一定的优化，对于某些横边多的图，运行速度方面得到了大幅提升 Dinic算法的基本思路: 根据残量网络计算...
遗传算法c++实现模板
08-06
遗传算法的c++实现，代码量一般，使用方便。在求值优化时只需要将函数表达式改变即可。
函数模板与类模板
程序员_小兵
07-12 1559
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 381
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 371
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
常见的排序算法，复杂度
最新发布
m0_61544805的博客
07-16 357
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
欧拉路径c++算法模板
06-13
以下是一个求解欧拉路径的 C++ 算法模板（无向图）： ```cpp #include <iostream> #include <vector> using namespace std; const int MAXN = 1005; vector<int> G[MAXN]; int deg[MAXN]; // 记录每个顶点的度数 vector<int> ans; // 存储欧拉路径 void dfs(int u) { for (int i = 0; i < G[u].size(); ++i) { int v = G[u][i]; if (deg[v]) { // 只要边存在，就一定能够走 --deg[u]; --deg[v]; dfs(v); } } ans.push_back(u); // 回溯时将经过的点加入路径中 } int main() { int n, m; cin >> n >> m; // 输入顶点数和边数 for (int i = 1; i <= m; ++i) { int u, v; cin >> u >> v; G[u].push_back(v); G[v].push_back(u); ++deg[u]; ++deg[v]; // 维护每个顶点的度数 } int cnt = 0; // 统计度数为奇数的顶点个数 int st = 1; // 欧拉路径的起点 for (int i = 1; i <= n; ++i) { if (deg[i] & 1) { ++cnt; st = i; } } // 不存在欧拉路径的情况 if (cnt != 0 && cnt != 2) { cout << "No Euler Path!" << endl; return 0; } dfs(st); // 从起点开始搜索欧拉路径 // 判断路径是否经过了所有的边 if (ans.size() != m + 1) { cout << "No Euler Path!" << endl; return 0; } // 输出欧拉路径 for (int i = ans.size() - 1; i >= 0; --i) { cout << ans[i] << " "; } cout << endl; return 0; } ``` 该算法的时间复杂度为 $O(m)$，其中 $m$ 表示边数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值