結果

問題 No.1080 Strange Squared Score Sum
ユーザー noiminoimi
提出日時 2020-06-12 23:27:52
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 1,264 ms / 5,000 ms
コード長 15,948 bytes
コンパイル時間 3,968 ms
コンパイル使用メモリ 252,536 KB
実行使用メモリ 21,868 KB
最終ジャッジ日時 2023-09-06 11:26:18
合計ジャッジ時間 18,679 ms
ジャッジサーバーID
（参考情報） 		judge14 / judge13
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
4,380 KB
testcase_01 AC 2 ms
4,376 KB
testcase_02 AC 593 ms
13,196 KB
testcase_03 AC 1,260 ms
21,040 KB
testcase_04 AC 283 ms
7,656 KB
testcase_05 AC 279 ms
8,184 KB
testcase_06 AC 64 ms
4,384 KB
testcase_07 AC 133 ms
5,480 KB
testcase_08 AC 598 ms
12,980 KB
testcase_09 AC 596 ms
11,948 KB
testcase_10 AC 64 ms
4,424 KB
testcase_11 AC 1,261 ms
21,096 KB
testcase_12 AC 600 ms
11,892 KB
testcase_13 AC 1,258 ms
21,188 KB
testcase_14 AC 596 ms
12,144 KB
testcase_15 AC 2 ms
4,380 KB
testcase_16 AC 1,250 ms
21,868 KB
testcase_17 AC 588 ms
13,300 KB
testcase_18 AC 587 ms
13,256 KB
testcase_19 AC 587 ms
13,284 KB
testcase_20 AC 1,264 ms
20,512 KB
testcase_21 AC 1,263 ms
20,604 KB
権限があれば一括ダウンロードができます
コンパイルメッセージ
main.cpp:567:1: 警告: ISO C++ では型の無い ‘main’ の宣言を禁止しています [-Wreturn-type]
  567 | main() {
      | ^~~~

ソースコード

diff # 

#pragma region Macros
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define rep2(i, a, b) for(ll i = a; i <= b; ++i)
#define rep(i, n) for(ll i = 0; i < n; ++i)
#define rep3(i, a, b) for(ll i = a; i >= b; --i)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define vec vector<int>
#define vll vector<ll>
#define vpi vector<pii>
#define vpll vector<pll>
#define overload2(_1, _2, name, ...) name
#define vv(a, b) vector<vector<int>>(a, vector<int>(b))
#define vv2(a, b, c) vector<vector<int>>(a, vector<int>(b, c))
#define vvl(a, b) vector<vector<ll>>(a, vector<ll>(b))
#define vvl2(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define vvv(a, b, c) vector<vv(b, c)>(a)
#define vvv2(a, b, c, d) vector<vv(b, c, d)>(a)
#define vvvl(a, b, c) vector<vvl(b, c)>(a)
#define vvvl2(a, b, c, d) vector<vvl(b, c, d)>(a)
#define fi first
#define se second
#define all(c) begin(c), end(c)
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
#define Size(c) (int)(c).size()
#define INT(...)     \
    int __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LL(...)     \
    ll __VA_ARGS__; \
    IN(__VA_ARGS__)
#define ULL(...)     \
    ull __VA_ARGS__; \
    IN(__VA_ARGS__)
#define STR(...)        \
    string __VA_ARGS__; \
    IN(__VA_ARGS__)
#define CHR(...)      \
    char __VA_ARGS__; \
    IN(__VA_ARGS__)
#define DBL(...)        \
    double __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LD(...)     \
    ld __VA_ARGS__; \
    IN(__VA_ARGS__)
#define VEC(type, name, size) \
    vector<type> name(size);  \
    IN(name)
#define VV(type, name, h, w)                       \
    vector<vector<type>> name(h, vector<type>(w)); \
    IN(name)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(long double &a) { cin >> a; }
void scan(char a[]) { scanf("%s", a); }
void scan(string &a) { cin >> a; }
template <class T>
void scan(vector<T> &);
template <class T, size_t size>
void scan(array<T, size> &);
template <class T, class L>
void scan(pair<T, L> &);
template <class T, size_t size>
void scan(T (&)[size]);
template <class T>
void scan(vector<T> &a) {
    for(auto &i : a) scan(i);
}
template <class T>
void scan(deque<T> &a) {
    for(auto &i : a) scan(i);
}
template <class T, size_t size>
void scan(array<T, size> &a) {
    for(auto &i : a) scan(i);
}
template <class T, class L>
void scan(pair<T, L> &p) {
    scan(p.first);
    scan(p.second);
}
template <class T, size_t size>
void scan(T (&a)[size]) {
    for(auto &i : a) scan(i);
}
template <class T>
void scan(T &a) {
    cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &... tail) {
    scan(head);
    IN(tail...);
}
string stin() {
    string s;
    cin >> s;
    return s;
}
template <class T>
inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return 1;
    }
    return 0;
}
template <class T>
inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return 1;
    }
    return 0;
}
vi iota(int n) {
    vi a(n);
    iota(all(a), 0);
    return a;
}
template <class T>
void UNIQUE(vector<T> &x) {
    sort(all(x));
    x.erase(unique(all(x)), x.end());
}
int in() {
    int x;
    cin >> x;
    return x;
}
ll lin() {
    unsigned long long x;
    cin >> x;
    return x;
}
void print() { putchar(' '); }
void print(bool a) { cout << a; }
void print(int a) { cout << a; }
void print(long long a) { cout << a; }
void print(char a) { cout << a; }
void print(string &a) { cout << a; }
void print(double a) { cout << a; }
template <class T>
void print(const vector<T> &);
template <class T, size_t size>
void print(const array<T, size> &);
template <class T, class L>
void print(const pair<T, L> &p);
template <class T, size_t size>
void print(const T (&)[size]);
template <class T>
void print(const vector<T> &a) {
    if(a.empty()) return;
    print(a[0]);
    for(auto i = a.begin(); ++i != a.end();) {
        cout << " ";
        print(*i);
    }
    cout << endl;
}
template <class T>
void print(const deque<T> &a) {
    if(a.empty()) return;
    print(a[0]);
    for(auto i = a.begin(); ++i != a.end();) {
        cout << " ";
        print(*i);
    }
}
template <class T, size_t size>
void print(const array<T, size> &a) {
    print(a[0]);
    for(auto i = a.begin(); ++i != a.end();) {
        cout << " ";
        print(*i);
    }
}
template <class T, class L>
void print(const pair<T, L> &p) {
    cout << '(';
    print(p.first);
    cout << ",";
    print(p.second);
    cout << ')';
}
template <class T>
void print(set<T> &x) {
    for(auto e : x) print(e), cout << " ";
    cout << endl;
}
template <class T>
void print(multiset<T> &x) {
    for(auto e : x) print(e), cout << " ";
    cout << endl;
}
template <class T, size_t size>
void print(const T (&a)[size]) {
    print(a[0]);
    for(auto i = a; ++i != end(a);) {
        cout << " ";
        print(*i);
    }
}
template <class T>
void print(const T &a) {
    cout << a;
}
int out() {
    putchar('\n');
    return 0;
}
template <class T>
int out(const T &t) {
    print(t);
    putchar('\n');
    return 0;
}
template <class Head, class... Tail>
int out(const Head &head, const Tail &... tail) {
    print(head);
    putchar(' ');
    out(tail...);
    return 0;
}
ll gcd(ll a, ll b) {
    while(b) {
        ll c = b;
        b = a % b;
        a = c;
    }
    return a;
}
ll lcm(ll a, ll b) {
    if(!a || !b) return 0;
    return a * b / gcd(a, b);
}
vector<pll> factor(ll x) {
    vector<pll> ans;
    for(ll i = 2; i * i <= x; i++)
        if(x % i == 0) {
            ans.push_back({i, 1});
            while((x /= i) % i == 0) ans.back().second++;
        }
    if(x != 1) ans.push_back({x, 1});
    return ans;
}
vector<int> divisor(int x) {
    vector<int> ans;
    for(int i = 1; i * i <= x; i++)
        if(x % i == 0) {
            ans.pb(i);
            if(i * i != x) ans.pb(x / i);
        }
    return ans;
}
int popcount(ll x) { return __builtin_popcountll(x); }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int n) { return uniform_int_distribution<int>(0, n - 1)(rng); }
#define endl '\n'

