結果

問題 No.147 試験監督（2）
ユーザー xuzijian629xuzijian629
提出日時 2018-10-31 20:33:30
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 697 ms / 2,000 ms
コード長 8,543 bytes
コンパイル時間 3,377 ms
コンパイル使用メモリ 232,504 KB
実行使用メモリ 5,376 KB
最終ジャッジ日時 2024-04-30 01:49:14
合計ジャッジ時間 6,805 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 697 ms
5,248 KB
testcase_01 AC 696 ms
5,376 KB
testcase_02 AC 692 ms
5,376 KB
testcase_03 AC 2 ms
5,376 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
using vi = vector<i64>;
using vvi = vector<vi>;
constexpr i64 MOD = 1e9 + 7;
#pragma GCC optimize("O3")

template<int n>
struct mat {
    vvi d;
    
    mat() {
        d = vvi(n, vi(n));
    }
    
    mat(initializer_list<initializer_list<i64>> m) {
        for (auto& a: m) {
            vi row(a.begin(), a.end());
            d.emplace_back(row);
        }
        assert(n == d.size());
        assert(n == d.front().size());
    };
    
    mat operator+(const mat& rhs) {
        mat ret;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                ret.d[i][j] = d[i][j] + rhs.d[i][j];
                ret.d[i][j] %= MOD;
                ret.d[i][j] += MOD;
                ret.d[i][j] %= MOD;
            }
        }
        return ret;
    }
    
    mat operator-(const mat& rhs) {
        mat ret;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                ret.d[i][j] = d[i][j] - rhs.d[i][j];
                ret.d[i][j] %= MOD;
                ret.d[i][j] += MOD;
                ret.d[i][j] %= MOD;
            }
        }
        return ret;
    }
    
    mat operator*(const mat& rhs) {
        mat ret;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    ret.d[i][j] += d[i][k] * rhs.d[k][j];
                    ret.d[i][j] %= MOD;
                    ret.d[i][j] += MOD;
                    ret.d[i][j] %= MOD;
                }
            }
        }
        return ret;
    }
    
    mat operator*(const i64 k) {
        mat ret;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                ret.d[i][j] = d[i][j] * k;
                ret.d[i][j] %= MOD;
                ret.d[i][j] += MOD;
                ret.d[i][j] %= MOD;
            }
        }
        return ret;
    }
    
    static mat eye() {
        mat ret;
        for (int i = 0; i < n; i++) {
            ret.d[i][i] = 1;
        }
        return ret;
    }
};

template<int k>
mat<k> pow(mat<k>& a, i64 n) {
    if (n == 0) {
        return mat<k>::eye();
    }
    if (n % 2 == 0) {
        mat<k> t = pow(a, n / 2);
        return t * t;
    }
    return a * pow(a, n - 1);
}

i64 fib(i64 n) {
    if (n <= 1) return n;
    mat<2> f{{1, 1}, {1, 0}};
    mat<2> res = pow(f, n - 2);
    return (res.d[0][0] + res.d[0][1]) % MOD;
}

// 負の数は扱っていない
// 宣言するときはconvert関数を使う
// 掛け算でFFTをやるので畳み込み後の配列の最大要素を1e13程度にして誤差を小さくしたい
// BASELOGを大きくすると桁数が1/BASELOGになる代わりに配列の要素が指数関数的に大きくなる
// 掛け算をしないのであれば定数倍早くなるのでBASELOGを大きくするとよい。掛け算をするときは3が精度的に安心
constexpr i64 BASE = 100000000;
constexpr int BASELOG = 8;
struct BigInt {
    // 掛け算のために本来の最大桁数の2倍必要
    vi digit = vi(1 << 5);
    int size;
    BigInt(int size = 1, i64 a = 0) : size(size) {
        digit[0] = a;
    }
    BigInt(const BigInt& a) {
        size = a.size;
        digit = vi(a.digit);
    }
};

bool operator<(BigInt x, BigInt y) {
    if (x.size != y.size) {
        return x.size < y.size;
    }
    for (int i = x.size - 1; i >= 0; i--) {
        if (x.digit[i] != y.digit[i]) {
            return x.digit[i] < y.digit[i];
        }
    }
    return false;
}

bool operator>(BigInt x, BigInt y) {
    return y < x;
}
bool operator<=(BigInt x, BigInt y) {
    return !(y < x);
}
bool operator>=(BigInt x, BigInt y) {
    return !(x < y);
}
bool operator!=(BigInt x, BigInt y) {
    return x < y || y < x;
}
bool operator==(BigInt x, BigInt y) {
    return !(x < y) && !(y < x);
}

BigInt normal(BigInt x, bool all = false) {
    if (all) {
        x.size = int(x.digit.size()) - 1;
    }
    for (int i = 0; i < x.size; i++) {
        while (x.digit[i] < 0) {
            x.digit[i + 1] -= (-x.digit[i] + BASE - 1) / BASE;
            x.digit[i] = x.digit[i] % BASE + BASE;
        }
        while (x.digit[i] >= BASE) {
            x.digit[i + 1] += x.digit[i] / BASE;
            x.digit[i] = x.digit[i] % BASE;
        }
    }
    while (x.digit[x.size]) {
        x.digit[x.size + 1] = x.digit[x.size] / BASE;
        x.digit[x.size] = x.digit[x.size] % BASE;
        x.size++;
    }
    
    while (x.size > 1 && x.digit[x.size - 1] == 0) {
        x.size--;
    }
    return x;
}

