#411268 (C++17) No.510 二次漸化式

提出ソース

結果

問題	No.510 二次漸化式
ユーザー	Haar
提出日時	2019-12-23 00:31:05
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	AC
実行時間	447 ms / 3,000 ms
コード長	11,371 bytes
コンパイル時間	2,399 ms
コンパイル使用メモリ	213,648 KB
実行使用メモリ	37,688 KB
最終ジャッジ日時	2024-09-14 21:20:24
合計ジャッジ時間	14,296 ms
ジャッジサーバーID （参考情報）	judge5 / judge4

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	2 ms 5,248 KB
testcase_01	AC	2 ms 5,376 KB
testcase_02	AC	60 ms 5,376 KB
testcase_03	AC	60 ms 5,376 KB
testcase_04	AC	60 ms 5,376 KB
testcase_05	AC	60 ms 5,376 KB
testcase_06	AC	106 ms 7,424 KB
testcase_07	AC	106 ms 7,340 KB
testcase_08	AC	107 ms 7,532 KB
testcase_09	AC	107 ms 7,424 KB
testcase_10	AC	32 ms 5,376 KB
testcase_11	AC	32 ms 5,376 KB
testcase_12	AC	33 ms 5,376 KB
testcase_13	AC	33 ms 5,376 KB
testcase_14	AC	33 ms 5,376 KB
testcase_15	AC	32 ms 5,376 KB
testcase_16	AC	392 ms 37,592 KB
testcase_17	AC	393 ms 37,504 KB
testcase_18	AC	394 ms 37,576 KB
testcase_19	AC	394 ms 37,520 KB
testcase_20	AC	394 ms 37,524 KB
testcase_21	AC	395 ms 37,632 KB
testcase_22	AC	395 ms 37,596 KB
testcase_23	AC	443 ms 37,552 KB
testcase_24	AC	442 ms 37,600 KB
testcase_25	AC	447 ms 37,688 KB
testcase_26	AC	442 ms 37,592 KB
testcase_27	AC	441 ms 37,616 KB
testcase_28	AC	443 ms 37,552 KB
testcase_29	AC	443 ms 37,632 KB
testcase_30	AC	442 ms 37,612 KB
testcase_31	AC	430 ms 37,448 KB
testcase_32	AC	430 ms 37,632 KB
testcase_33	AC	435 ms 37,512 KB
testcase_34	AC	443 ms 37,632 KB
testcase_35	AC	424 ms 37,632 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

#include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for(LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for(LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for(LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for(auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for(auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c,x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL<<(i))

#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif

#define gcd __gcd

using namespace std;
template <class T> constexpr T lcm(T m, T n){return m/gcd(m,n)*n;}

template <typename I> void join(ostream &ost, I s, I t, string d=" "){for(auto i=s; i!=t; ++i){if(i!=s)ost<<d; ost<<*i;}ost<<endl;}
template <typename T> istream& operator>>(istream &is, vector<T> &v){for(auto &a : v) is >> a; return is;}
template <typename T, typename U> bool chmin(T &a, const U &b){return (a>b ? a=b, true : false);}
template <typename T, typename U> bool chmax(T &a, const U &b){return (a<b ? a=b, true : false);}
template <typename T, size_t N, typename U> void fill_array(T (&a)[N], const U &v){fill((U*)a, (U*)(a+N), v);}

struct Init{
  Init(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(12);
    cerr << fixed << setprecision(12);
  }
}init;


