#976379 (C++17) No.2748 Strange Clock

提出ソース
結果

問題	No.2748 Strange Clock
ユーザー	hotman78
提出日時	2024-04-21 14:35:56
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	TLE
実行時間	-
コード長	17,553 bytes
コンパイル時間	2,743 ms
コンパイル使用メモリ	228,124 KB
実行使用メモリ	74,400 KB
最終ジャッジ日時	2024-04-21 14:36:07
合計ジャッジ時間	10,408 ms
ジャッジサーバーID （参考情報）	judge1 / judge4
このコードへのチャレンジ
（要ログイン）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 10,624 KB
testcase_01	AC	2 ms 5,376 KB
testcase_02	AC	1 ms 5,376 KB
testcase_03	AC	2 ms 5,376 KB
testcase_04	AC	2 ms 5,376 KB
testcase_05	AC	2 ms 5,376 KB
testcase_06	AC	1 ms 5,376 KB
testcase_07	AC	1 ms 5,376 KB
testcase_08	AC	1 ms 5,376 KB
testcase_09	AC	2 ms 5,376 KB
testcase_10	AC	3 ms 5,376 KB
testcase_11	AC	2 ms 5,376 KB
testcase_12	AC	5 ms 5,376 KB
testcase_13	AC	5 ms 5,376 KB
testcase_14	AC	11 ms 5,376 KB
testcase_15	AC	11 ms 5,376 KB
testcase_16	AC	31 ms 5,376 KB
testcase_17	AC	33 ms 5,376 KB
testcase_18	AC	102 ms 6,400 KB
testcase_19	AC	106 ms 6,400 KB
testcase_20	AC	351 ms 12,544 KB
testcase_21	AC	353 ms 12,544 KB
testcase_22	AC	1,208 ms 27,520 KB
testcase_23	AC	1,246 ms 27,392 KB
testcase_24	TLE	-
testcase_25	--	-
testcase_26	--	-
testcase_27	--	-
testcase_28	--	-
testcase_29	--	-
testcase_30	--	-
testcase_31	--	-
testcase_32	--	-
testcase_33	--	-
testcase_34	--	-
testcase_35	--	-
testcase_36	--	-
testcase_37	--	-
testcase_38	--	-
権限があれば一括ダウンロードができます
ソースコード

raw source code
// author: hotman78
// date: 2024/04/21-14:35:40

// --- begin raw code -----------------
// #include"cpplib/util/template.hpp"
// // #include"cpplib/graph_tree/dijkstra.hpp"
// #include<atcoder/math.hpp>
// 
// void solve(){
//     lint n,m;
//     cin>>n>>m;
//     
//     auto to_str=[&](lint x,const lint& b){
//         string s;
//         while(x){
//             s+=char('0'+x%b);
//             x/=b;
//         }
//         return s;
//     };
//     auto to_int=[&](string s,const lint& b){
//         lint x=0;
//         rrep(i,s.size()){
//             x=x*b+int(s[i]-'0');
//         }
//         return x;
//     };
//     lint m1=powll(3,n);
//     lint m2=powll(4,n);
//     lint m3=powll(6,n);
//     lint ans=0;
//     map<lint, vector<pair<lint,lint>>>val;
//     rep(i,m1){
//         // cerr<<to_str(i,3)<<" "<<" "<<to_int(to_str(i,3),3)<<i<<endl;
//         // assert(to_int(to_str(i,3),3)==i);
//         // string s=to_str(i,3);
//         lint pre3=i;
//         lint pre4=to_int(to_str(i,3),4)%m2;
//         lint pre6=to_int(to_str(i,3),6)%m3;
//         string str3=to_str(((pre3-m)%m1+m1)%m1,3);
//         string str4=to_str(((pre4-m)%m2+m2)%m2,4);
//         string str6=to_str(((pre6-m)%m3+m3)%m3,6);
//         auto crt=atcoder::crt({pre3,pre4},{m1,m2}).first;
//         val[((crt-pre6)%m3+m3)%m3].emplace_back(crt,(str3!=str4)||(str4!=str6)||(str6!=str3));
//         // assert(atcoder::crt({pre3,pre4},{m1,m2}).second);
//         // cerr<<val.back().first<<" "<<val.back().second<<endl;
//     }
//     // sort(all(val));
//     
//     for(auto [key,val2]:val){
//         sort(all(val2));
//         rep(i,val2.size()){
//             if(i==0){
//                 if(val2[i].first-val2.back().first+powll(12,n)>m){
//                     ans+=val2[i].second;
//                 }
//             }else{
//                 if(val2[i].first-val2[i-1].first>m){
//                     ans+=val2[i].second;
//                 }
//             }
//         }
//     }
//     cout<<ans<<endl;
// }
// 
// int main(){
//     solve();
//     // lint t;cin>>t;while(t--)solve();
// }
// --- end raw code -----------------

