寒假训练——第四周（素数|因数）

最新推荐文章于 2024-06-13 10:13:20 发布
最新推荐文章于 2024-06-13 10:13:20 发布
阅读量138 收藏
点赞数
分类专栏： vj集训补题 文章标签： 算法 图论 c++ 数论 质因数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61409183/article/details/126572691
版权

目录

A - 质因数分解

A - 质因数分解

思路：

  • 分解质因数板子

代码如下：

#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>

#define fast ios::sync_with_stdio(false), cin.tie(nullptr); cout.tie(nullptr)

#define mkpr make_pair
#define x first
#define y second
#define int long long

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;

const int N = 15, M = N * 2;
const int YB = 8, YM = 1e8;

const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int T, cases;
int n, m, times;
PII a;

void solve()
{
    cin >> n;
    int t;
    for (int i = 2; i <= n / i; i ++ )
        if(n % i == 0)
        {
            t = i;
            break;
        }
    cout << n / t << endl;

    return;
}

signed main()
{
    T = 1;
    //fast;cin >> T;
    //scanf("%d", &T);

    //for (cases = 1; cases <= T; cases ++ )
    while(T -- )
        solve();

    return 0;
}

B - Prime Independence

B - Prime Independence

思路：

  • 严格超过我的承受范围，，不会写（望大神浇浇！）

C - Division

C - Division

题意总结：

  • 找到满足p%x == 0 && q % x != 0的，最大的 x。

思路：

  • 分解质因数

具体实现：

  • 若 p % q != 0，x(max) = p直接得到答案
  • 若p % q == 0，证明 p和q分解质因数得到的质因数相同，但质因数的次数不同；
    1. 我们的目的就转化为找到集合ok中的最大值k，其中集合ok为将p的任意的一个质因数的次数变为q中的（此质因数的）次数 -1，
    2. 即、使 q % ok集合中的任意值 != 0，如此即找到答案（满足p % k == 0 && q % k != 0的数的最大值k）
  • 考虑到对 p分解质因数可能会 T L E TLE TLE ，我们只对q分解质因数，并依次枚举每个质因数
  • 时间复杂度为： O (   q ∗ l o g 2 ( p )   ) O(~\sqrt{q} * log2(p)~) O( q ​∗log2(p) )最大为1e6 ~ 1e7，可以过掉，完全没压力！

代码如下：

#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>

#define fast ios::sync_with_stdio(false), cin.tie(nullptr); cout.tie(nullptr)

#define mkpr make_pair
#define x first
#define y second
#define int long long

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;

const int N = 15, M = N * 2;
const int YB = 8, YM = 1e8;

const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int T, cases;
int n, m, times;
PII a;

void solve()
{
    cin >> p >> q;

    if(p % q)
    {
        cout << p << endl;
        return;
    }

    int res = 0, t;
    // n % x == 0 && m % x != 0
    for (int i = 1; i <= q / i; i ++ )
    {
        if(q % i == 0)
        {
            if(i > 1)
            {
                t = p;
                while(t % q == 0) t /= i;
                res = max(res, t);
            }
            
            t = p;
            while(t % q == 0) t /= (q / i);
            res = max(res, t);
        }
    }

    cout << res << endl;

    return;
}

signed main()
{
    T = 1;
    fast;cin >> T;
    //scanf("%d", &T);

    //for (cases = 1; cases <= T; cases ++ )
    while(T -- )
        solve();

    return 0;
}

D - Half of Same

D - Half of Same

思路：

  • 暴力枚举 + 分解质因数

具体实现：

  • 若可以获得相同的 n/2个数字，则必定至少可以获得一组数量大于n/2的a[i]，所以得出至少n/2的相同的数可以为a[i]的某一个数
  • 如此我们枚举每一个v = a[i]，对每一个大于当前相等值a[i]的a[j]分解质因数，找出a[j]集合中至少在 n/2 - same个数中出现的最大数，更新最大值，从而得到结果
  • 时间复杂度为： O ( n 2 m a x ( a [ i ] ) ) O(n^2\sqrt{max(a[i])}) O(n2max(a[i]) ​)，最多为1e6 ~ 2e6，可以过。

