結果

問題 No.510 二次漸化式
ユーザー kyunakyuna
提出日時 2019-09-24 14:08:45
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 554 ms / 3,000 ms
コード長 4,407 bytes
コンパイル時間 1,272 ms
コンパイル使用メモリ 95,056 KB
実行使用メモリ 70,952 KB
最終ジャッジ日時 2024-09-19 05:07:06
合計ジャッジ時間 13,782 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 2 ms
6,940 KB
testcase_02 AC 151 ms
6,940 KB
testcase_03 AC 149 ms
6,944 KB
testcase_04 AC 149 ms
6,940 KB
testcase_05 AC 154 ms
6,944 KB
testcase_06 AC 225 ms
11,776 KB
testcase_07 AC 232 ms
11,648 KB
testcase_08 AC 230 ms
11,648 KB
testcase_09 AC 218 ms
11,648 KB
testcase_10 AC 78 ms
6,940 KB
testcase_11 AC 78 ms
6,940 KB
testcase_12 AC 80 ms
6,940 KB
testcase_13 AC 80 ms
6,944 KB
testcase_14 AC 78 ms
6,940 KB
testcase_15 AC 78 ms
6,944 KB
testcase_16 AC 349 ms
70,744 KB
testcase_17 AC 345 ms
70,892 KB
testcase_18 AC 352 ms
70,776 KB
testcase_19 AC 333 ms
70,768 KB
testcase_20 AC 341 ms
70,904 KB
testcase_21 AC 341 ms
70,772 KB
testcase_22 AC 328 ms
70,744 KB
testcase_23 AC 482 ms
70,792 KB
testcase_24 AC 485 ms
70,780 KB
testcase_25 AC 478 ms
70,780 KB
testcase_26 AC 465 ms
70,768 KB
testcase_27 AC 475 ms
70,932 KB
testcase_28 AC 474 ms
70,932 KB
testcase_29 AC 476 ms
70,884 KB
testcase_30 AC 483 ms
70,788 KB
testcase_31 AC 554 ms
70,844 KB
testcase_32 AC 531 ms
70,888 KB
testcase_33 AC 530 ms
70,952 KB
testcase_34 AC 376 ms
70,820 KB
testcase_35 AC 340 ms
70,884 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>
using namespace std;

//-----------------------
const int MOD = (int)1e9 + 7;
struct mint { int n; mint(int n_ = 0) : n(n_ % MOD) { if (n < 0) n += MOD; } };
mint operator+(mint a, mint b) { return (a.n += b.n) >= MOD ? a.n - MOD : a.n; }
mint operator-(mint a, mint b) { return (a.n -= b.n) < 0 ? a.n + MOD : a.n; }
mint operator*(mint a, mint b) { return 1LL * a.n * b.n % MOD; }
mint &operator+=(mint &a, mint b) { return a = a + b; }
mint &operator-=(mint &a, mint b) { return a = a - b; }
mint &operator*=(mint &a, mint b) { return a = a * b; }
ostream &operator<<(ostream &os, mint a) { return os << a.n; }
istream &operator>>(istream &is, mint& a) { return is >> a.n; }
mint inv(mint x) { long long a = x.n, b = MOD, u = 1, v = 0;
    while (b) { long long t = a/b; swap((a -= t*b), b); swap((u -= t*v), v); }
    return mint(u); }
mint operator^(mint a, long long n) { mint r = 1;
    while (n) { if (n & 1) r *= a; a *= a; n >>= 1; } return r; }
bool operator<(const mint &a, const mint &b) { return a.n < b.n; }
//-----------------------

template<typename Monoid>
struct SegmentTree {
    using F = function<Monoid(Monoid, Monoid)>;
    const F f;
    const Monoid M1;
    int sz;
    vector<Monoid> dat;
    SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1), sz(1) {
        while (sz < n) sz <<= 1;
        dat.assign(sz * 2, M1);
    }
    void set(int k, const Monoid &x) { dat[k + sz] = x; }
    void build() {
        for (int k = sz - 1; k > 0; k--) {
            dat[k] = f(dat[2 * k], dat[2 * k + 1]);
        }
    }
    void update(int k, const Monoid &x) {
        dat[k += sz] = x;
        while (k >>= 1) dat[k] = f(dat[2 * k], dat[2 * k + 1]);
    }
    Monoid get(int a, int b) {  // [a, b)
        Monoid L = M1, R = M1;
        for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
            if (a & 1) L = f(L, dat[a++]);
            if (b & 1) R = f(dat[--b], R);
        }
        return f(L, R);
    }
    Monoid operator[](const int &k) const { return dat[k + sz]; }
    friend ostream& operator<<(ostream& os, SegmentTree<Monoid> &seg) {
        for (int i = 0; i < seg.sz; i++) os << seg[i] << " ";
        return os;
    }
};

template<class T> ostream& operator<<(ostream& os, const vector<T>& vec) {
    for (auto &vi: vec) os << vi << " "; return os;
}
template<class T> struct Matrix {
    vector<vector<T>> val;
    Matrix(int n = 1, int m = 1, T x = 0) { val.assign(n, vector<T>(m, x)); }
    size_t size() const { return val.size(); }
    vector<T>& operator[](int i) { return val[i]; }
    const vector<T>& operator[](int i) const { return val[i]; }
    friend ostream& operator<<(ostream& os, const Matrix<T> M) {
        for (int i = 0; i < M.size(); ++i) os << M[i] << " \n"[i != M.size() - 1];
        return os;
    }
};
template<class T> Matrix<T> operator*(const Matrix<T>& A, const Matrix<T>& B) {
    Matrix<T> R(A.size(), B[0].size());
    for (int i = 0; i < A.size(); ++i) for (int j = 0; j < B[0].size(); ++j)
        for (int k = 0; k < B.size(); ++k) R[i][j] += A[i][k] * B[k][j];
    return R;
}
template<class T> vector<T> operator*(const Matrix<T> &A, vector<T> &B) {
    vector<T> v(A.size());
    for (int i = 0; i < A.size(); ++i)
        for (int k = 0; k < B.size(); ++k) v[i] += A[i][k] * B[k];
    return v;
}

int main() {
    int n; cin >> n;
    vector<mint> x0(4, 1);
    using M = Matrix<mint>;
    M I(4, 4); for (int i = 0; i < 4; i++) I[i][i] = 1;
    M G0(4, 4); G0[0][0] = G0[1][3] = G0[2][3] = G0[3][3] = 1;
    auto update_x = [](M G, mint xi) {
        G[0][2] = xi;
        return G;
    };
    auto update_y = [](M G, mint yi) {
        G[1][1] = yi, G[2][1] = yi * 2, G[2][2] = yi * yi;
        return G;
    };
    auto f = [](const M &a, const M &b) { return b * a; };
    SegmentTree<M> seg(n, f, I);
    for (int i = 0; i < n; i++) seg.set(i, G0);
    seg.build();
    int q; cin >> q;
    while (q--) {
        char com; cin >> com;
        if (com == 'x') {
            int i; mint v; cin >> i >> v;
            seg.update(i, update_x(seg[i], v));
        }
        if (com == 'y') {
            int i; mint v; cin >> i >> v;
            seg.update(i, update_y(seg[i], v));
        }
        if (com == 'a') {
            int i; cin >> i;
            cout << (seg.get(0, i) * x0)[0] << endl;
        }
    }
    return 0;
}
0