test/yosupo/enumerate_primes.test.cpp

• View this file on GitHub
• Last update: 2024-09-01 13:40:30+09:00
• Problem: https://judge.yosupo.jp/problem/enumerate_primes

Depends on

• CSR 表現を用いた二次元配列 他 (src/Internal/ListRange.hpp)
• 素数の列挙 (src/NumberTheory/enumerate_primes.hpp)

Code

// competitive-verifier: PROBLEM https://judge.yosupo.jp/problem/enumerate_primes
// competitive-verifier: TLE 3
// competitive-verifier: MLE 2048
#include <iostream>
#include <vector>
#include "src/NumberTheory/enumerate_primes.hpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 int N, A, B;
 cin >> N >> A >> B;
 auto ps= enumerate_primes(N);
 int pi= ps.size();
 vector<int> ans;
 for (int i= 0; A * i + B < pi; i++) ans.push_back(ps[A * i + B]);
 int X= ans.size();
 cout << pi << " " << X << '\n';
 for (int i= 0; i < X; i++) cout << ans[i] << " \n"[i == X - 1];
 return 0;
}

#line 1 "test/yosupo/enumerate_primes.test.cpp"
// competitive-verifier: PROBLEM https://judge.yosupo.jp/problem/enumerate_primes
// competitive-verifier: TLE 3
// competitive-verifier: MLE 2048
#include <iostream>
#include <vector>
#line 2 "src/NumberTheory/enumerate_primes.hpp"
#include <algorithm>
#include <cstdint>
#line 4 "src/Internal/ListRange.hpp"
#include <iterator>
#include <type_traits>
#define _LR(name, IT, CT) \
 template <class T> struct name { \
  using Iterator= typename std::vector<T>::IT; \
  Iterator bg, ed; \
  Iterator begin() const { return bg; } \
  Iterator end() const { return ed; } \
  size_t size() const { return std::distance(bg, ed); } \
  CT &operator[](int i) const { return bg[i]; } \
 }
_LR(ListRange, iterator, T);
_LR(ConstListRange, const_iterator, const T);
#undef _LR
template <class T> struct CSRArray {
 std::vector<T> dat;
 std::vector<int> p;
 size_t size() const { return p.size() - 1; }
 ListRange<T> operator[](int i) { return {dat.begin() + p[i], dat.begin() + p[i + 1]}; }
 ConstListRange<T> operator[](int i) const { return {dat.cbegin() + p[i], dat.cbegin() + p[i + 1]}; }
};
template <template <class> class F, class T> std::enable_if_t<std::disjunction_v<std::is_same<F<T>, ListRange<T>>, std::is_same<F<T>, ConstListRange<T>>, std::is_same<F<T>, CSRArray<T>>>, std::ostream &> operator<<(std::ostream &os, const F<T> &r) {
 os << '[';
 for (int _= 0, __= r.size(); _ < __; ++_) os << (_ ? ", " : "") << r[_];
 return os << ']';
}
#line 5 "src/NumberTheory/enumerate_primes.hpp"
namespace nt_internal {
using namespace std;
vector<int> ps, lf;
void sieve(int N) {
 static int n= 2;
 if (n > N) return;
 if (lf.resize((N + 1) >> 1); n == 2) ps.push_back(n++);
 int M= (N - 1) / 2;
 for (int j= 1, e= ps.size(); j < e; ++j) {
  int p= ps[j];
  if (int64_t(p) * p > N) break;
  for (auto k= int64_t(p) * max(n / p / 2 * 2 + 1, p) / 2; k <= M; k+= p) lf[k]+= p * !lf[k];
 }
 for (; n <= N; n+= 2)
  if (!lf[n >> 1]) {
   ps.push_back(lf[n >> 1]= n);
   for (auto j= int64_t(n) * n / 2; j <= M; j+= n) lf[j]+= n * !lf[j];
  }
}
ConstListRange<int> enumerate_primes() { return {ps.cbegin(), ps.cend()}; }
ConstListRange<int> enumerate_primes(int N) {
 sieve(N);
 return {ps.cbegin(), upper_bound(ps.cbegin(), ps.cend(), N)};
}
int least_prime_factor(int n) { return n & 1 ? sieve(n), lf[(n >> 1)] : 2; }
// f(p,e) := f(p^e)
template <class T, class F> vector<T> completely_multiplicative_table(int N, const F &f) {
 vector<T> ret(N + 1);
 sieve(N);
 for (int n= 3, i= 1; n <= N; n+= 2, ++i) ret[n]= lf[i] == n ? f(n, 1) : ret[lf[i]] * ret[n / lf[i]];
 if (int n= 4; 2 <= N)
  for (T t= ret[2]= f(2, 1); n <= N; n+= 2) ret[n]= t * ret[n >> 1];
 return ret[1]= 1, ret;
}
}
using nt_internal::enumerate_primes, nt_internal::least_prime_factor, nt_internal::completely_multiplicative_table;
// O(N log k / log N + N)
template <class T> static std::vector<T> pow_table(int N, uint64_t k) {
 if (k == 0) return std::vector<T>(N + 1, 1);
 auto f= [k](int p, int) {
  T ret= 1, b= p;
  for (auto e= k;; b*= b) {
   if (e & 1) ret*= b;
   if (!(e>>= 1)) return ret;
  }
 };
 return completely_multiplicative_table<T>(N, f);
}
#line 7 "test/yosupo/enumerate_primes.test.cpp"
using namespace std;
signed main() {
 cin.tie(0);
 ios::sync_with_stdio(false);
 int N, A, B;
 cin >> N >> A >> B;
 auto ps= enumerate_primes(N);
 int pi= ps.size();
 vector<int> ans;
 for (int i= 0; A * i + B < pi; i++) ans.push_back(ps[A * i + B]);
 int X= ans.size();
 cout << pi << " " << X << '\n';
 for (int i= 0; i < X; i++) cout << ans[i] << " \n"[i == X - 1];
 return 0;
}

Test cases

Env	Name	Status	Elapsed	Memory
g++-13	1_00	AC	5 ms	4 MB
g++-13	2_00	AC	5 ms	4 MB
g++-13	499477801_00	AC	2126 ms	1111 MB
g++-13	499999993_00	AC	2117 ms	1112 MB
g++-13	example_00	AC	5 ms	4 MB
g++-13	max_00	AC	2103 ms	1113 MB
g++-13	max_01	AC	2135 ms	1112 MB
g++-13	ten_00	AC	444 ms	232 MB
g++-13	ten_01	AC	62 ms	32 MB
g++-13	ten_02	AC	13 ms	6 MB
clang++-18	1_00	AC	5 ms	4 MB
clang++-18	2_00	AC	5 ms	4 MB
clang++-18	499477801_00	AC	2088 ms	1112 MB
clang++-18	499999993_00	AC	2083 ms	1113 MB
clang++-18	example_00	AC	6 ms	4 MB
clang++-18	max_00	AC	2091 ms	1112 MB
clang++-18	max_01	AC	2069 ms	1112 MB
clang++-18	ten_00	AC	427 ms	233 MB
clang++-18	ten_01	AC	63 ms	33 MB
clang++-18	ten_02	AC	13 ms	6 MB

Back to top page