結果
| 問題 |
No.3228 Very Large Fibonacci Sum
|
| ユーザー |
 bandai
|
| 提出日時 | 2025-10-15 15:13:24 |
| 言語 | C++23 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 2 ms / 2,000 ms |
| コード長 | 12,377 bytes |
| コンパイル時間 | 6,324 ms |
| コンパイル使用メモリ | 335,548 KB |
| 実行使用メモリ | 7,720 KB |
| 最終ジャッジ日時 | 2025-10-15 15:13:32 |
| 合計ジャッジ時間 | 8,178 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 23 |
ソースコード
#include <bits/stdc++.h>
using namespace std;
#include <atcoder/all>
using namespace atcoder;
template <typename T>
using vc = vector<T>;
template <typename T>
using vv = vc<vc<T>>;
//-------------1.型系---------------
using ll = long long;
ll INF = 2e18;
using ld = long double;
using bl = bool;
using mint = modint998244353;
// using mint = modint1000000007;
// using mint = modint;
// mint::set_mod(m);
template <class T>
using pq = priority_queue<T, vc<T>>;
template <class T>
using pq_g = priority_queue<T, vc<T>, greater<T>>;
//-----------------------------------
//-------------2.配列系--------------
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
template <class T>
istream& operator>>(istream& i, vc<T>& v) {
rep(j, size(v)) i >> v[j];
return i;
}
using ar2 = array<ll, 2>;
//----------------------------------
//--------3.コード短縮化とか---------
const double PI = 3.141592653589793238;
const int inf = 1073741823;
const ll infl = 1LL << 60;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string abc = "abcdefghijklmnopqrstuvwxyz";
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define drep(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define nfor(i, s, n) for (ll i = s; i < n; i++)
#define dfor(i, s, n) for (ll i = (s) - 1; i >= n; i--)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YN \
{ \
cout << "Yes" << endl; \
} \
else { \
cout << "No" << endl; \
} // if(a==b)YN;
#define vc_unique(v) v.erase(unique(v.begin(), v.end()), v.end());
#define vc_rotate(v) rotate(v.begin(), v.begin() + 1, v.end());
#define pop_cnt(s) ll(popcount(uint64_t(s)))
#define next_p(v) next_permutation(v.begin(), v.end())
//-------------------------------
//---------4.グリッド系----------
vector<int> dx = {1, 0, -1, 0}; // dx={1,1,0,-1,-1,-1,0,1};
vector<int> dy = {0, 1, 0, -1}; // dy={0,1,1,1,0,-1,-1,-1};
bool out_grid(ll i, ll j, ll h, ll w = -1) {
if (w == -1) {
w = h;
}
return (!(0 <= i && i < h && 0 <= j && j < w));
}
#define vvl_rotate(v) \
{ \
ll n = size(v); \
vvl nx(n, vl(n)); \
rep(i, n) rep(j, n) nx[j][n - i - 1] = v[i][j]; \
swap(nx, v); \
} // 時計回りに90°回転
// #define vvl_rotate(v) {ll n = size(v);vvl
// nx(n,vl(n));rep(i,n)rep(j,n)nx[n-j-1][i]=v[i][j];swap(nx,v);}//反時計周りに90°回転
#define vs_rotate(v) \
{ \
ll n = size(v); \
vs nx(n, string(n, '.')); \
rep(i, n) rep(j, n) nx[j][n - i - 1] = v[i][j]; \
swap(nx, v); \
} // 文字列版 時計回りに90°回転
// #define vs_rotate(v) {ll n = size(v);vs
// nx(n,string(n,'.'));rep(i,n)rep(j,n)nx[n-j-1][i]=v[i][j];swap(nx,v);}//文字列版 反時計周りに90°回転
#define vvl_transpos(v) \
{ \
ll n = size(v); \
vvl nx(n, vl(n)); \
rep(i, n) rep(j, n) nx[j][i] = v[i][j]; \
swap(nx, v); \
}
#define vs_transpos(v) \
{ \
ll n = size(v); \
vs nx(n, string(n, '.')); \
rep(i, n) rep(j, n) nx[j][i] = v[i][j]; \
swap(nx, v); \
}
//--------------------------------
//-----------5.数学系--------------
#define euclid(x, y) ((x) * (x) + (y) * (y)) // ユークリッド距離 2乗のまま
#define manhattan(x1, x2, y1, y2) \
(abs(x1 - x2) + abs(y1 - y2)) // マンハッタン距離 = |x1-x2|+|y1-y2|
template <class T>
T tousa_sum1(T l, T d, T r) { // 初項,公差,末項 で総和を求める
T wide = (r - l) / d + 1;
return (l + r) * wide / 2;
}
template <class T>
T tousa_sum2(T a, T d, T n) { // 初項,交差,項数 で総和を求める
return (a * 2 + d * (n - 1)) * n / 2;
}
ll kousa_kousuu(ll l, ll r, ll d) { // 初項,末項,交差 で等差数列の項数を求める
return (r - l) / d + 1;
}
mint touhi_sum(mint a, mint r,
ll n) { // 初項,公比,項数で等比数列の総和を求める
if (r == 1) {
return a * n;
}
mint bunsi = a * (r.pow(n) - mint(1));
mint bunbo = r - 1;
return bunsi / bunbo;
}
ll nc2(ll x) { return x * (x - 1) / 2; }
ll nc3(ll x) { return x * (x - 1) * (x - 2) / 6; }
//----------------------------------------------
//-----------6.デバックや出力系------------------
void print(ld x) { printf("%.20Lf\n", x); }
#define print_vec(v) \
{ \
ll n = size(v); \
rep(i, n) cout << v[i] << " "; \
cout << endl; \
} // 一次元配列を出力する(改行なし)
#define vc_cout(v) \
{ \
ll n = size(v); \
rep(i, n) cout << v[i] << endl; \
} // 一次元配列を出力する(改行あり)
#define vv_cout(v) \
{ \
ll n = size(v); \
rep(i, n) { \
rep(j, size(v[i])) { cout << v[i][j] << ' '; } \
cout << endl; \
} \
} // 二次元配列を出力する
//----------------------------------------------
// pivot 候補 : [0, pivot_end)
template <typename T>
std::pair<int, T> GaussElimination(vector<vector<T>>& a, int pivot_end = -1,
bool diagonalize = false) {
if (a.empty()) return {0, 1};
int H = a.size(), W = a[0].size(), rank = 0;
if (pivot_end == -1) pivot_end = W;
T det = 1;
for (int j = 0; j < pivot_end; j++) {
int idx = -1;
for (int i = rank; i < H; i++) {
if (a[i][j] != T(0)) {
idx = i;
break;
}
}
if (idx == -1) {
det = 0;
continue;
}
if (rank != idx) det = -det, swap(a[rank], a[idx]);
det *= a[rank][j];
if (diagonalize && a[rank][j] != T(1)) {
T coeff = T(1) / a[rank][j];
for (int k = j; k < W; k++) a[rank][k] *= coeff;
}
int is = diagonalize ? 0 : rank + 1;
for (int i = is; i < H; i++) {
if (i == rank) continue;
if (a[i][j] != T(0)) {
T coeff = a[i][j] / a[rank][j];
for (int k = j; k < W; k++) a[i][k] -= a[rank][k] * coeff;
}
}
rank++;
}
return make_pair(rank, det);
}
template <typename mint>
vector<vector<mint>> inverse_matrix(const vector<vector<mint>>& a) {
int N = a.size();
assert(N > 0);
assert(N == (int)a[0].size());
vector<vector<mint>> m(N, vector<mint>(2 * N));
for (int i = 0; i < N; i++) {
copy(begin(a[i]), end(a[i]), begin(m[i]));
m[i][N + i] = 1;
}
auto [rank, det] = GaussElimination(m, N, true);
if (rank != N) return {};
vector<vector<mint>> b(N);
for (int i = 0; i < N; i++) {
copy(begin(m[i]) + N, end(m[i]), back_inserter(b[i]));
}
return b;
}
template <class T>
struct Matrix {
vector<vector<T>> A;
Matrix() = default;
Matrix(int n, int m) : A(n, vector<T>(m, T())) {}
Matrix(int n) : A(n, vector<T>(n, T())) {};
int H() const { return A.size(); }
int W() const { return A[0].size(); }
int size() const { return A.size(); }
inline const vector<T>& operator[](int k) const { return A[k]; }
inline vector<T>& operator[](int k) { return A[k]; }
static Matrix I(int n) {
Matrix mat(n);
for (int i = 0; i < n; i++) mat[i][i] = 1;
return (mat);
}
Matrix& operator+=(const Matrix& B) {
int n = H(), m = W();
assert(n == B.H() && m == B.W());
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) (*this)[i][j] += B[i][j];
return (*this);
}
Matrix& operator-=(const Matrix& B) {
int n = H(), m = W();
assert(n == B.H() && m == B.W());
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) (*this)[i][j] -= B[i][j];
return (*this);
}
Matrix& operator*=(const Matrix& B) {
int n = H(), m = B.W(), p = W();
assert(p == B.H());
vector<vector<T>> C(n, vector<T>(m, T{}));
for (int i = 0; i < n; i++)
for (int k = 0; k < p; k++)
for (int j = 0; j < m; j++) C[i][j] += (*this)[i][k] * B[k][j];
A.swap(C);
return (*this);
}
Matrix& operator^=(long long k) {
Matrix B = Matrix::I(H());
while (k > 0) {
if (k & 1) B *= *this;
*this *= *this;
k >>= 1LL;
}
A.swap(B.A);
return (*this);
}
Matrix operator+(const Matrix& B) const { return (Matrix(*this) += B); }
Matrix operator-(const Matrix& B) const { return (Matrix(*this) -= B); }
Matrix operator*(const Matrix& B) const { return (Matrix(*this) *= B); }
Matrix operator^(const long long k) const { return (Matrix(*this) ^= k); }
bool operator==(const Matrix& B) const {
assert(H() == B.H() && W() == B.W());
for (int i = 0; i < H(); i++)
for (int j = 0; j < W(); j++)
if (A[i][j] != B[i][j]) return false;
return true;
}
bool operator!=(const Matrix& B) const {
assert(H() == B.H() && W() == B.W());
for (int i = 0; i < H(); i++)
for (int j = 0; j < W(); j++)
if (A[i][j] != B[i][j]) return true;
return false;
}
Matrix inverse() const {
assert(H() == W());
Matrix B(H());
B.A = inverse_matrix(A);
return B;
}
friend ostream& operator<<(ostream& os, const Matrix& p) {
int n = p.H(), m = p.W();
for (int i = 0; i < n; i++) {
os << (i ? " " : "") << "[";
for (int j = 0; j < m; j++) {
os << p[i][j] << (j + 1 == m ? "]\n" : ",");
}
}
return (os);
}
T determinant() const {
Matrix B(*this);
assert(H() == W());
T ret = 1;
for (int i = 0; i < H(); i++) {
int idx = -1;
for (int j = i; j < W(); j++) {
if (B[j][i] != 0) {
idx = j;
break;
}
}
if (idx == -1) return 0;
if (i != idx) {
ret *= T(-1);
swap(B[i], B[idx]);
}
ret *= B[i][i];
T inv = T(1) / B[i][i];
for (int j = 0; j < W(); j++) {
B[i][j] *= inv;
}
for (int j = i + 1; j < H(); j++) {
T a = B[j][i];
if (a == 0) continue;
for (int k = i; k < W(); k++) {
B[j][k] -= B[i][k] * a;
}
}
}
return ret;
}
};
int main() {
ll a, b, c, d, e, n;
cin >> a >> b >> c >> d >> e >> n, n++;
Matrix<static_modint<1000000007>> vec(1, 4), mat(4);
vec[0] = {0, a, b, e};
vector<vector<static_modint<1000000007>>> mat_v = {
{1, 0, 0, 0}, {1, 0, d, 0}, {0, 1, c, 0}, {0, 0, 1, 1}};
rep(i, 4) rep(j, 4) mat[i][j] = mat_v[i][j];
mat ^= n;
vec *= mat;
cout << vec[0][0].val() << endl;
}