結果

問題 No.1164 GCD Products hard
ユーザー firiexpfiriexp
提出日時 2020-11-27 18:52:12
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 4,431 bytes
コンパイル時間 1,065 ms
コンパイル使用メモリ 110,788 KB
実行使用メモリ 45,200 KB
最終ジャッジ日時 2023-10-01 04:16:30
合計ジャッジ時間 27,961 ms
ジャッジサーバーID
（参考情報） 		judge12 / judge11
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 WA -
testcase_01 RE -
testcase_02 RE -
testcase_03 WA -
testcase_04 RE -
testcase_05 WA -
testcase_06 RE -
testcase_07 AC 1,275 ms
39,556 KB
testcase_08 WA -
testcase_09 WA -
testcase_10 RE -
testcase_11 AC 1,131 ms
30,664 KB
testcase_12 RE -
testcase_13 RE -
testcase_14 AC 584 ms
28,792 KB
testcase_15 AC 1,357 ms
40,096 KB
testcase_16 AC 611 ms
30,724 KB
testcase_17 AC 1,247 ms
31,472 KB
testcase_18 WA -
testcase_19 RE -
testcase_20 AC 592 ms
18,248 KB
testcase_21 AC 1,814 ms
40,252 KB
testcase_22 AC 36 ms
6,552 KB
testcase_23 AC 1,618 ms
45,200 KB
testcase_24 AC 2,237 ms
44,948 KB
testcase_25 AC 35 ms
7,244 KB
testcase_26 AC 36 ms
6,664 KB
testcase_27 AC 35 ms
7,100 KB
testcase_28 AC 36 ms
6,540 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;

template <u32 M>
struct modint {
    u32 val;
public:
    static modint raw(int v) { modint x; x.val = v; return x; }
    modint() : val(0) {}
    template <class T>
    modint(T v) { ll x = (ll)(v%(ll)(M)); if (x < 0) x += M; val = u32(x); }
    modint(bool v) { val = ((unsigned int)(v) % M); }
    modint& operator++() { val++; if (val == M) val = 0; return *this; }
    modint& operator--() { if (val == 0) val = M; val--; return *this; }
    modint operator++(int) { modint result = *this; ++*this; return result; }
    modint operator--(int) { modint result = *this; --*this; return result; }
    modint& operator+=(const modint& b) { val += b.val; if (val >= M) val -= M; return *this; }
    modint& operator-=(const modint& b) { val -= b.val; if (val >= M) val += M; return *this; }
    modint& operator*=(const modint& b) { u64 z = val; z *= b.val; val = (u32)(z % M); return *this; }
    modint& operator/=(const modint& b) { return *this = *this * b.inv(); }
    modint operator+() const { return *this; }
    modint operator-() const { return modint() - *this; }
    modint pow(long long n) const { modint x = *this, r = 1; while (n) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
    modint inv() const { return pow(M-2); }
    friend modint operator+(const modint& a, const modint& b) { return modint(a) += b; }
    friend modint operator-(const modint& a, const modint& b) { return modint(a) -= b; }
    friend modint operator*(const modint& a, const modint& b) { return modint(a) *= b; }
    friend modint operator/(const modint& a, const modint& b) { return modint(a) /= b; }
    friend bool operator==(const modint& a, const modint& b) { return a.val == b.val; }
    friend bool operator!=(const modint& a, const modint& b) { return a.val != b.val; }
};
using mint = modint<MOD-1>;
using mint2 = modint<MOD>;

struct Prime { // Wheel factorization
    static constexpr int wheel[] = {4, 2, 4, 2, 4, 6, 2, 6},
            wheel2[] = {7, 11, 13, 17, 19, 23, 29, 31},
            wheel_sum[] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7};
    static inline int f(int n){ return (n-1)/30*8 + wheel_sum[(n-1)%30]; }
    static inline int g(int n){ return ((n-1) >> 3)*30 + wheel2[(n-1)&7]; }
    vector<int> primes;

    Prime(int M) {
        primes = {2, 3, 5};
        if(M < 7){
            while(!primes.empty() && M < primes.back()) primes.pop_back();
            return;
        }
        int n = f(M), m = g(n), k = f(int(floor(sqrt(M))));
        primes.reserve(3+max(0, (int)(n/(log(n)-1.12))));
        vector<bool> sieve(n+1, true);
        for (int i = 1; i <= k; ++i) {
            if(sieve[i]){
                ll p = g(i), q = p*p;
                int j = (i-1)&7;
                while(q <= m){
                    sieve[f(q)] = false;
                    q += wheel[j] * p;
                    j = (j+1)&7;
                }
            }
        }
        for (int i = 1; i <= n; ++i) {
            if(sieve[i]) primes.emplace_back(g(i));
        }
    }
};
constexpr int Prime::wheel[], Prime::wheel2[], Prime::wheel_sum[];
Prime p(10000010);
template<class T>
void div_transform(vector<T> &a){
    int n = a.size();
    for (auto &&i : p.primes) {
        if(i >= n) break;
        for (int k = (n-1)/i; k > 0; --k) {
            a[k] += a[k*i];
        }
    }
    for (int i = 1; i < n; ++i) a[i] += a[0];
}
template<class T>
void div_itransform(vector<T> &a){
    int n = a.size();
    for (int i = 1; i < n; ++i) a[i] -= a[0];
    for (auto &&i : p.primes) {
        if(i >= n) break;
        for (int k = 1; k*i < n; ++k) {
            a[k] -= a[k*i];
        }
    }
}

int main() {
    int a, b, n;
    cin >> a >> b >> n;
    vector<mint> v(b+1);
    for (int i = a; i <= b; ++i) {
        v[i] = 1;
    }
    div_transform(v);
    for (int i = 1; i <= n; ++i) {
        v[i] = v[i].pow(n);
    }
    div_itransform(v);
    mint2 ans = 1;
    for (int i = 2; i <= b; ++i) {
        ans *= mint2(i).pow(v[i].val);
    }
    printf("%d\n", ans.val);
    return 0;
}
0