#680557 (C++17) No.1611 Minimum Multiple with Double Divisors

提出ソース

結果

問題	No.1611 Minimum Multiple with Double Divisors
ユーザー	2 n
提出日時	2021-07-21 22:49:09
言語	C++17 (gcc 12.3.0 + boost 1.83.0)
結果	WA
実行時間	-
コード長	8,445 bytes
コンパイル時間	4,139 ms
コンパイル使用メモリ	208,280 KB
実行使用メモリ	6,944 KB
最終ジャッジ日時	2024-07-17 19:53:50
合計ジャッジ時間	8,332 ms
ジャッジサーバーID （参考情報）	judge1 / judge2

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

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	WA	-
testcase_01	WA	-
testcase_02	WA	-
testcase_03	WA	-
testcase_04	WA	-
testcase_05	WA	-
testcase_06	WA	-
testcase_07	WA	-
testcase_08	WA	-
testcase_09	WA	-
testcase_10	AC	43 ms 6,272 KB
testcase_11	AC	48 ms 6,272 KB
testcase_12	AC	50 ms 6,272 KB
testcase_13	AC	48 ms 6,272 KB
testcase_14	AC	48 ms 6,144 KB
testcase_15	AC	49 ms 6,144 KB
testcase_16	AC	49 ms 6,144 KB
testcase_17	AC	49 ms 6,272 KB
testcase_18	AC	50 ms 6,144 KB
testcase_19	AC	9 ms 6,272 KB
testcase_20	AC	8 ms 6,272 KB
testcase_21	AC	8 ms 6,144 KB
testcase_22	AC	8 ms 6,272 KB
testcase_23	AC	8 ms 6,144 KB
testcase_24	AC	8 ms 6,272 KB
testcase_25	AC	8 ms 6,144 KB
testcase_26	AC	8 ms 6,272 KB
testcase_27	AC	8 ms 6,272 KB
testcase_28	AC	7 ms 6,144 KB
testcase_29	AC	7 ms 6,272 KB
testcase_30	AC	8 ms 6,272 KB
testcase_31	AC	7 ms 6,272 KB
testcase_32	AC	7 ms 6,144 KB
testcase_33	AC	8 ms 6,400 KB
testcase_34	AC	8 ms 6,272 KB
testcase_35	AC	7 ms 6,272 KB
testcase_36	AC	7 ms 6,144 KB
testcase_37	AC	8 ms 6,144 KB
testcase_38	AC	7 ms 6,272 KB

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

ソースコード

raw source code

#pragma GCC target("avx2")
//#pragma GCC target("avx")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("O3")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")

// #include<bits/stdc++.h>

// #include <array>
#include <vector>
// #include <list>
// #include <forward_list>
#include <deque>
#include <queue>
#include <stack>

// #include <bitset>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <set>

#include <algorithm>

#include <string>
#include <iostream>
#include <iomanip>
// #include <sstream>

// #include <bit>
// #include <complex>
// #include <exception>
// #include <fstream>
// #include <functional>
// #include <iosfwd>
// #include <iterator>
// #include <limits>
// #include <locale>
// #include <memory>
// #include <new>
// #include <numeric>
// #include <stdexcept>
// #include <typeinfo>
// #include <utility>
// #include <valarray>
// #include <atomic>
// #include <chrono>
// #include <condition_variable>
// #include <future>
// #include <mutex>
// #include <random>
// #include <ratio>
// #include <regex>
// #include <scoped_allocator>
// #include <system_error>
// #include <thread>
// #include <tuple>
// #include <typeindex>
// #include <type_traits>

// #include <cctype>
// #include <cerrno>
// #include <cfloat>
// #include <ciso646>
// #include <climits>
// #include <clocale>
// #include <cmath>
// #include <csetjmp>
// #include <csignal>
// #include <cstdarg>
// #include <cstddef>
// #include <cstdio>
// #include <cstdlib>
// #include <cstring>
#include <ctime>
// #include <ccomplex>
// #include <cfenv>
// #include <cinttypes>
// #include <cstdbool>
// #include <cstdint>
// #include <ctgmath>
// #include <cwchar>
// #include <cwctype>