#line 2 "cpplib/util/template.hpp"
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
using namespace std;
#line 1 "cpplib/util/ioutil.hpp"
// template <class Head,class... Args>
// std::ostream& output(std::ostream& out,const Head& head,const Args&... args){
//     out>>head;
//     return output(head,args...);
// }
// template <class Head>
// std::ostream& output(std::ostream& out,const Head& head){
//     out>>head;
//     return out;
// }

template <typename T, typename E>
std::ostream &operator<<(std::ostream &out, std::pair<T, E> v) {
    out << "(" << v.first << "," << v.second << ")";
    return out;
}

// template <class... Args>
// ostream& operator<<(ostream& out,std::tuple<Args...>v){
//     std::apply(output,v);
//     return out;
// }
#line 11 "cpplib/util/template.hpp"
struct __INIT__ {
    __INIT__() {
        cin.tie(0);
        ios::sync_with_stdio(false);
        cout << fixed << setprecision(15);
    }
} __INIT__;
typedef long long lint;
constexpr long long INF = 1LL << 60;
constexpr int IINF = 1 << 30;
constexpr double EPS = 1e-10;
#ifndef REACTIVE
#define endl '\n';
#endif
typedef vector<lint> vec;
typedef vector<vector<lint>> mat;
typedef vector<vector<vector<lint>>> mat3;
typedef vector<string> svec;
typedef vector<vector<string>> smat;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
#define output(t)                                                              \
    {                                                                          \
        bool f = 0;                                                            \
        for (auto val : (t)) {                                                 \
            cout << (f ? " " : "") << val;                                     \
            f = 1;                                                             \
        }                                                                      \
        cout << endl;                                                          \
    }
#define output2(t)                                                             \
    {                                                                          \
        for (auto i : t)                                                       \
            output(i);                                                         \
    }
#define debug(t)                                                               \
    {                                                                          \
        bool f = 0;                                                            \
        for (auto i : t) {                                                     \
            cerr << (f ? " " : "") << i;                                       \
            f = 1;                                                             \
        }                                                                      \
        cerr << endl;                                                          \
    }
#define debug2(t)                                                              \
    {                                                                          \
        for (auto i : t)                                                       \
            debug(i);                                                          \
    }
#define loop(n) for (long long _ = 0; _ < (long long)(n); ++_)
#define _overload4(_1, _2, _3, _4, name, ...) name
#define __rep(i, a) repi(i, 0, a, 1)
#define _rep(i, a, b) repi(i, a, b, 1)
#define repi(i, a, b, c)                                                       \
    for (long long i = (long long)(a); i < (long long)(b); i += c)
#define rep(...) _overload4(__VA_ARGS__, repi, _rep, __rep)(__VA_ARGS__)
#define _overload3_rev(_1, _2, _3, name, ...) name
#define _rep_rev(i, a) repi_rev(i, 0, a)
#define repi_rev(i, a, b)                                                      \
    for (long long i = (long long)(b)-1; i >= (long long)(a); --i)