代码如下：

#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>

#define fast ios::sync_with_stdio(false), cin.tie(nullptr); cout.tie(nullptr)

#define mkpr make_pair
#define x first
#define y second
#define int long long

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;

const int N = 50, M = N * 2;
const int YB = 8, YM = 1e8;

const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int T, cases;
int n, m, times;

map<int, int> divide_cnt;

void divide(int x)
{
    for (int i = 1; i <= x / i; i ++ )
        if(x % i == 0)
        {
            divide_cnt[i] ++;
            if(x / i != i) divide_cnt[x / i] ++;
        }
}

void solve()
{
    cin >> n;

    int a[N];
    for (int i = 0; i < n; i ++ )
        cin >> a[i];

    int res = 0;

    for (int i = 0; i < n; i ++ )
    {
        divide_cnt.clear();
        int v = a[i];
        int same = 0;
        vector<int> d;
        for (int j = 0; j < n; j ++ )
            if(a[j] == v) same ++;
            else if(a[j] > v) d.push_back(a[j] - v);

        if(same >= n / 2)
        {
            cout << -1 << endl;
            return;
        }

        for (auto it : d)
            divide(it);

        for (auto it : divide_cnt)
            if(it.y >= n / 2 - same)
                res = max(res, it.x);
    }

    cout << res << endl;

    return;
}

signed main()
{
    T = 1;
    fast;cin >> T;
    //scanf("%d", &T);

    //for (cases = 1; cases <= T; cases ++ )
    while(T -- )
        solve();

    return 0;
}

E - 分解因数

E - 分解因数

思路：

  • 递归 + 分解质因数

具体实现：

  • divide函数为对整数x进行因数分解，分解出的因数大于等于st的方案数，如此递归求解即可
  • 递归边界为：x == 1，此时返回 1

代码如下：

#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <bitset>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>

#define fast ios::sync_with_stdio(false), cin.tie(nullptr); cout.tie(nullptr)

#define mkpr make_pair
#define x first
#define y second
#define int long long

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const LL LL_INF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-9;

const int N = 50, M = N * 2;
const int YB = 8, YM = 1e8;

const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

int T, cases;
int n, m, times;

map<int, int> divide_cnt;

int divide(int x, int st)
{
    if(x == 1) return 1;

    int res = 0;
    for (int i = st; i <= x; i ++ )
        if(x % i == 0) res += divide(x / i, i);

    return res;
}

void solve()
{
    cin >> n;

    cout << divide(n, 2) << endl;

    return;
}

