洛谷题解——P2043 质因子分解

本文介绍了一种高效算法,用于对N!进行质因数分解,适用于N小于等于10000的情况。文章详细解释了如何避免直接计算N!,而是通过循环分解1到N的每个数来获取所有质因数及其指数。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目相关

题目链接

洛谷,https://www.luogu.com.cn/problem/P2043

我的OJ,http://47.110.135.197/problem.php?id=5279

题目描述

对 N! 进行质因子分解。

输入格式

输入数据仅有一行包含一个正整数 N,N <= 10000。

输出格式

输出数据包含若干行,每行两个正整数 p,a,中间用一个空格隔开。表示 N! 包含 a 个质因子 p,要求按 p 的值从小到大输出。

输入样例

10

输出样例

2 8
3 4
5 2
7 1

样例说明

10!=3628800=(2^8)*(3^4)*(5^2)*7

数据规模

N ≤ 10000。

题解报告

题意分析

非常简单的一个质因数分解题目。属于数论的知识点。

本题唯一的难度在于不能直接求解 N!,因为我们知道 C++ 中固有数据类型中,能表示最大的数据为 2^64-1,也就是 unsigned long long 类型。有些记不清楚了,好像 23! 就超过了 2^64-1 这个数据。而题目中给出的 N 最大值为 1000。

本题为的考点就是数论中的质因数分解。我们可以参考质数判定来实现,再使用 STL 中的 map 这个数据类型对结果进行保存,就可以满足本题的要求。

质因数分解

思路就是从 2 开始,利用质数逐一判断。代码如下。

map<int, int> ans;

//对x求质因数
void factor(int x) {
    for (int i=2; i*i<=x; i++) {
        while (0==x%i) {
            ans[i]++;
            x /= i;
        }
    }
    if (x>1) {
        ans[x]++;
    }
}

注意函数中的 for 循环里套了一个 while 循环,其目的是实现对某个质数幂进行判断。

如 1024 = 2^10,通过这个函数,我们可以分解出 2 和 10。

样例数据分析

N = 10,10! = 10*9*8*7*6*5*4*3*2,但是我们不能直接计算 10!,因为 N 大了,数据会超过 C++ 表示的范围,同时也是没有必要进行阶乘计算。我们只需要使用循环分解分别求 10、9、8、7、6、5、4、3、2 的质因数即可。

10 = (2^1) * (5^1)

9 = (3^2)

8 = (2^3)

7 = (7^1)

6 = (2^1) * (3^1)

5 = (5^1)

4 = (2^2)

3 = (3^1)

2 = (2^2)

这样,我们就知道了 10! 最终可以表示为:(2^8) * (3^4) * (5^2) * (7^1)。

数据规模分析

N ≤ 10000。同时通过上面的样例数据分析过程,我们可以推断,使用 int 表示足够。

算法思路

1、读入 N。

2、质因数分解函数。

3、从 2 到 N 循环,对每个 i 进行质因数分解。

4、输出。

AC 参考代码

#include <bits/stdc++.h>

using namespace std;

map<int, int> ans;

//对x求质因数
void factor(int x) {
    for (int i=2; i*i<=x; i++) {
        while (0==x%i) {
            ans[i]++;
            x /= i;
        }
    }
    if (x>1) {
        ans[x]++;
    }
}

int main() {
    int n;
    cin>>n;

    for (int i=2; i<=n; i++) {
        factor(i);
    }

    map<int, int>::iterator it;
    for (it=ans.begin(); it!=ans.end(); it++) {
        cout << it->first << " " << it->second << endl;
    }
	
    return 0;
}

 

