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

• View this file on GitHub
• Last update: 2025-03-03 00:33:48+09:00
• Include: #include "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$

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

• $\vert\varphi(x, 0)\vert = x$ ($\varphi(x,a)$ は $a \ge 1$ に対して定義していたが、便宜上 $a=0$ にも拡張した)
• $\vert\varphi(x, a)\vert = \vert\varphi(x, a-1)\vert - \left\vert\varphi\left(\left\lfloor\dfrac{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)$ となる。

アルゴリズム

前計算

• $\sqrt[3]{n} < y \le \sqrt{n}$ となるような整数 $y$ を決めておく
• $a = \pi(y)$ とする
  • このとき $\pi$ の定義から $p_a \le y < p_{a+1}$ が成り立つ
• $N/y$ までの素数を列挙しておく
• $N/y$ までの各整数について最小の素因数を求めておく

$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$ までの素数は列挙してある。 尺取り法を用いてこれを求める。

• $b$ を $\pi(y) + 1$ から $\pi(n/y)$ まで動かす
• $c$ を $\pi(n/y)$ から減らしていく
• $p_b p_c \le n$ となるような $b, c$ の組み合わせを数える

$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

• library/_internal/modint-base.hpp
• 内部型 (library/_internal/types.hpp)
• Binary Indexed Tree (library/data-structure/bit.hpp)

Verified with

• tests/math/meissel-lehmer/libchecker.test.cpp

Code

#pragma once

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

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

namespace asalib {
  namespace 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.push_back(i);
        }
        for (T j = 0; j < (T) prime.size(); ++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;
        else if (x <= ny)
          params.push_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);
      sort(params.begin(), params.end());

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

      return pi_n;
    }
  }  // namespace math
}  // namespace asalib

#line 2 "library/math/meissel-lehmer.hpp"

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

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

#line 4 "library/data-structure/bit.hpp"
using namespace std;

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

#line 4 "library/_internal/types.hpp"
#include <type_traits>
using namespace std;

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

#line 5 "library/_internal/modint-base.hpp"
using namespace std;

namespace asalib {
  namespace _internal {
    class modint_base {};

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

namespace asalib {
  namespace _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>;

    // ---------- function definition ---------- //
    template<class T>
    T plus(T a, T b) { return a + b; }

    template<class T>
    T minus(T a, T b) { return a - b; }

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

namespace asalib {
  namespace ds {
    template<_internal::numeric_like T, T (*op)(T, T) = _internal::plus<T>, T (*invop)(T, T) = _internal::minus<T>, T (*e)() = _internal::zero<T>>
    class BIT {
      public:
      BIT(): _n(0) {}
      explicit BIT(size_t n) {
        _n = n;
        data.reserve(n);
        data.resize(n, 0);
      }

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

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

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

namespace asalib {
  namespace 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.push_back(i);
        }
        for (T j = 0; j < (T) prime.size(); ++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;
        else if (x <= ny)
          params.push_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);
      sort(params.begin(), params.end());

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

      return pi_n;
    }
  }  // namespace math
}  // namespace asalib

Back to top page