結果

問題 No.510 二次漸化式
ユーザー tottoripapertottoripaper
提出日時 2017-05-05 22:01:37
言語 C++14
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 528 ms / 3,000 ms
コード長 3,997 bytes
コンパイル時間 2,291 ms
コンパイル使用メモリ 184,488 KB
実行使用メモリ 92,232 KB
最終ジャッジ日時 2024-09-14 08:48:43
合計ジャッジ時間 18,373 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 148 ms
90,752 KB
testcase_01 AC 148 ms
90,752 KB
testcase_02 AC 368 ms
90,752 KB
testcase_03 AC 373 ms
90,552 KB
testcase_04 AC 372 ms
90,752 KB
testcase_05 AC 369 ms
90,752 KB
testcase_06 AC 403 ms
90,732 KB
testcase_07 AC 402 ms
91,008 KB
testcase_08 AC 395 ms
90,752 KB
testcase_09 AC 403 ms
90,880 KB
testcase_10 AC 360 ms
90,696 KB
testcase_11 AC 359 ms
90,880 KB
testcase_12 AC 365 ms
90,752 KB
testcase_13 AC 362 ms
90,752 KB
testcase_14 AC 361 ms
90,556 KB
testcase_15 AC 358 ms
90,556 KB
testcase_16 AC 308 ms
92,104 KB
testcase_17 AC 308 ms
92,108 KB
testcase_18 AC 310 ms
92,228 KB
testcase_19 AC 309 ms
92,232 KB
testcase_20 AC 312 ms
92,232 KB
testcase_21 AC 309 ms
92,104 KB
testcase_22 AC 309 ms
92,104 KB
testcase_23 AC 473 ms
92,100 KB
testcase_24 AC 470 ms
92,104 KB
testcase_25 AC 486 ms
92,232 KB
testcase_26 AC 481 ms
92,232 KB
testcase_27 AC 477 ms
92,104 KB
testcase_28 AC 479 ms
92,232 KB
testcase_29 AC 476 ms
92,108 KB
testcase_30 AC 478 ms
92,100 KB
testcase_31 AC 527 ms
91,464 KB
testcase_32 AC 528 ms
91,340 KB
testcase_33 AC 523 ms
92,108 KB
testcase_34 AC 366 ms
90,660 KB
testcase_35 AC 304 ms
90,568 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>

using namespace std;

#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)

using ll = long long;
using P = std::tuple<int,int>;

const int dx[8] = {-1, 1, 0, 0, -1, -1, 1, 1}, dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};

const ll MOD = 1e9 + 7;

template <typename T>
using Matrix = std::vector<std::vector<T>>;

namespace tottori{
    template <typename T>
    Matrix<T> mult(const Matrix<T>& m2, const Matrix<T>& m1){
        assert(m1.size() > 0);
        assert(m2.size() > 0);
        assert(m1[0].size() == m2.size());
        int n = m1.size(), m = m1[0].size(), l = m2[0].size();
        
        Matrix<T> res(n);
        for(int i=0;i<n;++i){
            res[i].resize(l);

            for(int j=0;j<l;++j){
                for(int k=0;k<m;++k){
                    res[i][j] = (res[i][j] + m1[i][k] * m2[k][j]) % MOD;
                }
            }
        }

        return res;
    }
};

// I want to delete this stupid solution ;(
#define sandwich(x) [](auto a, auto b){return (x)(a, b);}

template <typename T>
using F2 = std::function<T(T,T)>;

template <typename T, int N, typename F = std::plus<T>>
    struct SegmentTree{
        SegmentTree(T u, F f = F()){
            size = 1;
            while(size < N){
                size <<= 1;
            }

            unit = u;
            func = f;

            init();
        }
        void init(){
            for(int i=1;i<=2*size-1;++i){
                data[i] = {{1, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}};
            }
        }
        void update(int k, T v){
            k += size;
            data[k] = v;

            while(k > 1){
                k >>= 1;
                data[k] = func(data[k*2], data[k*2+1]);
            }
        }
        inline T query(int l, int r){
            return _query(l, r, 1, 0, size);
        }
        T _query(int a, int b, int k, int l, int r){
            if(b <= l || r <= a){return unit;}
            if(a <= l && r <= b){return data[k];}
            int mid = (l + r) >> 1;
            return func(_query(a, b,   2*k,   l, mid),
                        _query(a, b, 2*k+1, mid, r  ));
        }

        T unit, data[N*4];
        int size;
        F func;
    };

SegmentTree<Matrix<ll>, 100100, F2<Matrix<ll>>> segtree({{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}, sandwich(tottori::mult));
ll xs[100100], ys[100100];

void update(int i){
    Matrix<ll> mat = {{1, 0, xs[i], 0}, {0, ys[i], 0, 1}, {0, ys[i] * 2 % MOD, ys[i] * ys[i] % MOD, 1}, {0, 0, 0, 1}};
    segtree.update(i, mat);
}

int main(){
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    int N;
    std::cin >> N;
    
    int Q;
    std::cin >> Q;

    for(int i=0;i<Q;++i){
        char c;
        std::cin >> c;

        if(c == 'x'){
            int i, v;
            std::cin >> i >> v;

            xs[i] = v;
            update(i);
        }else if(c == 'y'){
            int i, v;
            std::cin >> i >> v;

            ys[i] = v;
            update(i);
        }else{
            int i;
            std::cin >> i;

            int ai = 0;
            if(i == 0){
                ai = 1;
            }else{
                Matrix<ll> coefficientMatrix = segtree.query(0, i);

                // auto f = [](const Matrix<ll>& mat){
                //         int n = mat.size(), m = mat[0].size();

                //         for(int i=0;i<n;++i){
                //             for(int j=0;j<m;++j){
                //                 std::cout << mat[i][j] << " \n"[j+1==m];
                //             }
                //         }
                //         std::cout << "------------------------------------------------------------" << std::endl;
                //     };
                
                for(int i=0;i<4;++i){
                    ai = (ai + coefficientMatrix[0][i]) % MOD;
                }
            }

            std::cout << ai << std::endl;
        }
    }
}
0