P3538 [POI 2012] OKR-A Horrible Poem 提交答案加入题单复制题目 提交 15.09k 通过 3.62k 时间限制 1.50s 内存限制 125.00MB 题目编号 P3538 提供者 洛谷 难度 省选/NOI− 历史分数 66 提交记录 查看题解 题目反馈 标签 POI(波兰) 2012 相关讨论进入讨论版 推荐题目 复制 Markdown 中文 展开 进入 IDE 模式 题目描述 Byteie 男孩需要背诵一首诗的某个片段。这首诗遵循现代艺术的最高标准,是一个仅由小写英文字母组成的长字符串。显然,它听起来很糟糕,但这还不是 Byteie 最担心的。首先,他完全忘记了自己该背诵哪个片段。而且所有片段看起来都很难记…… 不过仍有希望:诗中某些部分呈现出特定的规律性。特别是,时常会出现某个片段(记作 A)仅是另一个片段(记作 B)的多次重复(即 A=BB⋯B,可表示为 A=B k ,其中 k≥1 为整数)。这种情况下,我们称 B 是 A 的一个完整周期(特别地,每个字符串都是其自身的完整周期)。如果一个片段存在很短的完整周期,Byteie 的任务就会变得简单。问题在于……到底是哪个片段呢? 送给 Byteie 一份礼物吧——编写一个程序,它会读入整首诗以及 Byteie 怀疑可能需要背诵的片段列表,并针对每个片段找出其最短的完整周期 输入格式 第一行:一个整数 n (1≤n≤500,000),表示诗的长度。 第二行:一个长度为 n 的字符串,表示诗的内容。字符串中字符的位置依次编号为 1 到 n。 第三行:一个整数 q (1≤q≤2,000,000),表示查询的片段数量。 接下来的 q 行:每行包含两个整数 a i ​ 和 b i ​ (1≤a i ​ ≤b i ​ ≤n),用空格分隔。表示查询从位置 a i ​ 开始到位置 b i ​ 结束的诗的片段的最短完整周期的长度。 在总计占比 42% 分数的测试点中,额外满足 n≤10,000。其中占比 30% 分数的测试点还满足 q≤10,000。 输出格式 输出 q 行到标准输出。第 i 行输出一个整数,表示第 i 个查询的答案。 显示翻译 题意翻译 输入输出样例 输入 #1复制 8 aaabcabc 3 1 3 3 8 4 8 输出 #1复制 1 3 5 说明/提示 题面翻译由 deepseek-R1 提供。 我的代码如下,请检查 #include <bits/stdc++.h> using namespace std; using ll = long long; const ll base = 1313131; const ll Mod = 1e9 + 9; const int N = 5e5 + 10; ll p[N], f[N]; ll n; string s; bool check(int a, int b, int x) { if ((b - a + 1) % x != 0) return false; int len = b - a + 1; if(f[n - len] != (f[n] - f[len + 1] * p[n - len] % Mod + Mod) % Mod) return false; if((n - len) % len != 0) return false; return true; } void solve(ll a, ll b) { ll len = b - a + 1; ll ans = len; vector<ll> vec; for (int i = 1; i * i <= len; i++) { if (len % i == 0) { vec.push_back(i); if (i != len / i) { vec.push_back(len / i); } } } sort(vec.begin(), vec.end()); for (ll x : vec){ if (check(a, b, x)) { ans = x; break; } } cout << ans << '\n'; } void pre_work() { p[0] = 1; for (int i = 1; i <= n; i++) { p[i] = p[i - 1] * base % Mod; f[i] = (f[i - 1] * base % Mod + s[i] - 'a' + 1 + Mod) % Mod; } } int main() { // freopen("1.in", "r", stdin); ios::sync_with_stdio(false); cin.tie(0); cin >> n; cin >> s; s = '#' + s; pre_work(); ll q; cin >> q; while (q--) { ll l, r; cin >> l >> r; solve(l, r); } return 0; }
最新发布
07-24
### 洛谷题目解答与算法解析 洛谷是一个广受欢迎的在线编程学习平台,提供大量算法题目和题解资源。针对不同的问题,用户可以选择适合自己的算法进行练习或解决问题。 #### DFS(深度优先搜索)在洛谷题目中的应用 DFS是一种经典的回溯算法,通常用于解决迷宫类问题或者路径探索问题。例如,在P1605题目中,使用DFS可以统计从起点到终点的所有可行路径数量。通过递归实现对每个方向的探索,并在满足条件时继续深入,直到到达目标点。以下代码展示了如何实现这一逻辑: ```cpp int dir[4][2] = {0, 1, 1, 0, 0, -1, -1, 0}; // 方向数组 bool check(int nx, int ny) { return nx >= 1 && nx <= n && ny >= 1 && ny <= m; } void dfs(int x, int y) { vis[x][y] = true; for (int i = 0; i < 4; i++) { int nx = x + dir[i][0]; int ny = y + dir[i][1]; if (check(nx, ny) && vis[nx][ny] == false && map[nx][ny] != '#') { dfs(nx, ny); } } vis[x][y] = false; // 回溯 } ``` 上述代码中,`dir`数组定义了四个方向的增量,`check`函数判断坐标是否合法,而`dfs`函数则递归地遍历所有可能的路径并进行回溯[^3]。 #### Dijkstra算法的应用 Dijkstra算法是解决最短路径问题的经典方法,适用于图中节点之间的加权边。以最小体力消耗为例,相邻格子的差值作为代价,可以通过构建小根堆来优化路径选择。具体来说,将每个节点的代价存储在堆中,并按照代价从小到大排序,逐步扩展路径直至找到目标点。以下是Dijkstra算法的核心部分: ```cpp struct Node { int x, y, cost; bool operator<(const Node& other) const { return cost > other.cost; } }; priority_queue<Node> pq; void dijkstra() { pq.push({start_x, start_y, 0}); dist[start_x][start_y] = 0; while (!pq.empty()) { Node current = pq.top(); pq.pop(); if (current.x == target_x && current.y == target_y) break; for (int i = 0; i < 4; i++) { int nx = current.x + dir[i][0]; int ny = current.y + dir[i][1]; if (check(nx, ny)) { int new_cost = abs(grid[nx][ny] - grid[current.x][current.y]); if (dist[nx][ny] > dist[current.x][current.y] + new_cost) { dist[nx][ny] = dist[current.x][current.y] + new_cost; pq.push({nx, ny, dist[nx][ny]}); } } } } } ``` 在此代码中,`Node`结构体定义了节点的信息,包括坐标和当前代价;`priority_queue`实现了小根堆的功能,确保每次取出代价最小的节点进行扩展[^2]。 #### 回溯算法在经典题目中的运用 回溯算法是解决组合、排列等问题的重要工具。例如,在N皇后问题中,通过尝试在每一行放置一个皇后,并检查是否满足列和对角线的约束条件,最终找出所有合法的布局方案。以下是N皇后问题的核心代码: ```cpp bool is_safe(int row, int col) { for (int i = 0; i < row; i++) { if (board[i] == col || abs(row - i) == abs(col - board[i])) { return false; } } return true; } void solve(int row) { if (row == n) { solutions++; return; } for (int col = 0; col < n; col++) { if (is_safe(row, col)) { board[row] = col; solve(row + 1); } } } ``` 此代码中,`is_safe`函数检查当前位置是否安全,`solve`函数递归地尝试每一列的可能性,并在找到完整解后增加计数器[^3]。 #### 总结 DFS、Dijkstra以及回溯算法在洛谷题目中均有广泛应用。DFS适合处理路径探索和数量统计问题,Dijkstra适用于最短路径问题,而回溯算法则擅长解决组合、排列等需要穷举可能性的问题。掌握这些算法及其变种对于提升编程能力至关重要。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

努力的老周

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

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

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

打赏作者

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

抵扣说明:

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

余额充值