模拟，二分，数学，双指针，前缀和

最新推荐文章于 2024-11-15 20:16:11 发布
最新推荐文章于 2024-11-15 20:16:11 发布
阅读量257 收藏 5
点赞数 4
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50952205/article/details/136646884
版权

目录

模拟

题目

  • 输入系数可能为0，这种情况直接排除
  • 次数一致的项合并，合并后可能产生系数为0的项，这种情况也要排除
  • 感觉这个用map略麻烦，题解用hash数组。以后想到用map时，可以优先考虑hash数组。
#include <cstdio>
#include <algorithm>
#include <map>

using namespace std;

int main() {
    int n;
    map<int, int, greater<int>> func;
    scanf("%d", &n);

    int a, b;
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &a, &b);
        if (b >= 5 && a != 0) {
            for (int k = 0; k < 5; k++) {
                a *= b;
                b --;
            }
            if (!func.count(b)) {
                func[b] = a;
            } else {
                func[b] += a;
            }
        }
    }

    int size = func.size();
    if (size == 0) {
        printf("0 0");
        return 0;
    }

    int i = 0;
    for (map<int, int>::iterator it = func.begin(); it != func.end(); it++) {
        if (it -> second != 0) {
            printf("%d %d", it -> second, it -> first);
            if (i != size - 1) printf("\n");
        }
        i ++;
    }
}

数学

进制转换

  • 负三进制转换，需要了解的编程除余知识：
    n-被除数，r-除数
    当r<0，n>0时，商和余数都是非负数
    当r<0，n<0时，商是非负数，而余数在[r+1, 0]之间
    这道题要求余数不能为负数，所以对于负的余数+r使其变化到非负值，相对的，商加一。
#include <cstdio>
#include <vector>

using namespace std;
int main() {
    int n;
    vector<int> v;
    scanf("%d", &n);

    if (n == 0) {
        printf("0");
        return 0;
    }

    int mod = 0;
    while (n != 0) {
        mod = n % (-3);
        n = (n - mod) / (-3);
        if (mod < 0) {
            mod += 3;
            n ++;
        }
        v.push_back(mod);
        // printf("%d %d\n", mod, n);
    }

    for (int i = v.size() - 1; i >= 0; i--) {
        printf("%d", v[i]);
    }
}

二分法

  • 寻找第一个元素x的下标，没有就返回-1
  • 递增序列，则寻找从左到右，第一个满足x的元素下标
#include <cstdio>
#include <algorithm>
#define maxn 100000

using namespace std;
int n, x, a[maxn];

// 实现的是lower_bound：找出第一个大于等于x的元素下标
int binarySearch() {
    int l = 0, r = n; // 左闭右闭，搜查范围是[0, n]，n为找不到的情况
    int mid = (l + r) / 2; 
    while (l < r) { // 夹出一个元素，l=r
        if (a[mid] < x) { // 当mid所指元素小于x，说明第一个大于等于x的元素应该在mid的右边
            l = mid + 1;
        } else { // 反之，第一个大于等于x的元素在mid的左边或者为mid
            r = mid;
        }

        mid = (l + r) / 2;
    }

    return l;
}

int main() {
    scanf("%d %d", &n, &x);

    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    int idx = binarySearch();

    if (idx < n && a[idx] == x) printf("%d", idx);
    else printf("-1");
}
  • 寻找最后一个元素x的下标，没有就返回-1
#include <cstdio>
#define maxn 100000

using namespace std;
int n, x;
int a[maxn];

// 实现upper_bound
int BinarySearch () {
    int l = 0, r = n;
    int mid = (l + r) / 2;

    while (l < r) {
        if (a[mid] <= x) { // 第一个大于x的元素在mid的右边
            l = mid + 1;
        } else { // 在mid的左边
            r = mid;
        }

        mid = (l + r) / 2;
    }

    return l;
}

int main() {
    scanf("%d %d", &n, &x);

    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    int idx = BinarySearch();

    if (idx > 0 && a[idx-1] == x) printf("%d", idx-1);
    else printf("-1");
    return 0;
}

