#408032 (C++17) No.950 行列累乗

提出ソース

結果

問題	No.950 行列累乗
ユーザー	Pachicobue
提出日時	2019-12-13 02:08:18
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	WA
実行時間	-
コード長	15,055 bytes
コンパイル時間	3,105 ms
コンパイル使用メモリ	241,996 KB
実行使用メモリ	7,660 KB
最終ジャッジ日時	2023-09-08 10:47:24
合計ジャッジ時間	9,125 ms
ジャッジサーバーID （参考情報）	judge13 / judge15

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	WA	-
testcase_01	AC	2 ms 4,376 KB
testcase_02	AC	2 ms 4,376 KB
testcase_03	AC	2 ms 4,380 KB
testcase_04	AC	2 ms 4,376 KB
testcase_05	AC	2 ms 4,376 KB
testcase_06	AC	15 ms 4,380 KB
testcase_07	AC	2 ms 4,380 KB
testcase_08	WA	-
testcase_09	AC	4 ms 4,380 KB
testcase_10	WA	-
testcase_11	AC	1 ms 4,380 KB
testcase_12	AC	2 ms 4,376 KB
testcase_13	AC	2 ms 4,380 KB
testcase_14	WA	-
testcase_15	AC	2 ms 4,376 KB
testcase_16	WA	-
testcase_17	WA	-
testcase_18	AC	1 ms 4,376 KB
testcase_19	WA	-
testcase_20	WA	-
testcase_21	RE	-
testcase_22	RE	-
testcase_23	AC	16 ms 4,380 KB
testcase_24	RE	-
testcase_25	WA	-
testcase_26	AC	15 ms 4,376 KB
testcase_27	AC	6 ms 4,380 KB
testcase_28	RE	-
testcase_29	RE	-
testcase_30	RE	-
testcase_31	AC	160 ms 5,764 KB
testcase_32	AC	241 ms 7,296 KB
testcase_33	AC	183 ms 6,112 KB
testcase_34	WA	-
testcase_35	WA	-
testcase_36	AC	2 ms 4,376 KB
testcase_37	WA	-
testcase_38	WA	-
testcase_39	AC	1 ms 4,380 KB
testcase_40	WA	-
testcase_41	AC	15 ms 4,376 KB
testcase_42	RE	-
testcase_43	RE	-
testcase_44	RE	-
testcase_45	RE	-
testcase_46	RE	-
testcase_47	WA	-
testcase_48	RE	-
testcase_49	RE	-
testcase_50	WA	-
testcase_51	WA	-
testcase_52	WA	-
testcase_53	WA	-
testcase_54	WA	-
testcase_55	AC	1 ms 4,380 KB
testcase_56	WA	-
testcase_57	AC	2 ms 4,376 KB
testcase_58	AC	2 ms 4,380 KB
testcase_59	AC	1 ms 4,380 KB
testcase_60	AC	2 ms 4,376 KB

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

ソースコード

raw source code

#include <bits/stdc++.h>
// created [2019/12/12] 23:52:05
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wsign-conversion"

