Asa's CP Library

a01sa01to's competitive programming library. Requires C++20 or higher with GCC. This documentation is automatically generated by online-judge-tools/verification-helper

View the Project on GitHub a01sa01to/cp-library

:heavy_check_mark: Meissel–Lehmer Algorithm
(library/math/meissel-lehmer.hpp)

$O(n^{2/3})$ で $n$ 以下の素数の個数 $\pi(n)$ を求めるアルゴリズム。

キーアイデア

ルジャンドルが以下の式を提案。 $\pi(x) - \pi(x^{1/2}) + 1 = \left\lfloor x \right\rfloor - \sum_i \left\lfloor \frac{x}{p_i} \right\rfloor + \sum_{i < j} \left\lfloor \frac{x}{p_i p_j} \right\rfloor - …$ やっていることはエラトステネスの篩 + 包除原理と同じだが、難しくなっているので単純化しよう！という動機

$p_i$ を $i$ 番目の素数とし、 $a \ge 1$ について以下の関数を定義する。 $\varphi(x, a) := \left\lbrace n: n \le x, p \vert n \Rightarrow p > p_a \right\rbrace$ $1$ 以上 $x$ 以下の整数のうち、 $a$ 番目までの素数の倍数を除いたもの。 感覚的には、エラトステネスの篩で $p_a$ まで実行したときの残り。

また、 $P_k(x,a) := \left\vert n: n \le x, n = q_1 q_2 … q_k (q_1, …, q_k > p_a) \right\vert$ を定義する。 $\varphi(x,a)$ のうち、ちょうど $k$ 個の素因数を持つものの個数。 $P_0(x,a) = 1, P_1(x, a) = \pi(x) - a$ が成り立つ。 素因数 0 個なのは $1$ のみで、素因数 1 個なのは $p_a$ より大きい素数のみ。

これらの定義から、明らかに $\vert\varphi(x, a)\vert = \sum_{k=0}^\infty P_k(x,a)$ が成り立つ。 なお、 $p_a^k > x$ なら $P_k(x,a) = 0$ であるため、この値は有限和である。

$P_0(x,a) = 1, P_1(x,a) = \pi(x) - a$ から、 $\pi(x) = \vert\varphi(x, a)\vert + a - 1 - \sum_{k=2}^\infty P_k(x,a)$ が成り立つ。

よって、 $\pi(x)$ を求めるためには $\vert\varphi(x, a)\vert$ と $P_k(x,a)$ を求めればいい。

$\vert\varphi(x,a)\vert$ の計算

エラトステネスの篩の動作を考えると、 $\vert\varphi(x, a)\vert = \vert\varphi(x, a - 1)\vert - (\text{最小素因数が} p_a \text{となる整数の個数})$ である。

最小素因数が $p_a$ となる整数の個数？になるが、そのような数を $n’ \cdot p_a$ としたときに、 $n’$ が $p_{a-1}$ までの素数で割り切れないようなものである。 言い換えれば、 $n’$ が $\varphi(n’, a-1)$ に含まれるようなものである。 よって、 $(\text{最小素因数が} p_a \text{となる整数の個数}) = \left\vert\varphi\left(\left\lfloor\frac{x}{p_a}\right\rfloor, a-1 \right)\right\vert$

すると、以下のように再帰的に求めることが可能。

$\sum_{k=2}^\infty P_k(x,a)$ の計算

これを求めたいが、無限級数は計算できない。 そこで、 $p_a^k > x$ となれば $P_k(x,a) = 0$ であることを利用する。 $k \ge 3$ については $P_k(x,a) = 0$ となるようにしちゃう。 $p_a^3 > x$ とするには $p_a > x^{1/3}$ とすればいいので、 $a = \pi(x^{1/3}) + 1$ とすれば OK。

こうすることで、 $\sum_{k=2}^\infty P_k(x,a) = P_2(x,a)$ となる。

アルゴリズム

前計算

$P_2(n, a)$ の計算

$P_2(n, a) = \left\vert\left\lbrace m: m \le n, m = p_b p_c, p_a \le y < p_b \le p_c \right\rbrace\right\vert$ と表現可能。

$p_c < n/y$ となるが、 $n/y$ までの素数は列挙してある。 尺取り法を用いてこれを求める。

$O(\pi(n/y))$ で求められる。

$\vert\varphi(n, a)\vert$ の計算

再帰的に求めるが、 $\varphi(x, a)$ のうち $x \le n/y$ については後で求める。 このとき再帰的に求めることになるのは $\varphi(n/k, b)$ の形のもの。ただし $k < y, b \le a$ である。 ざっくり上限を求めると $O(y \pi(y))$ 個あるが、素数定理より $O(y^2 / \log y)$ である。