template <std::uint32_t M> class ModInt{
public:
  std::uint64_t val;
  ModInt(): val(0){}
  ModInt(std::int64_t n){
    if(n >= M) val = n % M;
    else if(n < 0) val = n % M + M;
    else val = n;
  }
  
  inline constexpr ModInt operator+(const ModInt &a) const {return ModInt((val+a.val) % M);}
  inline constexpr ModInt operator-(const ModInt &a) const {return ModInt((val-a.val+M) % M);}
  inline constexpr ModInt operator*(const ModInt &a) const {return ModInt((val*a.val) % M);}
  inline constexpr ModInt operator/(const ModInt &a) const {return ModInt((val*a.inv().val) % M);}
  
  inline constexpr ModInt& operator=(const ModInt &a){val = a.val; return *this;}
  inline constexpr ModInt& operator+=(const ModInt &a){if((val += a.val) >= M) val -= M; return *this;}
  inline constexpr ModInt& operator-=(const ModInt &a){if(val < a.val) val += M; val -= a.val; return *this;}
  inline constexpr ModInt& operator*=(const ModInt &a){(val *= a.val) %= M; return *this;}
  inline constexpr ModInt& operator/=(const ModInt &a){(val *= a.inv().val) %= M; return *this;}

  inline constexpr bool operator==(const ModInt &a) const {return val == a.val;}
  inline constexpr bool operator!=(const ModInt &a) const {return val != a.val;}

  inline constexpr ModInt& operator++(){*this += 1; return *this;}
  inline constexpr ModInt& operator--(){*this -= 1; return *this;}

  inline constexpr ModInt operator++(int){ModInt t = *this; *this += 1; return t;}
  inline constexpr ModInt operator--(int){ModInt t = *this; *this -= 1; return t;}

  inline constexpr static ModInt frac(std::int64_t a, std::int64_t b){
    return ModInt(a) / ModInt(b);
  }
  
  inline constexpr static ModInt power(std::int64_t n, std::int64_t p){
    ModInt ret = 1, e = n;
    for(; p; e *= e, p >>= 1) if(p&1) ret *= e;
    return ret;
  }

  inline constexpr ModInt power(std::int64_t p) const {return power(val,p);}
  
  inline constexpr ModInt inv() const {
    std::int64_t a = val, b = M, u = 1, v = 0;
    
    while(b){
      std::int64_t t = a/b;
      a -= t*b; std::swap(a,b);
      u -= t*v; std::swap(u,v);
    }
    u %= M;
    if(u < 0) u += M;
    
    return u;
  }
};

template <std::uint32_t M> ModInt<M> operator-(const ModInt<M> &a){return M-a.val;}

template <std::uint32_t M> ModInt<M> operator+(std::int64_t a, const ModInt<M> &b){return ModInt<M>(ModInt<M>(a)+b.val);}
template <std::uint32_t M> ModInt<M> operator-(std::int64_t a, const ModInt<M> &b){return ModInt<M>(ModInt<M>(a)-b.val);}
template <std::uint32_t M> ModInt<M> operator*(std::int64_t a, const ModInt<M> &b){return ModInt<M>(ModInt<M>(a)*b.val);}
template <std::uint32_t M> ModInt<M> operator/(std::int64_t a, const ModInt<M> &b){return ModInt<M>(ModInt<M>(a)/b.val);}

template <std::uint32_t M> std::istream& operator>>(std::istream &is, ModInt<M> &a){is >> a.val; return is;}
template <std::uint32_t M> std::ostream& operator<<(std::ostream &os, const ModInt<M> &a){ os << a.val; return os;}