#ifdef _LOCAL
#undef endl
#define debug(x)        \
    cout << #x << ": "; \
    print(x);           \
    cout << endl;
void err() {}
template <class T>
void err(const T &t) {
    print(t);
    cout << " ";
}
template <class Head, class... Tail>
void err(const Head &head, const Tail &... tail) {
    print(head);
    putchar(' ');
    out(tail...);
}
#else
#define debug(x)
template <class... T>
void err(const T &...) {}
#endif

struct Setup_io {
    Setup_io() {
        ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
        cout << fixed << setprecision(15);
    }
} setup_io;
#pragma endregion

// _______ここから編集！_______________

// exp of poly from https://judge.yosupo.jp/submission/2613
template <class T, class Op = multiplies<T>>
constexpr T power(T a, long long n, Op op = Op(), T e = {1}) {
    assert(n >= 0);
    while(n) {
        if(n & 1) e = op(e, a);
        if(n >>= 1) a = op(a, a);
    }
    return e;
}

template <class T>
vector<T> operator-(vector<T> a) {
    for(auto &&e : a) e = -e;
    return a;
}
template <class T>
vector<T> &operator+=(vector<T> &a, const vector<T> &b) {
    a.resize(max(a.size(), b.size()));
    for(int i = 0; i < (int)b.size(); ++i) a[i] += b[i];
    return a;
}
template <class T>
vector<T> operator+(vector<T> a, const vector<T> &b) {
    return a += b;
}
template <class T>
vector<T> &operator-=(vector<T> &a, const vector<T> &b) {
    a.resize(max(a.size(), b.size()));
    for(int i = 0; i < (int)b.size(); ++i) a[i] -= b[i];
    return a;
}
template <class T>
vector<T> operator-(vector<T> a, const vector<T> &b) {
    return a -= b;
}
template <class T>
vector<T> &operator<<=(vector<T> &a, size_t n) {
    return a.insert(begin(a), n, 0), a;
}
template <class T>
vector<T> operator<<(vector<T> a, size_t n) {
    return a <<= n;
}
template <class T>
vector<T> &operator>>=(vector<T> &a, size_t n) {
    return a.erase(begin(a), begin(a) + min(a.size(), n)), a;
}
template <class T>
vector<T> operator>>(vector<T> a, size_t n) {
    return a >>= n;
}
// template <class T> vector<T> operator*(const vector<T>& a, const vector<T>&
// b) {
//   if (a.empty() or b.empty()) return {};
//   vector<T> res(a.size() + b.size() - 1);
//   for (int i = 0; i < (int)a.size(); ++i)
//     for (int j = 0; j < (int)b.size(); ++j) res[i + j] += a[i] * b[j];
//   return res;
// }
template <class T>
vector<T> &operator*=(vector<T> &a, const vector<T> &b) {
    return a = a * b;
}
template <class T>
vector<T> inverse(const vector<T> &a) {
    assert(not a.empty() and not(a[0] == 0));
    vector<T> b{1 / a[0]};
    while(b.size() < a.size()) {
        vector<T> x(begin(a), begin(a) + min(a.size(), 2 * b.size()));
        x *= b * b;
        b.resize(2 * b.size());
        for(auto i = b.size() / 2; i < min(x.size(), b.size()); ++i)
            b[i] = -x[i];
    }
    return {begin(b), begin(b) + a.size()};
}
template <class T>
vector<T> operator/(vector<T> a, vector<T> b) {
    if(a.size() < b.size()) return {};
    reverse(begin(a), end(a)), reverse(begin(b), end(b));
    int n = a.size() - b.size() + 1;
    a.resize(n), b.resize(n);
    a *= inverse(b);
    return {rend(a) - n, rend(a)};
}
template <class T>
vector<T> &operator/=(vector<T> &a, const vector<T> &b) {
    return a = a / b;
}
template <class T>
vector<T> operator%(vector<T> a, const vector<T> &b) {
    if(a.size() < b.size()) return a;
    a -= a / b * b;
    return {begin(a), begin(a) + (b.size() - 1)};
}
template <class T>
vector<T> &operator%=(vector<T> &a, const vector<T> &b) {
    return a = a % b;
}
template <class T>
vector<T> derivative(const vector<T> &a) {
    vector<T> res(max((int)a.size() - 1, 0));
    for(int i = 0; i < (int)res.size(); ++i) res[i] = (i + 1) * a[i + 1];
    return res;
}
template <class T>
vector<T> primitive(const vector<T> &a) {
    vector<T> res(a.size() + 1);
    for(int i = 1; i < (int)res.size(); ++i) res[i] = a[i - 1] / i;
    return res;
}
template <class T>
vector<T> logarithm(const vector<T> &a) {
    assert(not a.empty() and a[0] == 1);
    auto res = primitive(derivative(a) * inverse(a));
    return {begin(res), begin(res) + a.size()};
}
template <class T>
vector<T> exponent(const vector<T> &a) {
    assert(a.empty() or a[0] == 0);
    vector<T> b{1};
    while(b.size() < a.size()) {
        vector<T> x(begin(a), begin(a) + min(a.size(), 2 * b.size()));
        x[0] += 1;
        b.resize(2 * b.size());
        x -= logarithm(b);
        x *= {begin(b), begin(b) + b.size() / 2};
        for(auto i = b.size() / 2; i < min(x.size(), b.size()); ++i)
            b[i] = x[i];
    }
    return {begin(b), begin(b) + a.size()};
}