旋转数组🥲

    int l = 0, r = n - 1, mid;
    while (l < r) {
        mid = (l + r) / 2;
        if (a[mid] > a[r]) {
            l = mid + 1;
        } else {
            r = mid;
        }
    }

求方程根

木棒切割

总结

如果l = m, r = m -1, mid = （r+m+1）/ 2 不然会死循环，干
如果l = m + 1, r = m, mid = （r+m）/ 2

双指针

归并排序

#include <cstdio>
#define maxn 1000

using namespace std;

void merge(int a[], int l1, int r1, int l2, int r2) {
    int idx1 = l1, idx2 = l2, idx = 0;
    int temp[maxn];
    while (idx1 <= r1 && idx2 <= r2) {
        if (a[idx1] < a[idx2]) {
            temp[idx++] = a[idx1++];
        } else {
            temp[idx++] = a[idx2++];
        }
    }

    while (idx1 <= r1) {
        temp[idx++] = a[idx1++];
    }

    while(idx2 <= r2) {
        temp[idx++] = a[idx2++];
    }

    for (int i = 0; i < idx; i++) {
        a[l1 + i] = temp[i];
    }
}

void mergesort(int a[], int left, int right) { // 用来划分的- -
    if (left < right) { // 当只剩一个元素时返回
        int mid = (left + right) / 2;
        mergesort(a, left, mid);
        mergesort(a, mid+1, right);
        merge(a, left, mid, mid + 1, right); 
    }
}

int main() {
    int n, a[maxn];
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    mergesort(a, 0, n-1);

    for (int i = 0; i < n; i++) {
        printf("%d", a[i]);
        if (i != n-1) printf(" ");
    }
}

前缀和

平衡数组

  • 累加累乘这些可能会溢出，前缀和尤为注意
  • 注意到a[i]的取值只有1，2，3，利用这一点简化
#include <cstdio>
#include <algorithm>
#define maxn 1000

using namespace std;
int main() {
    int n, a[maxn], lefttwo[maxn], leftthree[maxn], cnt2 = 0, cnt3 = 0;

    scanf("%d", &n);

    fill(lefttwo, lefttwo + n, 0);
    fill(leftthree, leftthree + n, 0);
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
        if (a[i] == 2) {
            cnt2 ++;
        } else if (a[i] == 3){
            cnt3 ++;
        }
        lefttwo[i] = cnt2;
        leftthree[i] = cnt3;
    }

    if (lefttwo[n-1] % 2 == 1 || leftthree[n-1] % 2 == 1) {
        printf("-1");
        return 0;
    }

    for (int i = 0; i < n; i++) {
        if (lefttwo[i]*2 == lefttwo[n-1] && leftthree[i]*2 == leftthree[n-1]) {
            printf("%d", i);
            break;
        }
    }

}

快速排序

#include <cstdio>
#define maxn 1000

using namespace std;
int Partition(int a[], int l, int r) {
    int temp = a[l]; // 主元
    while (l < r) {
        while (l < r && temp < a[r]) r--; // 右边的比主元大，反之扔左边
        a[l] = a[r];
        while (l < r && a[l] <= temp) l++; // 左边小于等于主元，反之扔右边
        a[r] = a[l];
    }

    a[l] = temp; // l==r，主元放置到了最终的位置上
    return l;
}

void quicksort(int a[], int l, int r) {
    if (l < r) { // 只有一个元素就不用排啦
        int pos = Partition(a, l, r); // 得到一个元素的位置
        quicksort(a, l, pos-1);
        quicksort(a, pos+1, r);
    }
}

int main() {
    int n, a[maxn];
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    quicksort(a, 0, n-1);

    for (int i = 0; i < n; i++) {
        printf("%d", a[i]);
        if (i != n-1) printf(" ");
    }

}

数学

最大公约数

int gcd(int a, int b) {
	if (b == 0) return a;
	else return gcd(b, a%b);
}

最小公倍数

  • a，b的最小公倍数：ab/d，d是a，b的最大公约数
  • 为了防止溢出可以写成：a/d * b

素数

质因子分解

#include <cstdio>
#include <vector>
#include <utility>