template <typename T, int N> struct SquareMatrix{
  std::array<std::array<T,N>,N> matrix;

  SquareMatrix(): matrix(){}
  SquareMatrix(const T &val){
    for(size_t i = 0; i < N; ++i) matrix[i].fill(val);
  }
  SquareMatrix(const SquareMatrix<T,N> &) = default;
  SquareMatrix(SquareMatrix<T,N> &&) = default;
  SquareMatrix(std::initializer_list<std::initializer_list<T>> list){
    int i = 0;
    for(auto it1 = list.begin(); it1 != list.end(); ++it1){
      int j = 0;
      for(auto it2 = it1->begin(); it2 != it1->end(); ++it2){
        matrix[i][j] = *it2;
        ++j;
      }
      ++i;
    }
  }

  bool operator==(const SquareMatrix<T,N> &val) const {
    return matrix == val.matrix;
  }

  bool operator!=(const SquareMatrix<T,N> &val) const {
    return !(*this == val);
  }

  SquareMatrix& operator=(const SquareMatrix &) = default;

  SquareMatrix& operator+=(const SquareMatrix &val){
    for(size_t i = 0; i < N; ++i){
      for(size_t j = 0; j < N; ++j){
        matrix[i][j] = matrix[i][j] + val[i][j];
      }
    }
    return *this;
  }

  SquareMatrix& operator-=(const SquareMatrix &val){
    for(size_t i = 0; i < N; ++i){
      for(size_t j = 0; j < N; ++j){
        matrix[i][j] = matrix[i][j] - val[i][j];
      }
    }
    return *this;
  }

  SquareMatrix& operator*=(const SquareMatrix &val){
    std::array<std::array<T,N>,N> temp = {};
    for(size_t i = 0; i < N; ++i){
      for(size_t j = 0; j < N; ++j){
        for(size_t k = 0; k < N; ++k){
          temp[i][j] = temp[i][j] + matrix[i][k] * val[k][j];
        }
      }
    }
    std::swap(matrix, temp);
    return *this;
  }

  inline const auto& operator[](size_t i) const {return matrix[i];}
  inline auto& operator[](size_t i){return matrix[i];}
  inline int size() const {return N;}
  
  static SquareMatrix<T,N> make_unit(){
    SquareMatrix<T,N> ret;
    for(size_t i = 0; i < N; ++i) ret[i][i] = 1;
    return ret;
  }

  SquareMatrix<T,N> transpose() const {
    SquareMatrix<T,N> ret;
    for(size_t i = 0; i < N; ++i){
      for(size_t j = 0; j < N; ++j){
        ret[i][j] = matrix[j][i];
      }
    }
    return ret;
  }
 
  void show(int w = 10) const {
#ifdef DEBUG
    std::cerr << "⎛" << std::string((w+1)*N, ' ') << "⎞" << std::endl;
    for(size_t i = 0; i < N; ++i){
      std::cerr << "⎜";
      for(size_t j = 0; j < N; ++j) std::cerr << std::setw(w) << matrix[i][j] << " ";
      std::cerr << "⎟";
      std::cerr << std::endl;
    }
    std::cerr << "⎝" << std::string((w+1)*N, ' ') << "⎠" << std::endl;
#endif
  }
};

template <typename T, int N> SquareMatrix<T,N> operator+(const SquareMatrix<T,N> &a, const SquareMatrix<T,N> &b){auto ret = a; ret += b; return ret;}
template <typename T, int N> SquareMatrix<T,N> operator-(const SquareMatrix<T,N> &a, const SquareMatrix<T,N> &b){auto ret = a; ret -= b; return ret;}
template <typename T, int N> SquareMatrix<T,N> operator*(const SquareMatrix<T,N> &a, const SquareMatrix<T,N> &b){auto ret = a; ret *= b; return ret;}

template <typename T, int N> SquareMatrix<T,N> power(SquareMatrix<T,N> a, uint64_t p){
  if(p == 0) return SquareMatrix<T,N>::make_unit();
  if(p == 1) return a;
  
  SquareMatrix<T,N> temp = power(a, p/2);
  auto ret = temp * temp;

  if(p%2) ret *= a;
 
  return ret;
}

template <typename T, int N> std::vector<T> operator*(const SquareMatrix<T,N> &a, const std::vector<T> &b){
  std::vector<T> ret(N);

  for(size_t i = 0; i < N; ++i){
    for(size_t j = 0; j < N; ++j){
      ret[i] += a[i][j] * b[j];
    }
  }

  return ret;
}

template <typename T, int N> std::vector<T> operator*(const std::vector<T> &b, const SquareMatrix<T,N> &a){
  std::vector<T> ret(N);

  for(size_t i = 0; i < N; ++i){
    for(size_t j = 0; j < N; ++j){
      ret[j] += b[i] * a[i][j];
    }
  }

  return ret;
}