#define rrep(...) _overload3_rev(__VA_ARGS__, repi_rev, _rep_rev)(__VA_ARGS__)

#define all(n) begin(n), end(n)
template <typename T, typename E> bool chmin(T &s, const E &t) {
    bool res = s > t;
    s = min<T>(s, t);
    return res;
}
template <typename T, typename E> bool chmax(T &s, const E &t) {
    bool res = s < t;
    s = max<T>(s, t);
    return res;
}
const vector<lint> dx = {1, 0, -1, 0, 1, 1, -1, -1};
const vector<lint> dy = {0, 1, 0, -1, 1, -1, 1, -1};
#define SUM(v) accumulate(all(v), 0LL)
#if __cplusplus >= 201703L
template <typename T, typename... Args>
auto make_vector(T x, int arg, Args... args) {
    if constexpr (sizeof...(args) == 0)
        return vector<T>(arg, x);
    else
        return vector(arg, make_vector<T>(x, args...));
}
#endif
#define bit(n, a) ((n >> a) & 1)
#define extrep(v, ...) for (auto v : make_mat_impl({__VA_ARGS__}))
vector<vector<long long>> make_mat_impl(vector<long long> v) {
    if (v.empty())
        return vector<vector<long long>>(1, vector<long long>());
    long long n = v.back();
    v.pop_back();
    vector<vector<long long>> ret;
    vector<vector<long long>> tmp = make_mat_impl(v);
    for (auto e : tmp)
        for (long long i = 0; i < n; ++i) {
            ret.push_back(e);
            ret.back().push_back(i);
        }
    return ret;
}
using graph = vector<vector<int>>;
template <typename T> using graph_w = vector<vector<pair<int, T>>>;

#if __cplusplus >= 201703L
constexpr inline long long powll(long long a, long long b) {
    long long res = 1;
    while (b--)
        res *= a;
    return res;
}
#endif

template <typename T, typename E>
pair<T, E> &operator+=(pair<T, E> &s, const pair<T, E> &t) {
    s.first += t.first;
    s.second += t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> &operator-=(pair<T, E> &s, const pair<T, E> &t) {
    s.first -= t.first;
    s.second -= t.second;
    return s;
}
template <typename T, typename E>
pair<T, E> operator+(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res += t;
}
template <typename T, typename E>
pair<T, E> operator-(const pair<T, E> &s, const pair<T, E> &t) {
    auto res = s;
    return res -= t;
}
#define BEGIN_STACK_EXTEND(size)                                               \
    void *stack_extend_memory_ = malloc(size);                                 \
    void *stack_extend_origin_memory_;                                         \
    char *stack_extend_dummy_memory_ = (char *)alloca(                         \
        (1 + (int)(((long long)stack_extend_memory_) & 127)) * 16);            \
    *stack_extend_dummy_memory_ = 0;                                           \
    asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp"                          \
                 : "=b"(stack_extend_origin_memory_)                           \
                 : "a"((char *)stack_extend_memory_ + (size)-1024));
#define END_STACK_EXTEND                                                       \
    asm volatile("mov %%rax, %%rsp" ::"a"(stack_extend_origin_memory_));       \
    free(stack_extend_memory_);
int floor_pow(int n) { return n ? 31 - __builtin_clz(n) : 0; }
#line 2 "main.cpp"
// #include"cpplib/graph_tree/dijkstra.hpp"

#include <algorithm>
#include <cassert>
#include <tuple>
#include <vector>

#include <utility>

#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

constexpr long long safe_mod(long long x, long long m) {
    x %= m;
    if (x < 0)
        x += m;
    return x;
}

struct barrett {
    unsigned int _m;
    unsigned long long im;

    explicit barrett(unsigned int m)
        : _m(m), im((unsigned long long)(-1) / m + 1) {}

    unsigned int umod() const { return _m; }

    unsigned int mul(unsigned int a, unsigned int b) const {

        unsigned long long z = a;
        z *= b;
#ifdef _MSC_VER
        unsigned long long x;
        _umul128(z, im, &x);
#else
        unsigned long long x =
            (unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
        unsigned int v = (unsigned int)(z - x * _m);
        if (_m <= v)
            v += _m;
        return v;
    }
};

constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
    if (m == 1)
        return 0;
    unsigned int _m = (unsigned int)(m);
    unsigned long long r = 1;
    unsigned long long y = safe_mod(x, m);
    while (n) {
        if (n & 1)
            r = (r * y) % _m;
        y = (y * y) % _m;
        n >>= 1;
    }
    return r;
}

constexpr bool is_prime_constexpr(int n) {
    if (n <= 1)
        return false;
    if (n == 2 || n == 7 || n == 61)
        return true;
    if (n % 2 == 0)
        return false;
    long long d = n - 1;
    while (d % 2 == 0)
        d /= 2;
    constexpr long long bases[3] = {2, 7, 61};
    for (long long a : bases) {
        long long t = d;
        long long y = pow_mod_constexpr(a, t, n);
        while (t != n - 1 && y != 1 && y != n - 1) {
            y = y * y % n;
            t <<= 1;
        }
        if (y != n - 1 && t % 2 == 0) {
            return false;
        }
    }
    return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);

constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
    a = safe_mod(a, b);
    if (a == 0)
        return {b, 0};

    long long s = b, t = a;
    long long m0 = 0, m1 = 1;

    while (t) {
        long long u = s / t;
        s -= t * u;
        m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b

        auto tmp = s;
        s = t;
        t = tmp;
        tmp = m0;
        m0 = m1;
        m1 = tmp;
    }
    if (m0 < 0)
        m0 += b / s;
    return {s, m0};
}