using namespace std;
typedef pair<int, int> factor;

int main() {
    int n;
    vector<factor> v;
    scanf("%d", &n);

    for (int i = 2; i*i <= n; i++) { // 筛选[2, sqrt(n)]的质数
        int cnt = 0;
        while (n % i == 0) { // 包含了筛法，所以不用使用素数表
            cnt ++;
            n /= i;
        }
        if (cnt != 0) v.push_back(factor(i, cnt));
    }

    if (n != 1) { // n为质数的情形
        v.push_back(factor(n, 1));
    }

    for (int i = 0; i < v.size(); i++) {
        printf("%d %d", v[i].first, v[i].second);
        if (i != (int)v.size() - 1) printf("\n");
    }
}
  • 求n!的质因子：n!中有（n/p + n/p ^ 2 + n/p ^ 3 + …）个质因子p
  • n！的末尾有多少个零：末尾0的个数等于n！中因子10的个数，而10的个数等于n！中质因子5的个数。

组合数

#include <cstdio>
#include <cstring>
#define maxn 51
typedef long long LL;

using namespace std;
// c[i][j] = c[i-1][j] + c[i-1][j-1]:c[j/i] = c[j/i-1] + c[j-1/i-1]
// c[i][j] = c[i][n-j]:c[j/i] = c[i-j/i]
int main() {
    LL n, m;
    LL c[maxn][maxn];

    scanf("%lld %lld", &n, &m);

    // 初始化
    // c[0/i] = 1, c[i/i] = 1
    memset(c, 0, sizeof(c));
    for (LL i = 0; i <= n; i++) {
        c[i][0] = 1;
        c[i][i] = 1;
    }

    for (LL i = 2; i <= n; i++) {
        for (LL j = 0; j <= i/2; j++) {
            c[i][j] = c[i-1][j] + c[i-1][j-1];
            c[i][i-j] = c[i][j];
        }
    }

    printf("%lld", c[n][m]);
}
  • 组合数取模：c[m/n] % p
#include <cstdio>
#include <cstring>
#define maxn 501
typedef long long LL;