using namespace std;
#include <atcoder/all>
using namespace atcoder;

#define STRINGIFY(n) #n
#define TOSTRING(n) STRINGIFY(n)

using ll = long long;
using ull = unsigned long long;
template<typename T> using maxque = priority_queue<T>;
template<typename T> using minque = priority_queue<T,vector<T>,greater<T>>;
#define int ll
#define endl "\n"
#define unless(cond) if(!(cond))
#define until(cond) while(!(cond))
#define rep(i,s,e) for(ll i = (s); i < (e); ++i)
#define repR(i,s,e) for(ll i = (e)-1; (s) <= i; --i)
#define repE(i,s,e) for(ll i = (s); i <= (e); ++i)
#define repER(i,s,e) for(ll i = (e); (s) <= i; --i)
#define repSubsetR(set,super) for(ll _super=super,set = _super; 0 <= set; --set)if(set &= _super, true)
#define ALL(xs) begin(xs), end(xs)
#define ALLR(xs) rbegin(xs), rend(xs)
#define ALLC(xs) cbegin(xs), cend(xs)
#define ALLCR(xs) crbegin(xs), crend(xs)
template<typename C> void uniq(C &xs){ xs.erase(unique(ALL(xs)), xs.end()); }
template<typename C> constexpr ll len(C &&xs){ return size(forward<C>(xs)); }
ll BIT(ll n){ return 1LL<<n; }

auto clock0 = clock();
void debug_h(const char *file, signed line, const char *str_args){ cerr << file << ":" << line << ":    " << str_args << "  =>  "; }
template<class X, class... Xs> void debug_(const X &x, const Xs&... xs){ cerr << x; (void)initializer_list<int>{ (cerr << ", " << xs,0)... };cerr << endl; }void debug_(){ cerr << endl; }
#define ASSERT(pred,...) (static_cast<bool>(pred) ? void(0) : (debug_h(__FILE__, __LINE__, "ASSERT FAIL!   " #pred ";   " #__VA_ARGS__),debug_(__VA_ARGS__),exit(1)))
template<class X> X &&dbg_(X &&x){ cerr<<x<<endl; return forward<X>(x); }
#ifdef DEBUG
#define dbg(x) (debug_h(__FILE__, __LINE__, "" #x),dbg_(x))
#define debug(...) (debug_h(__FILE__, __LINE__, "" #__VA_ARGS__),debug_(__VA_ARGS__))
#define clk(...) (cerr << __VA_ARGS__ " @ " << (clock()-clock0) <<endl,(void)0)
#else
#define dbg(x) (x)
#define debug(...) ((void)0)
#define clk(...) ((void)0)
//#define ASSERT(pred,...) ((void)0)
#endif

#define DEF_ORD(op) bool operator op(SELF_ const &b)const { return Ord() op b.Ord(); }
#define ORD(...) auto Ord()const{ return tie(__VA_ARGS__); } typedef auto self_fn_() -> decltype(*this); using SELF_ = decltype(((self_fn_*)nullptr)()); DEF_ORD(==) DEF_ORD(!=) DEF_ORD(<) DEF_ORD(>) DEF_ORD(<=) DEF_ORD(>=)

template<class C> auto operator<<(ostream &out, const C &xs) -> enable_if_t<!is_same_v<decay_t<C>, char*> && !is_same_v<decay_t<C>, string>, decltype(begin(xs),out)&> { out<<"[ "; for(auto&&x:xs)out<<x<<", "; return out<<"]"; }
template<class C> auto operator>>(istream &in, C &xs) -> enable_if_t<!is_same_v<decay_t<C>, char*> && !is_same_v<decay_t<C>, string>, decltype(begin(xs),in)&> { for(auto&x:xs)in>>x; return in; }
template<class Tuple, size_t... I> void print_tuple_(ostream &out, Tuple const &xs, std::index_sequence<I...>){ out << "("; (void)initializer_list<int>{ (out << (I==0?"":", ") << std::get<I>(xs),0)... }; out << ")"; }
template<class... T> ostream &operator<<(ostream &out, tuple<T...> const &xs){ print_tuple_(out, xs, make_index_sequence<sizeof...(T)>()); return out; }
template<class Tuple, size_t... I> void read_tuple_(istream &in, Tuple &xs, std::index_sequence<I...>){ (void)initializer_list<int>{ (in >> std::get<I>(xs),0)... }; }
template<class... T> istream &operator>>(istream &in, tuple<T...> &xs){ read_tuple_(in, xs, make_index_sequence<sizeof...(T)>()); return in; }
template<class S, class T> ostream &operator<<(ostream &out, pair<S, T> const &p){ return out << "(" << p.first << ", " << p.second << ")"; }
template<class S, class T> istream &operator>>(istream &in, pair<S, T> &p){ return in >> p.first >> p.second; }
template<typename MINT, typename = internal::is_modint_t<MINT>> ostream &operator<<(ostream &out, MINT x){ return out << x.val(); }
template<typename MINT, typename = internal::is_modint_t<MINT>> istream &operator>>(istream &in, MINT &x){ ll a; in>>a; x = a; return in; }