$x \le n/y$ についてはどう数える？ $\varphi(x,a)$ の定義は「$x$ 以下の自然数のうち、最小の素因数が $p_a$ より大きいもの」。 補集合をとって、「最小素因数が $p_a$ 以下」を数えることにする。 すると、 $n/y$ 以下の整数については前計算で最小素因数を求めているので、これを使えばいい。

しかし毎回 $x$ について $p_a$ より小さいか判定するのは時間がかかる。 $x$ の昇順に見てみる。 「$d_i$ = $x$ 以下の最小素因数が $p_i$ 以下の個数」という配列 $d$ を作っておくと、 $\varphi(x, a) = x - \sum_{i=1}^a d_i$ となる。 更新あり区間和なので、フェニック木を使えば $O(n/y \log n/y)$ で求められる。

$y$ の選び方

$y$ は $\sqrt[3]{n} < y \le \sqrt{n}$ となるようなものを選ぶ。 $y \approx \sqrt[3]{n}$ としておくと、全体で $O(n^{2/3} \log n)$ で求められる。 $y \approx \sqrt[3]{n} \log^{2/3} n$ とすると、全体で $O(n^{2/3} \log^{1/3} n)$ が達成可能。

Depends on

Verified with

Code

#pragma once

#include <algorithm>
#include <cmath>
#include <concepts>
#include <functional>
#include <tuple>
#include <vector>
using namespace std;

#include "../data-structure/bit.hpp"

namespace asalib::math {
  template<integral T>
  constexpr T meissel_lehmer(T n) {
    // n <= 2 だと y = 0 になってしまうのでここで返しておく
    if (n <= 2) [[unlikely]]
      return n == 2;
    T y = powl(n, 1.0 / 3.0) * powl(logl(n), 2.0 / 3.0);

    // 前計算
    T ny = n / y;
    if (n < 200) [[unlikely]]  // この場合は普通に求めちゃったほうが早い
      ny = n;

    constexpr T None = -1;
    vector<T> minim_prime(ny + 1, None);
    vector<T> prime(0);
    for (T i = 2; i <= ny; ++i) {
      if (minim_prime[i] == None) {
        minim_prime[i] = prime.size();
        prime.emplace_back(i);
      }
      for (T j = 0; j < ranges::ssize(prime); ++j) {
        if (i * prime[j] > ny || prime[j] > prime[minim_prime[i]]) break;
        minim_prime[i * prime[j]] = j;
      }
    }
    if (n < 200) [[unlikely]]
      return prime.size();

    T pi_ny = prime.size();
    T pi_y = 0;
    for (T p : prime) {
      if (p > y) break;
      ++pi_y;
    }
    T pi_n = pi_y - 1;

    // P_2 (n, a) を計算し引いていく
    for (T b = pi_y + 1, c = pi_ny; b <= pi_ny; ++b) {
      while (c >= b && prime[b - 1] * prime[c - 1] > n) --c;
      if (c < b) break;
      pi_n -= c - b + 1;
    }

    // phi(n, a) の計算
    vector<tuple<T, T, bool>> params(0);
    function<void(T, T, bool)> phi = [&](T x, T a, bool isMinus) {
      if (x == 0) return;
      if (x <= ny)
        params.emplace_back(x, a, isMinus);
      else if (a == 0)
        pi_n += x * (isMinus ? -1 : 1);
      else
        phi(x, a - 1, isMinus), phi(x / prime[a - 1], a - 1, !isMinus);
    };
    phi(n, pi_y, false);
    ranges::sort(params);

    ds::BIT<T> bit(pi_ny);
    T idx = 2;
    for (auto&& [num, a, isMinus] : params) {
      while (idx <= num) bit.add(minim_prime[idx++], 1);
      pi_n += (num - bit.sum(0, a)) * (isMinus ? -1 : 1);
    }

    return pi_n;
  }
}  // namespace asalib::math
#line 2 "library/math/meissel-lehmer.hpp"

#include <algorithm>
#include <cmath>
#include <concepts>
#include <functional>
#include <tuple>
#include <vector>
using namespace std;

#line 2 "library/data-structure/bit.hpp"

#include <cassert>
#line 5 "library/data-structure/bit.hpp"
#include <cstddef>
#line 8 "library/data-structure/bit.hpp"
using namespace std;

#line 2 "library/_internal/types.hpp"

#line 4 "library/_internal/types.hpp"
using namespace std;