using namespace std;
// c[i][j] = c[i-1][j] + c[i-1][j-1]:c[j/i] = c[j/i-1] + c[j-1/i-1]
// c[i][j] = c[i][n-j]:c[j/i] = c[i-j/i]
int main() {
    LL n, m, p;
    LL c[maxn][maxn];

    scanf("%lld %lld %lld", &n, &m, &p);

    // 初始化
    // c[0/i] = 1, c[i/i] = 1
    memset(c, 0, sizeof(c));
    for (LL i = 0; i <= n; i++) {
        c[i][0] = 1;
        c[i][i] = 1;
    }

    for (LL i = 2; i <= n; i++) {
        for (LL j = 0; j <= i/2; j++) {
            c[i][j] = (c[i-1][j] + c[i-1][j-1]) % p; // 这里取模就好
            c[i][i-j] = c[i][j];
        }
    }

    printf("%lld", c[n][m]);
}
华为OD算法考点分类
程序员阿甘的博客
03-11 8万+
考点分类
二分查找 Binary Search
yake1965
02-27 1736
掌握二分法的精髓，内容少而精，重点在于理解插入位置与目标位置。解答了 100 多道 leetcode 题目。
【算法系列】二分、排序、高精度、前缀和、双指针、差分
愿不负所爱
03-05 425
常见问题算法模板前言二分模板排序模板高精度前缀和模板差分模板 前言 本博客从常见的算法模板出发，对常见算法进行归类并给出相应的模板，希望对您能有所帮助。 二分模板 模板一： 模板二： 排序模板 高精度 前缀和模板 差分模板 ...
【马蹄集】—— 前缀和与差分专题
酱懵静的博客
05-23 1351
实际上，题目的要求是找出指定序列中所有“均值不低于指 $t$ 的子序列”个数。一个很直观的想法是，既然你要求序列均值不低于 $t$ ，那我们可以将原序列中的每个数都与 $t$ 做差，这样一来，得到的新序列里一旦存在某串序列之和大于 0，那就说明这段序列的均值是大于 $t$ 的（即符合要求的序列）
最大的和
江上酒
05-12 183
文章目录题目一、主要思路二、实现双指针做法前缀和做法三. 总结 题目 给定一个长度为 n 的正整数数列 a1,a2,…,an。 初始时，数列中的每个元素要么处于可选状态，要么处于不可选状态。 你可以选择一个长度恰好为 k 的区间 [i,i+k−1]，使得 ai∼ai+k−1 这 k 个元素的状态全部变为可选。 请问，在经过此操作后，所有处于可选状态的元素之和最大是多少。 输入格式 第一行包含两个整数 n 和 k。 第二行包含 n 个整数 ai。 第三行包含一个长度为 n 的 01 序列，如果第 i 个数
保研机试——1基础算法（排序、哈希、模拟（日期、图形、查找、进制、字符串）、递归与分治、贪心、前缀和与差分、双指针）
ZhengrongYue的博客
09-20 2315
保研机试——1基础算法（排序、日期、哈希、排版、查找、贪心）
【十五届蓝桥杯备赛】几个月没打代码的康复训练集
weixin_61639349的博客
04-04 1030
因为临近毕业，已经很久没练算法了，考前临时抱抱佛脚，巩固一些基础模板和Java特性，希望考前能把最基本的模板都练一练，大概会有二分、前缀和、差分、双指针、BFS、区间合并等，希望能坚持更完。
leetcode-滑动窗口/双指针/哈希表
MaYingColdPlay的博客
12-12 5091
5955 摘水果 力扣https://leetcode-cn.com/problems/maximum-fruits-harvested-after-at-most-k-steps/solution/qiu-chu-fan-wei-nei-qian-zhui-he-zui-da-tfeoy/
前缀和的综合应用（力扣C++题解）
lihua777的博客
02-13 1273
前缀和与哈希滑动窗口指针的综合
c语言 指针与函数变量,c语言函数指针定义,指针函数和变量指针的区别
weixin_39965161的博客
05-18 437
f=func; /* 将func函数的首地址赋给指针f */赋值时变量func不带空格，也不带参数，由于func代表变量的首地址，因此经过赋值之后，指针f就指向数组func(x)的代码的首地址。指针函数和变量指针的区别：1、指针函数是指带指针的变量，即本质是一个函数。函数返回类别是某一类型的指针类型标识符 *函数名(参数表)int *f(x，y);空语句和复合语句27413.3.2控制语句2751...
贪心与二分
m0_60440185的博客
08-11 315
因为贪心一般要求一直局部最优解，所以一般会在此原则上用二分来优化结果的获得，所以将二分与贪心放在一起。本人blo可能有些许不严谨的地方，如果读者发现有任何问题，欢迎在评论区批评指正，大家一起讨论。
《英雄编程体验课》第 14 课 | 题海战术
热门推荐
英雄哪里出来
10-07 4万+
「 让天下没有难学的算法 」
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-22 1286
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
【LeetCode】【算法】136. 只出现一次的数字
passer__jw767的博客
11-12 236
LeetCode 136. 只出现一次的数字
16 合并区间
weixin_47521269的博客
11-12 751
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1162
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
1-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 160
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
24/11/14 算法笔记 GMM高斯混合模型
yyyy2711的博客
11-14 732
高斯混合模型（Gaussian Mixture Model，简称 GMM）是一种概率模型，用于表示具有多个子群体的数据集，其中每个子群体的数据分布可以用高斯分布（正态分布）来描述。GMM 是一种软聚类方法，意味着它为每个数据点分配一个属于每个聚类的概率分布，而不是硬聚类方法中的严格分类。
计算2的N次方
最新发布
Lemon_C17y的博客
11-15 31
任意给定一个正整数N(N<=100)，计算2的n次方的值。
优化暴力：双指针与前缀和算法详解
"双指针和前缀和是两种在算法中常见的优化技术，它们主要用于解决数组和区间操作的问题。双指针技术常用于优化暴力解法，将时间复杂度降低到线性级别，而前缀和则允许我们快速计算数组区间内的元素总和。本文将详细...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值