template<typename F> struct Fix : F {
    template<typename G> Fix(G &&g) : F{forward<G>(g)} {}
    template<typename... Xs> decltype(auto) operator()(Xs&&... xs)const{ return F::operator()(*this, forward<Xs>(xs)...); }
};
template<typename F> Fix(F&&) -> Fix<decay_t<F>>;

template<typename T,typename U> bool chmin(T &a, U b){ if(a <= b)return false; a = b; return true; }
template<typename T,typename U> bool chmax(T &a, U b){ if(a >= b)return false; a = b; return true; }

//const signed MOD = 998244353;
const signed MOD = 1000000007; // 10^9+7
using mint = static_modint<MOD>;
// using mint = dynamic_modint<-1>; // mint::set_mod(mod);
// using mint0 = dynamic_modint<0>; // mint0::set_mod(mod);

const ll INF = BIT(60);



ll solve(){
    vector<signed> primes;
    map<signed,signed> p2i;
    vector<signed> lpf(316230, -1);
    rep(d, 2, len(lpf)){
        if(lpf[d] == -1){
            lpf[d] = d;
            p2i[d] = len(primes);
            primes.push_back(d);
        }
        for(auto p : primes){
            unless(p <= lpf[d] && p * d < len(lpf)) break;
            lpf[p * d] = p;
        }
    }
    auto maxp = primes[5];
    map<map<ll,ll>, signed> memo;
    auto ans = [&](map<ll,ll> nu){
        auto it = memo.find(nu);
        unless(it == memo.end()) return it->second;
        for(ll i=2;;++i){
            ll j = i;
            ll prod = 1,div = 1;
            auto nu2 = nu;
            until(j <= 1){
                ll p = lpf[j];
                div *= nu2[p]+1;
                j /= p; ++nu2[p];
                prod *= nu2[p]+1;
            }
            if(prod == 2 * div) return memo[nu] = (signed)i;
        }
    };
    ll t;cin>>t;
    ll maxm = 32;
    map<ll,ll> p2maxc;p2maxc[2]=5;p2maxc[3]=3;
    rep(i,0,t){
        ll xx;cin>>xx;ll x=xx;
        debug(x);
        map<ll,ll> nu;
        auto check = [&](ll p, ll maxc){
            unless(x % p == 0) return false;
            do{
                x /= p;
                if(++nu[p]==maxc) break;
            }while(x % p == 0);
            return true;
        };
        for(auto p : primes){
            unless(p <= maxm) break;
            ll maxc = 2*p <= maxm ? 2 : 1;
            auto it = p2maxc.find(p); if(it != p2maxc.end()) maxc = it->second;
            unless(check(p, maxc)) break;
        }
        cout << xx*ans(nu) << endl;
    }
    exit(0);
}

signed main(){
    cin.tie(nullptr);ios_base::sync_with_stdio(false);
    cout << fixed << setprecision(15);
    try{
        cout << solve() << endl;/*
        cout << (solve()?"Yes":"No") << endl; // */
        return 0;
    }catch(exception& e){
        cerr << e.what() << endl;
    }catch(char *s){
        cerr << s << endl;
    }
    return 1;
}

yukicoder

結果

テストケース

ソースコード