constexpr int primitive_root_constexpr(int m) {
    if (m == 2)
        return 1;
    if (m == 167772161)
        return 3;
    if (m == 469762049)
        return 3;
    if (m == 754974721)
        return 11;
    if (m == 998244353)
        return 3;
    int divs[20] = {};
    divs[0] = 2;
    int cnt = 1;
    int x = (m - 1) / 2;
    while (x % 2 == 0)
        x /= 2;
    for (int i = 3; (long long)(i)*i <= x; i += 2) {
        if (x % i == 0) {
            divs[cnt++] = i;
            while (x % i == 0) {
                x /= i;
            }
        }
    }
    if (x > 1) {
        divs[cnt++] = x;
    }
    for (int g = 2;; g++) {
        bool ok = true;
        for (int i = 0; i < cnt; i++) {
            if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
                ok = false;
                break;
            }
        }
        if (ok)
            return g;
    }
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);

unsigned long long floor_sum_unsigned(unsigned long long n,
                                      unsigned long long m,
                                      unsigned long long a,
                                      unsigned long long b) {
    unsigned long long ans = 0;
    while (true) {
        if (a >= m) {
            ans += n * (n - 1) / 2 * (a / m);
            a %= m;
        }
        if (b >= m) {
            ans += n * (b / m);
            b %= m;
        }

        unsigned long long y_max = a * n + b;
        if (y_max < m)
            break;
        n = (unsigned long long)(y_max / m);
        b = (unsigned long long)(y_max % m);
        std::swap(m, a);
    }
    return ans;
}

} // namespace internal

} // namespace atcoder