template <class T>
void ntt(vector<T> &a, bool inverse) {
    int n = size(a);
    assert((n & (n - 1)) == 0);
    if(n < 2) return;
    assert((T::mod - 1) % n == 0);
    static vector<T> w{1}, iw{1};
    for(int m = size(w); m < n / 2; m *= 2) {
        static T root = 2;
        while(power(root, (T::mod - 1) / 2) == 1) root += 1;
        T dw = power(root, (T::mod - 1) / (4 * m)), idw = 1 / dw;
        w.resize(2 * m), iw.resize(2 * m);
        for(int i = 0; i < m; ++i)
            w[m + i] = w[i] * dw, iw[m + i] = iw[i] * idw;
    }
    if(not inverse) {
        for(int m = n; m >>= 1;) {
            for(int s = 0, k = 0; s < n; s += 2 * m, ++k) {
                for(int i = s, j = s + m; i < s + m; ++i, ++j) {
                    T x = a[i], y = a[j] * w[k];
                    a[i] = x + y, a[j] = x - y;
                }
            }
        }
    } else {
        for(int m = 1; m < n; m *= 2) {
            for(int s = 0, k = 0; s < n; s += 2 * m, ++k) {
                for(int i = s, j = s + m; i < s + m; ++i, ++j) {
                    T x = a[i], y = a[j];
                    a[i] = x + y, a[j] = (x - y) * iw[k];
                }
            }
        }
        auto inv = 1 / T(n);
        for(auto &&e : a) e *= inv;
    }
}
template <class T>
vector<T> operator*(vector<T> a, vector<T> b) {
    if(empty(a) or empty(b)) return {};
    int n = size(a), m = size(b), sz = 1 << __lg(2 * (n + m - 1) - 1);
    a.resize(sz), ntt(a, false);
    b.resize(sz), ntt(b, false);
    for(int i = 0; i < sz; ++i) a[i] *= b[i];
    ntt(a, true), a.resize(n + m - 1);
    return a;
}