using i32   = int32_t;
using i64   = int64_t;
using u32   = uint32_t;
using u64   = uint64_t;
using uint  = unsigned int;
using usize = std::size_t;
using ll    = long long;
using ull   = unsigned long long;
using ld    = long double;
template<typename T, usize n>
using arr = T (&)[n];
template<typename T, usize n>
using c_arr = const T (&)[n];
template<typename T> constexpr T popcount(const T u) { return u ? static_cast<T>(__builtin_popcountll(static_cast<u64>(u))) : static_cast<T>(0); }
template<typename T> constexpr T log2p1(const T u) { return u ? static_cast<T>(64 - __builtin_clzll(static_cast<u64>(u))) : static_cast<T>(0); }
template<typename T> constexpr T msbp1(const T u) { return log2p1(u); }
template<typename T> constexpr T lsbp1(const T u) { return __builtin_ffsll(u); }
template<typename T> constexpr T clog(const T u) { return u ? log2p1(u - 1) : static_cast<T>(u); }
template<typename T> constexpr bool ispow2(const T u) { return u and (static_cast<u64>(u) & static_cast<u64>(u - 1)) == 0; }
template<typename T> constexpr T ceil2(const T u) { return static_cast<T>(1) << clog(u); }
template<typename T> constexpr T floor2(const T u) { return u == 0 ? static_cast<T>(0) : static_cast<T>(1) << (log2p1(u) - 1); }
template<typename T> constexpr bool btest(const T mask, const usize ind) { return static_cast<bool>((static_cast<u64>(mask) >> ind) & static_cast<u64>(1)); }
template<typename T> void bset(T& mask, const usize ind) { mask |= (static_cast<T>(1) << ind); }
template<typename T> void breset(T& mask, const usize ind) { mask &= ~(static_cast<T>(1) << ind); }
template<typename T> void bflip(T& mask, const usize ind) { mask ^= (static_cast<T>(1) << ind); }
template<typename T> void bset(T& mask, const usize ind, const bool b) { (b ? bset(mask, ind) : breset(mask, ind)); }
template<typename T> constexpr T bcut(const T mask, const usize ind) { return ind == 0 ? static_cast<T>(0) : static_cast<T>((static_cast<u64>(mask) << (64 - ind)) >> (64 - ind)); }
template<typename T> bool chmin(T& a, const T& b) { return (a > b ? a = b, true : false); }
template<typename T> bool chmax(T& a, const T& b) { return (a < b ? a = b, true : false); }
constexpr unsigned int mod                  = 1000000007;
template<typename T> constexpr T inf_v      = std::numeric_limits<T>::max() / 4;
template<typename Real> constexpr Real pi_v = Real{3.141592653589793238462643383279502884};

template<typename T>
T in()
{
    T v;
    return std::cin >> v, v;
}
template<typename T, typename Uint, usize n, usize i>
T in_v(typename std::enable_if<(i == n), c_arr<Uint, n>>::type) { return in<T>(); }
template<typename T, typename Uint, usize n, usize i>
auto in_v(typename std::enable_if<(i < n), c_arr<Uint, n>>::type& szs)
{
    const usize s = (usize)szs[i];
    std::vector<decltype(in_v<T, Uint, n, i + 1>(szs))> ans(s);
    for (usize j = 0; j < s; j++) { ans[j] = in_v<T, Uint, n, i + 1>(szs); }
    return ans;
}
template<typename T, typename Uint, usize n>
auto in_v(c_arr<Uint, n> szs) { return in_v<T, Uint, n, 0>(szs); }
template<typename... Types>
auto in_t() { return std::tuple<std::decay_t<Types>...>{in<Types>()...}; }
struct io_init
{
    io_init()
    {
        std::cin.tie(nullptr), std::ios::sync_with_stdio(false);
        std::cout << std::fixed << std::setprecision(20);
    }
} hogechan;
template<typename T>
void out(const T& v) { std::cout << v << '\n'; }  // Reactiveではstd::flushを忘れない
template<typename T, typename... Args>
void out(const T& v, const Args... args) { std::cout << v << ' ', out(args...); }
#    define SHOW(...) static_cast<void>(0)
constexpr ull TEN(const usize n) { return n == 0 ? 1ULL : TEN(n - 1) * 10ULL; }

template<typename T, typename Uint, usize n, usize i>
auto make_v(typename std::enable_if<(i == n), c_arr<Uint, n>>::type, const T& v = T{}) { return v; }
template<typename T, typename Uint, usize n, usize i>
auto make_v(typename std::enable_if<(i < n), c_arr<Uint, n>>::type szs, const T& v = T{})
{
    const usize s = (usize)szs[i];
    return std::vector<decltype(make_v<T, Uint, n, i + 1>(szs, v))>(s, make_v<T, Uint, n, i + 1>(szs, v));
}
template<typename T, typename Uint, usize n>
auto make_v(c_arr<Uint, n> szs, const T& t = T{}) { return make_v<T, Uint, n, 0>(szs, t); }


