結果

問題 No.658 テトラナッチ数列 Hard
ユーザー rsk0315rsk0315
提出日時 2019-06-01 01:40:57
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 321 ms / 2,000 ms
コード長 2,411 bytes
コンパイル時間 828 ms
コンパイル使用メモリ 78,496 KB
実行使用メモリ 6,944 KB
最終ジャッジ日時 2024-09-17 19:52:01
合計ジャッジ時間 3,355 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 2 ms
6,944 KB
testcase_02 AC 2 ms
6,944 KB
testcase_03 AC 3 ms
6,940 KB
testcase_04 AC 114 ms
6,940 KB
testcase_05 AC 131 ms
6,944 KB
testcase_06 AC 167 ms
6,940 KB
testcase_07 AC 181 ms
6,940 KB
testcase_08 AC 216 ms
6,944 KB
testcase_09 AC 321 ms
6,944 KB
testcase_10 AC 320 ms
6,940 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <cstdio>
#include <cstdint>
#include <vector>
#include <algorithm>
#include <stdexcept>

template <typename Tp>
class matrix {
public:
  using value_type = Tp;

private:
  class M_container: protected std::vector<Tp> {
    friend matrix<Tp>;
  public:
    M_container() = default;
    M_container(size_t n, Tp const& x = Tp{}): std::vector<Tp>(n, x) {}
    M_container(const std::initializer_list<Tp>& init): std::vector<Tp>(init) {}
    Tp& operator [](size_t i) { return std::vector<Tp>::operator [](i); }
    Tp const& operator [](size_t i) const { return std::vector<Tp>::operator [](i); }
  };

  size_t M_rows = 0;
  size_t M_columns = 0;
  std::vector<M_container> M_c;

  matrix M_modmul(matrix const& rhs, Tp mod) const {
    if (M_columns != rhs.M_rows) throw std::logic_error("size mismatch");

    matrix res(M_rows, rhs.M_columns);
    for (size_t i = 0; i < M_rows; ++i)
      for (size_t j = 0; j < M_columns; ++j)
        for (size_t k = 0; k < rhs.M_columns; ++k)
          (res[i][k] += (*this)[i][j] * rhs[j][k]) %= mod;

    return res;
  }

public:
  matrix(size_t n, size_t m, Tp const& x = Tp{}):
    M_rows(n), M_columns(m), M_c(n, M_container(m, x))
  {}

  matrix(std::initializer_list<std::initializer_list<Tp>> const& init) {
    for (auto const& ii: init) {
      M_c.emplace_back(ii);
      ++M_rows;
      M_columns = std::max(M_columns, ii.size());
    }
    for (auto& ci: M_c) {
      if (ci.size() < M_columns)
        ci.resize(M_columns, Tp());
    }
  }

  M_container& operator [](size_t i) { return M_c[i]; }
  M_container const& operator [](size_t i) const { return M_c[i]; }

  matrix modpow(intmax_t iexp, Tp mod) {
    if (M_rows != M_columns) throw std::logic_error("non-square matrix");

    size_t n = M_rows;
    matrix eye(n, n);
    for (size_t i = 0; i < n; ++i) eye[i][i] = Tp{1};
    matrix res = eye;
    for (matrix dbl = *this; iexp; iexp >>= 1) {
      if (iexp & 1) res = res.M_modmul(dbl, mod);
      dbl = dbl.M_modmul(dbl, mod);
    }
    return res;
  }

  void clear() { M_c.clear(); }
};

intmax_t tetra(intmax_t n) {
  matrix<int> mx{{1, 1, 1, 1},
                 {1, 0, 0, 0},
                 {0, 1, 0, 0},
                 {0, 0, 1, 0}};

  return mx.modpow(n, 17)[3][0];
}

int main() {
  size_t Q;
  scanf("%zu", &Q);

  for (size_t i = 0; i < Q; ++i) {
    intmax_t n;
    scanf("%jd", &n);
    printf("%jd\n", tetra(n-1));
  }
}
0