template <unsigned M>
struct modular {
    using m = modular;
    static constexpr unsigned mod = M;
    unsigned v;
    modular(long long x = 0) : v((x %= mod) < 0 ? x + mod : x) {}
    m operator-() const { return m() -= *this; }
    m &operator+=(m b) {
        if((int)(v += b.v - mod) < 0) v += mod;
        return *this;
    }
    m &operator-=(m b) {
        if((int)(v -= b.v) < 0) v += mod;
        return *this;
    }
    m &operator*=(m b) {
        v = (uint64_t)v * b.v % mod;
        return *this;
    }
    m &operator/=(m b) { return *this *= power(b, mod - 2); }
    friend m operator+(m a, m b) { return a += b; }
    friend m operator-(m a, m b) { return a -= b; }
    friend m operator*(m a, m b) { return a *= b; }
    friend m operator/(m a, m b) { return a /= b; }
    friend bool operator==(m a, m b) { return a.v == b.v; }
};

using mint = modular<power(10, 9) + 9>;

vector<mint> operator*(const vector<mint> &a, const vector<mint> &b) {
    if(a.empty() or b.empty()) return {};
    int n = a.size(), m = b.size();
    static constexpr int mod0 = 998244353, mod1 = 1300234241, mod2 = 1484783617;
    using mint0 = modular<mod0>;
    using mint1 = modular<mod1>;
    using mint2 = modular<mod2>;
    vector<mint0> a0(n), b0(m);
    vector<mint1> a1(n), b1(m);
    vector<mint2> a2(n), b2(m);
    for(int i = 0; i < n; ++i) a0[i] = a[i].v, a1[i] = a[i].v, a2[i] = a[i].v;
    for(int j = 0; j < m; ++j) b0[j] = b[j].v, b1[j] = b[j].v, b2[j] = b[j].v;
    a0 = a0 * b0, a1 = a1 * b1, a2 = a2 * b2;
    static const mint1 im0 = 1 / mint1(mod0);
    static const mint2 im1 = 1 / mint2(mod1), im0m1 = im1 / mod0;
    static const mint m0 = mod0, m0m1 = m0 * mod1;
    vector<mint> res(n + m - 1);
    for(int i = 0; i < n + m - 1; ++i) {
        int y0 = a0[i].v;
        int y1 = (im0 * (a1[i] - y0)).v;
        int y2 = (im0m1 * (a2[i] - y0) - im1 * y1).v;
        res[i] = y0 + m0 * y1 + m0m1 * y2;
    }
    return res;
}