BigInt convert(i64 a) {
    return normal(BigInt(1, a), true);
}

BigInt convert(const string& s) {
    BigInt x;
    x.size = 0;
    int i = s.size() % BASELOG;
    if (i > 0) {
        i -= BASELOG;
    }
    for (; i < int(s.size()); i += BASELOG) {
        i64 a = 0;
        for (int j = 0; j < BASELOG; j++) {
            a = 10 * a + (i + j >= 0 ? s[i + j] - '0' : 0);
        }
        x.digit[x.size++] = a;
    }
    reverse(x.digit.begin(), x.digit.begin() + x.size);
    return normal(x);
}

ostream &operator<<(ostream& os, BigInt x) {
    os << x.digit[x.size - 1];
    for (int i = x.size - 2; i >= 0; i--) {
        os << setw(BASELOG) << setfill('0') << x.digit[i];
    }
    return os;
}

istream &operator>>(istream& is, BigInt &x) {
    string s;
    is >> s;
    x = convert(s);
    return is;
}

string to_string(BigInt &x) {
    stringstream ss;
    ss << x.digit[x.size - 1];
    for (int i = x.size - 2; i >= 0; i--) {
        ss << setw(BASELOG) << setfill('0') << x.digit[i];
    }
    return ss.str();
}

BigInt operator+(BigInt x, BigInt y) {
    if (x.size < y.size) {
        x.size = y.size;
    }
    for (int i = 0; i < y.size; i++) {
        x.digit[i] += y.digit[i];
    }
    return normal(x);
}

BigInt operator-(BigInt x, BigInt y) {
    assert(x >= y);
    for (int i = 0; i < y.size; i++) {
        x.digit[i] -= y.digit[i];
    }
    return normal(x);
}

BigInt operator*(BigInt x, i64 a) {
    for (int i = 0; i < x.size; i++) {
        x.digit[i] *= a;
    }
    return normal(x);
}

void fft(vector<complex<double>>& a, bool inv = false) {
    int n = int(a.size());
    if (n == 1) return;
    vector<complex<double>> even(n / 2), odd(n / 2);
    for (int i = 0; i < n / 2; i++) {
        even[i] = a[2 * i];
        odd[i] = a[2 * i + 1];
    }
    fft(even, inv);
    fft(odd, inv);
    complex<double> omega = polar(1.0, (-2 * inv + 1) * 2 * acos(-1) / n);
    complex<double> pow_omega = 1.0;
    for (int i = 0; i < n / 2; i++) {
        a[i] = even[i] + pow_omega * odd[i];
        a[i + n / 2] = even[i] - pow_omega * odd[i];
        pow_omega *= omega;
    }
}

void conv(vector<complex<double>>& a, vector<complex<double>>& b) {
    fft(a);
    fft(b);
    int n = int(a.size());
    for (int i = 0; i < n; i++) {
        a[i] *= b[i] / complex<double>(n);
    }
    fft(a, true);
}

void conv(vi& a, vi& b) {
    vector<complex<double>> ac, bc;
    for (int i = 0; i < a.size(); i++) {
        ac.push_back(a[i]);
        bc.push_back(b[i]);
    }
    conv(ac, bc);
    a.resize(ac.size());
    for (int i = 0; i < ac.size(); i++) {
        a[i] = long(real(ac[i]) + 0.5);
    }
}

BigInt operator*(BigInt x, BigInt y) {
    conv(x.digit, y.digit);
    return normal(x, true);
}

pair<BigInt, i64> divmod(BigInt x, i64 a) {
    i64 c = 0, t;
    for (int i = x.size - 1; i >= 0; i--) {
        t = BASE * c + x.digit[i];
        x.digit[i] = t / a;
        c = t % a;
    }
    return pair<BigInt, i64>(normal(x), c);
}

BigInt operator/(BigInt x, i64 a) {
    return divmod(x, a).first;
}

i64 operator%(BigInt x, i64 a) {
    return divmod(x, a).second;
}

i64 modpow(i64 a, i64 n, i64 mod) {
    if (n == 0) return 1;
    if (n % 2 == 0) {
        i64 t = modpow(a, n / 2, mod);
        return t * t % mod;
    }
    return a % mod * modpow(a, n - 1, mod) % mod;
}

int main() {
    // assert(freopen("/Users/xuzijian/yukicoder/input3", "r", stdin));
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cout.setf(ios::fixed);
    cout.precision(10);
    int n;
    cin >> n;
    i64 ans = 1;
    for (int i = 0; i < n; i++) {
        i64 c;
        string D;
        cin >> c >> D;
        i64 d = convert(D) % (MOD - 1);
        i64 f = fib(c + 2);
        if (f % MOD == 0) {
            cout << 0 << endl;
            return 0;
        }
        ans *= modpow(fib(c + 2), d, MOD);
        ans %= MOD;
    }
    cout << ans << endl;
}
0