#line 2 "library/_internal/modint-base.hpp"

#include <type_traits>
using namespace std;

namespace asalib::_internal {
  class modint_base {};

  template<typename T>
  concept is_modint = is_base_of_v<modint_base, T>;
}  // namespace asalib::_internal
#line 7 "library/_internal/types.hpp"

namespace asalib::_internal {
  // ---------- concept definition ---------- //
  template<class T>
  concept integral_like = integral<T> || is_modint<T>;

  template<class T>
  concept floating_like = floating_point<T>;

  template<class T>
  concept numeric_like = integral_like<T> || floating_like<T>;

  // ---------- constant definition ---------- //
  template<class T>
  T zero() { return 0; }
}  // namespace asalib::_internal
#line 11 "library/data-structure/bit.hpp"

namespace asalib::ds {
  template<
    _internal::numeric_like T,
    auto op = plus<T>(),
    auto invop = minus<T>(),
    auto e = _internal::zero<T>>
    requires regular_invocable<decltype(op), T, T>
             && convertible_to<T, invoke_result_t<decltype(op), T, T>>
             && regular_invocable<decltype(invop), T, T>
             && convertible_to<T, invoke_result_t<decltype(invop), T, T>>
             && invocable<decltype(e)>
             && convertible_to<invoke_result_t<decltype(e)>, T>
  class BIT {
    public:
    BIT(): _n(0) {}
    explicit BIT(const int n) {
      _n = n;
      data.reserve(n);
      data.resize(n, 0);
    }

    void add(int i, T x) {
      assert(i < _n);
      ++i;
      while (i <= _n) {
        data[i - 1] = op(data[i - 1], x);
        i += i & -i;
      }
    }

    T sum(const int l, const int r) const {
      assert(l <= r && r <= _n);
      return invop(_sum(r), _sum(l));
    }

    private:
    int _n;
    vector<T> data;
    T _sum(int i) const {
      T s = e();
      while (i > 0) {
        s = op(s, data[i - 1]);
        i -= i & -i;
      }
      return s;
    }
  };
}  // namespace asalib::ds
#line 12 "library/math/meissel-lehmer.hpp"

namespace asalib::math {
  template<integral T>
  constexpr T meissel_lehmer(T n) {
    // n <= 2 だと y = 0 になってしまうのでここで返しておく
    if (n <= 2) [[unlikely]]
      return n == 2;
    T y = powl(n, 1.0 / 3.0) * powl(logl(n), 2.0 / 3.0);

    // 前計算
    T ny = n / y;
    if (n < 200) [[unlikely]]  // この場合は普通に求めちゃったほうが早い
      ny = n;

    constexpr T None = -1;
    vector<T> minim_prime(ny + 1, None);
    vector<T> prime(0);
    for (T i = 2; i <= ny; ++i) {
      if (minim_prime[i] == None) {
        minim_prime[i] = prime.size();
        prime.emplace_back(i);
      }
      for (T j = 0; j < ranges::ssize(prime); ++j) {
        if (i * prime[j] > ny || prime[j] > prime[minim_prime[i]]) break;
        minim_prime[i * prime[j]] = j;
      }
    }
    if (n < 200) [[unlikely]]
      return prime.size();

    T pi_ny = prime.size();
    T pi_y = 0;
    for (T p : prime) {
      if (p > y) break;
      ++pi_y;
    }
    T pi_n = pi_y - 1;

    // P_2 (n, a) を計算し引いていく
    for (T b = pi_y + 1, c = pi_ny; b <= pi_ny; ++b) {
      while (c >= b && prime[b - 1] * prime[c - 1] > n) --c;
      if (c < b) break;
      pi_n -= c - b + 1;
    }

    // phi(n, a) の計算
    vector<tuple<T, T, bool>> params(0);
    function<void(T, T, bool)> phi = [&](T x, T a, bool isMinus) {
      if (x == 0) return;
      if (x <= ny)
        params.emplace_back(x, a, isMinus);
      else if (a == 0)
        pi_n += x * (isMinus ? -1 : 1);
      else
        phi(x, a - 1, isMinus), phi(x / prime[a - 1], a - 1, !isMinus);
    };
    phi(n, pi_y, false);
    ranges::sort(params);

    ds::BIT<T> bit(pi_ny);
    T idx = 2;
    for (auto&& [num, a, isMinus] : params) {
      while (idx <= num) bit.add(minim_prime[idx++], 1);
      pi_n += (num - bit.sum(0, a)) * (isMinus ? -1 : 1);
    }

    return pi_n;
  }
}  // namespace asalib::math
Back to top page