vector<mint> fact, inv_fact, minv;
void prepare(int n) {
    fact.resize(n + 1), inv_fact.resize(n + 1), minv.resize(n + 1);
    for(int i = 0; i <= n; ++i) fact[i] = i ? fact[i - 1] * i : 1;
    inv_fact[n] = power(fact[n], mint::mod - 2);
    for(int i = n; i--;) inv_fact[i] = (i + 1) * inv_fact[i + 1];
    for(int i = 1; i <= n; ++i) minv[i] = inv_fact[i] * fact[i - 1];
}
mint binom(int n, int k) {
    if(k < 0 or k > n) return 0;
    return fact[n] * inv_fact[k] * inv_fact[n - k];
}
template <>
mint &mint::operator/=(mint b) {
    return *this *= b.v < minv.size() ? minv[b.v] : power(b, mod - 2);
}
constexpr ll mod = 1e9+9;
main() {
    INT(n);
    ll a = 430477711, b = 569522298;
    vector<mint> f1(n + 1), f2(n + 1);
    rep2(i, 1, n) f1[i] = (i + 1) * (i + 1) % mod * a;
    rep2(i, 1, n) f2[i] = (i + 1) * (i + 1) % mod * b;
    prepare(2 * (n + 1));
    f1 = exponent(f1);
    f2 = exponent(f2);
    ll p = 1;
    rep2(i, 1, n) p = p * i % mod;
    rep2(i, 1, n) f1[i] *= p, f2[i] *= p;
    mint I = power<mint>(b - a, mod - 2);
    rep2(i, 1, n) {
        mint c = (f2[i] - f1[i]) * I;
        cout << (c.v + (f1[i] - c * a).v) % mod << endl;
    }
}
0