template<typename T> T gcd(const T& a, const T& b) { return a < 0 ? gcd(-a, b) : b < 0 ? gcd(a, -b) : (a > b ? gcd(b, a) : a == 0 ? b : gcd(b % a, a)); }
template<typename T> T lcm(const T& a, const T& b) { return a / gcd(a, b) * b; }
template<typename T>
constexpr std::pair<T, T> extgcd(const T a, const T b)
{
    if (b == 0) { return std::pair<T, T>{1, 0}; }
    const auto g = gcd(a, b), da = std::abs(b) / g;
    const auto p = extgcd(b, a % b);
    const auto x = (da + p.second % da) % da, y = (g - a * x) / b;
    return {x, y};
}
template<typename T>
constexpr T inverse(const T a, const T mod) { return extgcd(a, mod).first; }
template<uint mod_value, bool dynamic = false>
class modint_base
{
public:
    template<typename UInt = uint>
    static std::enable_if_t<dynamic, const UInt> mod() { return mod_ref(); }
    template<typename UInt = uint>
    static constexpr std::enable_if_t<not dynamic, const UInt> mod() { return mod_value; }
    template<typename UInt = uint>
    static void set_mod(const std::enable_if_t<dynamic, const UInt> mod) { mod_ref() = mod, inv_ref() = {1, 1}; }
    modint_base() : v{0} {}
    modint_base(const ll val) : v{norm(static_cast<uint>(val % static_cast<ll>(mod()) + static_cast<ll>(mod())))} {}
    modint_base(const modint_base& n) : v{n()} {}
    explicit operator bool() const { return v != 0; }
    bool operator!() const { return not static_cast<bool>(*this); }
    modint_base& operator=(const modint_base& m) { return v = m(), (*this); }
    modint_base& operator=(const ll val) { return v = norm(uint(val % static_cast<ll>(mod()) + static_cast<ll>(mod()))), (*this); }
    friend modint_base operator+(const modint_base& m) { return m; }
    friend modint_base operator-(const modint_base& m) { return make(norm(mod() - m.v)); }
    friend modint_base operator+(const modint_base& m1, const modint_base& m2) { return make(norm(m1.v + m2.v)); }
    friend modint_base operator-(const modint_base& m1, const modint_base& m2) { return make(norm(m1.v + mod() - m2.v)); }
    friend modint_base operator*(const modint_base& m1, const modint_base& m2) { return make(static_cast<uint>(static_cast<ll>(m1.v) * static_cast<ll>(m2.v) % static_cast<ll>(mod()))); }
    friend modint_base operator/(const modint_base& m1, const modint_base& m2) { return m1 * inv(m2.v); }
    friend modint_base operator+(const modint_base& m, const ll val) { return modint_base{static_cast<ll>(m.v) + val}; }
    friend modint_base operator-(const modint_base& m, const ll val) { return modint_base{static_cast<ll>(m.v) - val}; }
    friend modint_base operator*(const modint_base& m, const ll val) { return modint_base{static_cast<ll>(m.v) * (val % static_cast<ll>(mod()))}; }
    friend modint_base operator/(const modint_base& m, const ll val) { return modint_base{static_cast<ll>(m.v) * inv(val)}; }
    friend modint_base operator+(const ll val, const modint_base& m) { return modint_base{static_cast<ll>(m.v) + val}; }
    friend modint_base operator-(const ll val, const modint_base& m) { return modint_base{-static_cast<ll>(m.v) + val}; }
    friend modint_base operator*(const ll val, const modint_base& m) { return modint_base{static_cast<ll>(m.v) * (val % static_cast<ll>(mod()))}; }
    friend modint_base operator/(const ll val, const modint_base& m) { return modint_base{val * inv(static_cast<ll>(m.v))}; }
    friend modint_base& operator+=(modint_base& m1, const modint_base& m2) { return m1 = m1 + m2; }
    friend modint_base& operator-=(modint_base& m1, const modint_base& m2) { return m1 = m1 - m2; }
    friend modint_base& operator*=(modint_base& m1, const modint_base& m2) { return m1 = m1 * m2; }
    friend modint_base& operator/=(modint_base& m1, const modint_base& m2) { return m1 = m1 / m2; }
    friend modint_base& operator+=(modint_base& m, const ll val) { return m = m + val; }
    friend modint_base& operator-=(modint_base& m, const ll val) { return m = m - val; }
    friend modint_base& operator*=(modint_base& m, const ll val) { return m = m * val; }
    friend modint_base& operator/=(modint_base& m, const ll val) { return m = m / val; }
    friend modint_base operator^(const modint_base& m, const ll n) { return power(m.v, n); }
    friend modint_base& operator^=(modint_base& m, const ll n) { return m = m ^ n; }
    friend bool operator==(const modint_base& m1, const modint_base& m2) { return m1.v == m2.v; }
    friend bool operator!=(const modint_base& m1, const modint_base& m2) { return not(m1 == m2); }
    friend bool operator==(const modint_base& m, const ll val) { return m.v == norm(static_cast<uint>(static_cast<ll>(mod()) + val % static_cast<ll>(mod()))); }
    friend bool operator!=(const modint_base& m, const ll val) { return not(m == val); }
    friend bool operator==(const ll val, const modint_base& m) { return m.v == norm(static_cast<uint>(static_cast<ll>(mod()) + val % static_cast<ll>(mod()))); }
    friend bool operator!=(const ll val, const modint_base& m) { return not(m == val); }
    friend std::istream& operator>>(std::istream& is, modint_base& m)
    {
        ll v;
        return is >> v, m = v, is;
    }
    friend std::ostream& operator<<(std::ostream& os, const modint_base& m) { return os << m(); }
    uint operator()() const { return v; }
    static modint_base small_inv(const usize n)
    {
        auto& in = inv_ref();
        if (n < in.size()) { return in[n]; }
        for (usize i = in.size(); i <= n; i++) { in.push_back(-in[modint_base::mod() % i] * (modint_base::mod() / i)); }
        return in.back();
    }

private:
    template<typename UInt = uint>
    static std::enable_if_t<dynamic, UInt&> mod_ref()
    {
        static UInt mod = 0;
        return mod;
    }
    static uint norm(const uint x) { return x < mod() ? x : x - mod(); }
    static modint_base make(const uint x)
    {
        modint_base m;
        return m.v = x, m;
    }
    static modint_base power(modint_base x, ull n)
    {
        modint_base ans = 1;
        for (; n; n >>= 1, x *= x) {
            if (n & 1) { ans *= x; }
        }
        return ans;
    }
    static modint_base inv(const ll v) { return v < 1000000 ? small_inv(static_cast<usize>(v)) : modint_base{inverse(v, static_cast<ll>(mod()))}; }
    static std::vector<modint_base>& inv_ref()
    {
        static std::vector<modint_base> in{1, 1};
        return in;
    }
    uint v;
};
template<uint mod>
using modint = modint_base<mod, false>;
template<uint id>
using dynamic_modint = modint_base<id, true>;
template<typename T>
std::vector<T> divisors(const T n)
{
    std::vector<T> head, tail;
    for (T i = 1; i * i <= n; i++) {
        if (n % i == 0) {
            head.push_back(i);
            if (i * i != n) { tail.push_back(n / i); }
        }
    }
    for (auto it = tail.rbegin(); it != tail.rend(); it++) { head.push_back(*it); }
    return head;
}
using mint = dynamic_modint<0>;
bool operator<(const mint& m1, const mint& m2) { return m1() < m2(); }
int main()
{
    const uint p = in<uint>();
    mint::set_mod(p);
    const auto as = in_v<mint>({4});
    const auto bs = in_v<mint>({4});
    if (as == bs) { return std::cout << 1 << std::endl, 0; }
    using mat = std::array<std::array<mint, 2>, 2>;
    auto mul  = [&](const mat& m1, const mat& m2) {
        mat ans{{{0, 0}, {0, 0}}};
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 2; k++) {
                    ans[i][j] += m1[i][k] * m2[k][j];
                }
            }
        }
        return ans;
    };
    auto pow = [&](auto&& self, const mat& m, const ll k) {
        if (k == 0) { return mat{{{1, 0}, {0, 1}}}; }
        if (k % 2 == 0) {
            return self(self, mul(m, m), k / 2);
        } else {
            return mul(self(self, m, k - 1), m);
        }
    };
    const auto I = mat{{{1, 0}, {0, 1}}};
    auto tr      = [&](const mat& m) { return m[0][0] + m[1][1]; };
    auto det     = [&](const mat& m) { return m[0][0] * m[1][1] - m[0][1] * m[1][0]; };
    auto inv     = [&](const mat& m) {
        const mint d  = det(m);
        const mat ans = {{{m[1][1] / d, -m[0][1] / d}, {-m[1][0] / d, m[0][0] / d}}};
        assert(mul(ans, m) == I);
        return ans;
    };
    mat A{{{as[0], as[1]}, {as[2], as[3]}}};
    mat B{{{bs[0], bs[1]}, {bs[2], bs[3]}}};
    if (det(A) == 0) {
        if (det(B) != 0) { return std::cout << -1 << std::endl, 0; }
        const auto at = tr(A);
        const auto bt = tr(B);
        mint n        = bt / at;
        const ll k    = (n() == 0 ? p : n());
        std::cout << (pow(pow, A, k) == B ? k : -1LL) << std::endl;
        return 0;
    }
    if (det(B) == 0) { return std::cout << -1 << std::endl, 0; }
    const auto ad = det(A);
    const auto bd = det(B);
    SHOW(ad, bd);
    const auto adinv = mint(1) / ad;
    auto ds          = divisors(p - 1);
    ll period        = 0;
    for (const ll d : ds) {
        if ((ad ^ d) == 1) {
            period = d;
            break;
        }
    }
    const ll BS = 50000;
    std::map<uint, ll> giant;
    for (ll i = 0; i * BS < period; i++) {
        const mint p = ad ^ (i * BS);
        if (giant.count(p()) == 0) { giant[p()] = BS * i; }
    }
    auto lg = [&](mint x) {
        for (ll i = 0; i < BS; i++) {
            if (giant.count(x())) { return giant[x()] + i; }
            x *= adinv;
        }
        return 0LL;
    };
    const ll n      = lg(bd);
    const auto C    = pow(pow, A, p - 1);
    const auto D    = pow(pow, A, n);
    const auto CINV = inv(C);
    const auto DINV = inv(D);
    B               = mul(B, DINV);
    SHOW(B, C, D);
    std::set<ll> ds2;
    for (const ll d : divisors(p - 1)) { ds2.insert(d); }
    for (const ll d : divisors(p)) { ds2.insert(d); }
    for (const ll d : divisors(p)) { ds2.insert(d); }
    ll p2 = (p - 1) * (p + 1);
    for (const ll d : ds2) {
        if (pow(pow, C, d) == I) {
            p2 = d;
            break;
        }
    }
    SHOW(p2);
    assert(pow(pow, C, p2) == I);
    ll BS2 = 1;
    for (; BS2 * BS2 < p2; BS2++) {}
    std::map<mat, ll> giant2;
    for (ll i = 0; i * BS2 < p2; i++) {
        giant2[pow(pow, C, i * BS2)] = i * BS2;
    }
    auto lg2 = [&](mat B) {
        for (ll i = 0; i < BS2; i++) {
            if (giant2.count(B)) {
                const ll q = giant2[B] + i;
                if (q == 0 and n == 0) { return p2 * (p - 1); }
                return q * (p - 1) + n;
            }
            B = mul(B, CINV);
        }
        return inf_v<ll>;
    };
    const ll ans = lg2(B);
    SHOW(ans);
    std::cout << (ans == inf_v<ll> ? -1LL : ans) << std::endl;
    return 0;
}

yukicoder

結果

テストケース

ソースコード