namespace atcoder {

long long pow_mod(long long x, long long n, int m) {
    assert(0 <= n && 1 <= m);
    if (m == 1)
        return 0;
    internal::barrett bt((unsigned int)(m));
    unsigned int r = 1, y = (unsigned int)(internal::safe_mod(x, m));
    while (n) {
        if (n & 1)
            r = bt.mul(r, y);
        y = bt.mul(y, y);
        n >>= 1;
    }
    return r;
}

long long inv_mod(long long x, long long m) {
    assert(1 <= m);
    auto z = internal::inv_gcd(x, m);
    assert(z.first == 1);
    return z.second;
}

std::pair<long long, long long> crt(const std::vector<long long> &r,
                                    const std::vector<long long> &m) {
    assert(r.size() == m.size());
    int n = int(r.size());
    long long r0 = 0, m0 = 1;
    for (int i = 0; i < n; i++) {
        assert(1 <= m[i]);
        long long r1 = internal::safe_mod(r[i], m[i]), m1 = m[i];
        if (m0 < m1) {
            std::swap(r0, r1);
            std::swap(m0, m1);
        }
        if (m0 % m1 == 0) {
            if (r0 % m1 != r1)
                return {0, 0};
            continue;
        }

        long long g, im;
        std::tie(g, im) = internal::inv_gcd(m0, m1);

        long long u1 = (m1 / g);
        if ((r1 - r0) % g)
            return {0, 0};

        long long x = (r1 - r0) / g % u1 * im % u1;

        r0 += x * m0;
        m0 *= u1; // -> lcm(m0, m1)
        if (r0 < 0)
            r0 += m0;
    }
    return {r0, m0};
}

long long floor_sum(long long n, long long m, long long a, long long b) {
    assert(0 <= n && n < (1LL << 32));
    assert(1 <= m && m < (1LL << 32));
    unsigned long long ans = 0;
    if (a < 0) {
        unsigned long long a2 = internal::safe_mod(a, m);
        ans -= 1ULL * n * (n - 1) / 2 * ((a2 - a) / m);
        a = a2;
    }
    if (b < 0) {
        unsigned long long b2 = internal::safe_mod(b, m);
        ans -= 1ULL * n * ((b2 - b) / m);
        b = b2;
    }
    return ans + internal::floor_sum_unsigned(n, m, a, b);
}

} // namespace atcoder

void solve() {
    lint n, m;
    cin >> n >> m;

    auto to_str = [&](lint x, const lint &b) {
        string s;
        while (x) {
            s += char('0' + x % b);
            x /= b;
        }
        return s;
    };
    auto to_int = [&](string s, const lint &b) {
        lint x = 0;
        rrep(i, s.size()) { x = x * b + int(s[i] - '0'); }
        return x;
    };
    lint m1 = powll(3, n);
    lint m2 = powll(4, n);
    lint m3 = powll(6, n);
    lint ans = 0;
    map<lint, vector<pair<lint, lint>>> val;
    rep(i, m1) {
        // cerr<<to_str(i,3)<<" "<<" "<<to_int(to_str(i,3),3)<<i<<endl;
        // assert(to_int(to_str(i,3),3)==i);
        // string s=to_str(i,3);
        lint pre3 = i;
        lint pre4 = to_int(to_str(i, 3), 4) % m2;
        lint pre6 = to_int(to_str(i, 3), 6) % m3;
        string str3 = to_str(((pre3 - m) % m1 + m1) % m1, 3);
        string str4 = to_str(((pre4 - m) % m2 + m2) % m2, 4);
        string str6 = to_str(((pre6 - m) % m3 + m3) % m3, 6);
        auto crt = atcoder::crt({pre3, pre4}, {m1, m2}).first;
        val[((crt - pre6) % m3 + m3) % m3].emplace_back(
            crt, (str3 != str4) || (str4 != str6) || (str6 != str3));
        // assert(atcoder::crt({pre3,pre4},{m1,m2}).second);
        // cerr<<val.back().first<<" "<<val.back().second<<endl;
    }
    // sort(all(val));

    for (auto [key, val2] : val) {
        sort(all(val2));
        rep(i, val2.size()) {
            if (i == 0) {
                if (val2[i].first - val2.back().first + powll(12, n) > m) {
                    ans += val2[i].second;
                }
            } else {
                if (val2[i].first - val2[i - 1].first > m) {
                    ans += val2[i].second;
                }
            }
        }
    }
    cout << ans << endl;
}

int main() {
    solve();
    // lint t;cin>>t;while(t--)solve();
}
yukicoder

結果

テストケース

ソースコード
