GCD Convolution
(library/convolution/gcd_convolution.hpp)

• View this file on GitHub
• Last update: 2022-01-31 13:34:34+09:00
• Include: #include "library/convolution/gcd_convolution.hpp"

gcd_convolution

• シグネチャ

  template <
      typename T,
      auto add = default_operator::add<T>,
      auto sub = default_operator::sub<T>,
      auto mul = default_operator::mul<T>
  >
  std::vector<T> gcd_convolution(std::vector<T> a, std::vector<T> b)
  

• 概要

  長さ $N$ の列 $(A_0=0,A_1,\ldots,A_{N-1})$ および $(B_0=0,B_1,\ldots,B_{N-1})$ を添字 gcd で畳み込みます．即ち，長さ $N$ の列 $(C_0,C_1,\ldots,C_{N-1})$ であって，各 $k=0,\ldots,N-1$ に対して以下を満たす列を計算します．

  \[C _ k = \sum _ { \gcd (i, j) = k } A _ i \cdot B _ j\]

  ここで，$A_0=0$ かつ $B_0=0$ であることが要求されます．

  以下，この畳み込みを $C=A\ast B$ と表記します．

• テンプレート引数

  • T: 列の要素の型．
  • add: 二項演算 (加算)．デフォルトでは operator+ が呼ばれるようになっています．
  • sub: 二項演算 (減算)．デフォルトでは operator- が呼ばれるようになっています．
  • mul: 二項演算 (乗算)．デフォルトでは operator* が呼ばれるようになっています．

• 返り値

  $A\ast B$

• 制約

  • $\vert A\vert =\vert B\vert$
  • $A_0=B_0=0$

• 時間計算量

  $\Theta(N\log\log N)$

Depends on

• Convolution (library/convolution/convolution.hpp)
• 倍数系ゼータ変換・メビウス変換 (library/transform/multiple.hpp)
• Default Operator (library/util/default_operator.hpp)

Verified with

• test/src/convolution/gcd_convolution/gcd_convolution.test.cpp
• test/src/convolution/gcd_convolution/lcms.test.cpp

Code

#ifndef SUISEN_GCD_CONVOLUTION
#define SUISEN_GCD_CONVOLUTION

#include "library/transform/multiple.hpp"
#include "library/convolution/convolution.hpp"

namespace suisen {
    template <
        typename T,
        auto add = default_operator::add<T>,
        auto sub = default_operator::sub<T>,
        auto mul = default_operator::mul<T>
    >
    auto gcd_convolution(std::vector<T> a, std::vector<T> b) {
        return convolution::transform_convolution<
            T,
            multiple_transform::zeta<T, add>,
            multiple_transform::mobius<T, sub>,
            mul
        >(std::move(a), std::move(b));
    }
} // namespace suisen

#endif // SUISEN_GCD_CONVOLUTION

#line 1 "library/convolution/gcd_convolution.hpp"



#line 1 "library/transform/multiple.hpp"



#include <vector>
#line 1 "library/util/default_operator.hpp"



namespace suisen {
    namespace default_operator {
        template <typename T>
        auto zero() -> decltype(T { 0 }) { return T { 0 }; }
        template <typename T>
        auto one()  -> decltype(T { 1 }) { return T { 1 }; }
        template <typename T>
        auto add(const T &x, const T &y) -> decltype(x + y) { return x + y; }
        template <typename T>
        auto sub(const T &x, const T &y) -> decltype(x - y) { return x - y; }
        template <typename T>
        auto mul(const T &x, const T &y) -> decltype(x * y) { return x * y; }
        template <typename T>
        auto div(const T &x, const T &y) -> decltype(x / y) { return x / y; }
        template <typename T>
        auto mod(const T &x, const T &y) -> decltype(x % y) { return x % y; }
        template <typename T>
        auto neg(const T &x) -> decltype(-x) { return -x; }
        template <typename T>
        auto inv(const T &x) -> decltype(one<T>() / x)  { return one<T>() / x; }
    } // default_operator
    namespace default_operator_noref {
        template <typename T>
        auto zero() -> decltype(T { 0 }) { return T { 0 }; }
        template <typename T>
        auto one()  -> decltype(T { 1 }) { return T { 1 }; }
        template <typename T>
        auto add(T x, T y) -> decltype(x + y) { return x + y; }
        template <typename T>
        auto sub(T x, T y) -> decltype(x - y) { return x - y; }
        template <typename T>
        auto mul(T x, T y) -> decltype(x * y) { return x * y; }
        template <typename T>
        auto div(T x, T y) -> decltype(x / y) { return x / y; }
        template <typename T>
        auto mod(T x, T y) -> decltype(x % y) { return x % y; }
        template <typename T>
        auto neg(T x) -> decltype(-x) { return -x; }
        template <typename T>
        auto inv(T x) -> decltype(one<T>() / x)  { return one<T>() / x; }
    } // default_operator
} // namespace suisen