/**
 * @details eは単位元
 */
template <typename T, typename Func>
class SegmentTree{
protected:
  int size;
  std::vector<T> data;
  const T e;
  const Func f;

  inline T get_aux(int x, int y, int i, int l, int r) const {
    if(r <= x || y <= l) return e;
    else if(x <= l && r <= y) return data[i];
    else return f(get_aux(x,y,i*2+1,l,(l+r)/2), get_aux(x,y,i*2+2,(l+r)/2,r));
  };

public:
  SegmentTree(int n, const T &e, const Func &f): e(e), f(f){
    size = 1;
    while(size < n) size *= 2;
    size = size*2-1;
    data = std::vector<T>(size, e);
  }

  inline T operator[](int i) const {
    return at(i);
  }

  inline T at(int i) const {
  	return data[(size+1)/2 + i - 1];
  }

  inline T get(int x, int y) const { // [x,y)
    return get_aux(x,y,0,0,(size+1)/2);
  }

  inline void update(int i, const T &x){
    int j = i+(size+1)/2-1;
    data[j] = x;
    --j;
    while(j>=0){
      data[j/2] = f(data[(j/2)*2+1], data[(j/2)*2+2]);
      (j /= 2) -= 1;
    }
  }

  void debug(){
#ifdef DEBUG
    std::cerr << "{";

    for(int i = 0; i <= size/2; ++i){
      if(i) std::cerr << ",";
      std::cerr << data[(size+1) / 2 + i - 1];
    }

    std::cerr << "}" << std::endl;
#endif
  }
};


template <typename T>
auto make_segment_tree_range_product(int size, const T &e){
  auto f = [](const auto &a, const auto &b){return a * b;};
  return SegmentTree<T, decltype(f)>(size, e, f);
}





using mint = ModInt<1000000007>;
using M = SquareMatrix<mint, 4>;

int main(){
  int n, q;
  while(cin >> n >> q){
    auto seg = make_segment_tree_range_product<M>(n, M::make_unit());
    vector<mint> x(n), y(n);

    REP(i,n){
      M t = {{1, 0, x[i], 0}, {0, y[i], 0, 1}, {0, 2*y[i], y[i]*y[i], 1}, {0, 0, 0, 1}};
      seg.update(i, t.transpose());
    }
    

    while(q--){
      char c; cin >> c;

      if(c == 'x'){
        int i, v; cin >> i >> v;
        x[i] = v;

        M t = {{1, 0, x[i], 0}, {0, y[i], 0, 1}, {0, 2*y[i], y[i]*y[i], 1}, {0, 0, 0, 1}};

        seg.update(i, t.transpose());
        
      }else if(c == 'y'){
        int i, v; cin >> i >> v;
        y[i] = v;

        M t = {{1, 0, x[i], 0}, {0, y[i], 0, 1}, {0, 2*y[i], y[i]*y[i], 1}, {0, 0, 0, 1}};

        seg.update(i, t.transpose());

      }else{
        int i; cin >> i;

        if(i == 0){
          cout << 1 << endl;
        }else{
          auto m = seg.get(0, i);
          mint ans = m[0][0] + m[1][0] + m[2][0] + m[3][0];

          cout << ans << endl;
        }
      }
      /*
      {
        mint a = 1, b = 1;

        REP(j,n){
          auto A = a, B = b;
          a = x[j] * B * B + A;
          b = y[j] * B + 1;
          cerr << a << "  " << b << endl;
        }
      }

      
      REP(i,n){
        auto m = seg.get(0, i+1);

        mint a = 0, b = 0;
        REP(j,4){
          a += m[j][0];
          b += m[j][1];
        }
        
        cerr << "a[" << i << "] = " << a  << ", b[" << i << "] = " << b << endl;
        }*/
      
    }
    cerr << endl;
  }

  return 0;
}

yukicoder

結果

テストケース

ソースコード