signed main()
{
    T = 1;
    fast;cin >> T;
    //scanf("%d", &T);

    //for (cases = 1; cases <= T; cases ++ )
    while(T -- )
        solve();

    return 0;
}
AC自动寄
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
蓝桥测试3->寒假训练题集
不忘初心
02-13 808
hehe
寻找质数——————————————————
07-15
寻找质数——————————————————
寒假训练——第四周（筛法）
m0_61409183的博客
08-30 140
线性筛（欧氏筛） 或 埃氏筛 的模板，扩展，例题，帮助新手萌新加深对筛法的理解
2020寒假训练 第一周
qq_42804223的博客
02-10 148
#第一周 2020牛客寒假算法基础集训营1 rin和快速迭代 题意：
寒假集训——数论基础
weixin_52595313的博客
02-23 554
第一次b站直播讲课，还真有些紧张，准备了好久，生怕被小朋友们问住。最后的事实证明，寒假是真没什么人学算法啊哈哈哈，就当你们都去看冬奥了（哼） 一，gcd,lcm算法 1.gcd算法——求解两个数的最大公因数 基本方法——辗转相除法 1.迭代写法 int gcd(int a,int b) { int t; while(b)//while(b!=0)时进入循环 { t=a%b; a=b;//将原来的除数作为新的被除数 .
训练赛——WZU ACM No.229(寒假训练赛1)
linjiayina的博客
01-24 121
A - Links and Pearls 题目链接 题目大意 给定一串由线("-")和珍珠(“o”)构成的项链，问随意移动线或珍珠，是否能让每两个相邻珍珠之间的线的数量相等，若能，则输出“YES”，否则输出“NO”。 分析 可以分别对"-“和"o"的个数进行统计，然后看”-"的个数是否为"o"的个数的倍数。 #include<bits/stdc++.h> using namespace std; int main() { string s; cin >> s; int a =
大一寒假训练
逆境出勇者
01-30 591
期末考试加军训，大概一个月没碰了 现在寒假开启了，开始训练 集训前有三个星期，就刷cf题吧 目标不高，25道比自己水平高一些的题目 搞起。 1.30
寒假训练营 第二十节 数论基础（三）总结
qq_63391968的博客
02-19 182
筛质数
大一寒假培训（五）——Gcd&Lcm与快速幂取模
Icey_dying的博客
01-08 568
大一寒假培训（五）——Gcd&Lcm与快速幂取模 现在先学习一下最大公约数与最小公倍数的相关知识 求最大公约数的方法： 1.辗转相除法（欧几里得算法） 2.辗转相减法（更相减损术） 3.素因子法（最后提一下） 辗转相除法 欧几里得算法又叫辗转相除法,用来求得两个数的最大公约数,记作gcd(a,b) 其原理如下: 设有n,m(m>n),n和m的最大公约数为t 那么：n=k1...
寒假第一、二场合集
m0_73744146的博客
01-15 215
蒟蒻练习中出现的一些问题和补题时学到的一点东西，如果文章有任何问题，欢迎随时踢我。
C语言练习——判断是否是素数.c
06-02
C语言练习——判断是否是素数.c
分解质因数与判断是否是素数并验证哥德巴赫猜想
10-04
1.求出指定范围内的所有素数（只能被1和自身整除的数）。 2.把从键盘上输入的一个大于等于3的整数分解为质因子的乘积。 3.哥德巴赫猜想之一是，任何一个不小于6的偶数都可以表示为两个素数之和，例如，6=3+3，8=3+5...
判断质数和用算数基本定理分解质因数
12-22
质数又称为素数，是指大于1的并且除了1和它本身外，没有其他因数的自然数。 判断一个数是否是质数 假设该数为n， 我们只需要判断[2, n\sqrt{n}n​]内是否有n的因子。如果有，则n为合数，否则，n为质数。 public ...
第7章 数组-7数组的其他应用——筛法求素数1
08-03
第7章 数组——数组的其他应用之筛法求素数C语言程序设计第7章 数组数组的其他应用除了一维、二维数据表、矩阵运算等，还有其他应用吗？问题：如何判断一个整数x是否
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 406
【代码】力扣LCP 08.剧情触发时间。
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 495
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
LeetCode 算法：轮转数组c++
小金牛来了
06-09 687
LeetCode 算法：轮转数组c++
LSS 和 BEVDepth算法解读
最新发布
pytorch内部机制解读
06-13 937
当前BEV的研究大都基于深度学习的方法，从组织BEV特征信息的方式来看，主流方法分属两类：自底向上方法和自顶向下方法。自底向上方法比较早的代表工作是LSS，后来BEVDet、BEVDepth等也是基于LSS的框架来进行优化。自底向上方法核心是：Lift——对各相机的图像显性地估计像平面下采样后特征点的深度分布，得到包含图像特征的视锥（点云）；Splat——结合相机内外参把所有相机的视锥（点云）分配到BEV网格中，对每个栅格中的多个视锥点进行sum-pooling计算，形成BEV特征图；
php编程100——1000之间的素数
03-23
素数是只能被1和自身整除的正整数。以下是一个PHP代码示例来找出100到1000之间的素数： ```php function isPrime($num) { if ($num ) { return false; } for ($i = 2; $i ($num); $i++) { if ($num % $i == 0...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AC自动寄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值