#line 6 "library/transform/multiple.hpp"

namespace suisen::multiple_transform {
    // Calculates `g` s.t. g(n) = Sum_{n | m} f(m) inplace.
    template <typename T, auto add = default_operator::add<T>>
    void zeta(std::vector<T> &f) {
        const int n = f.size();
        std::vector<char> is_prime(n, true);
        auto cum = [&](const int p) {
            const int qmax = (n - 1) / p, rmax = qmax * p;
            for (int q = qmax, pq = rmax; q >= 1; --q, pq -= p) {
                f[q] = add(f[q], f[pq]);
                is_prime[pq] = false;
            }
        };
        for (int p = 2; p < n; ++p) if (is_prime[p]) cum(p);
    }
    // Calculates `f` s.t. g(n) = Sum_{n | m} f(m) inplace.
    template <typename T, auto sub = default_operator::sub<T>>
    void mobius(std::vector<T> &f) {
        const int n = f.size();
        std::vector<char> is_prime(n, true);
        auto diff = [&](const int p) {
            for (int q = 1, pq = p; pq < n; ++q, pq += p) {
                f[q] = sub(f[q], f[pq]);
                is_prime[pq] = false;
            }
        };
        for (int p = 2; p < n; ++p) if (is_prime[p]) diff(p);
    }
} // namespace suisen::multiple_transform


#line 1 "library/convolution/convolution.hpp"



#include <cassert>
#line 6 "library/convolution/convolution.hpp"

#line 8 "library/convolution/convolution.hpp"

namespace suisen {
    namespace convolution {
        template <typename T, auto transform, auto inv_transform, auto mul = default_operator::mul<T>>
        std::vector<T> transform_convolution(std::vector<T> a, std::vector<T> b) {
            const std::size_t n = a.size(), m = b.size();
            assert(n == m);
            transform(a), transform(b);
            for (std::size_t i = 0; i < n; ++i) a[i] = mul(a[i], b[i]);
            inv_transform(a);
            return a;
        }
        template <typename T, auto transform, auto inv_transform, auto mul = default_operator::mul<T>>
        std::vector<T> transform_convolution(std::vector<std::vector<T>> a) {
            const std::size_t num = a.size();
            assert(num);
            const std::size_t n = a[0].size();
            for (auto &v : a) {
                assert(n == int(v.size()));
                transform(v);
            }
            auto &res = a[0];
            for (int i = 1; i < num; ++i) {
                for (int j = 0; j < n; ++j) res[j] = mul(res[j], a[i][j]);
            }
            inv_transform(res);
            return res;
        }
    }
} // namespace suisen



#line 6 "library/convolution/gcd_convolution.hpp"

namespace suisen {
    template <
        typename T,
        auto add = default_operator::add<T>,
        auto sub = default_operator::sub<T>,
        auto mul = default_operator::mul<T>
    >
    auto gcd_convolution(std::vector<T> a, std::vector<T> b) {
        return convolution::transform_convolution<
            T,
            multiple_transform::zeta<T, add>,
            multiple_transform::mobius<T, sub>,
            mul
        >(std::move(a), std::move(b));
    }
} // namespace suisen

Back to top page