結果
| 問題 | No.2589 Prepare Integers |
| ユーザー |
👑  Nachia
|
| 提出日時 | 2023-12-17 16:32:06 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 14,661 bytes |
| コンパイル時間 | 1,713 ms |
| コンパイル使用メモリ | 132,316 KB |
| 実行使用メモリ | 6,948 KB |
| 最終ジャッジ日時 | 2024-09-27 08:01:28 |
| 合計ジャッジ時間 | 3,180 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
6,812 KB |
| testcase_01 | AC | 2 ms
6,940 KB |
| testcase_02 | AC | 2 ms
6,944 KB |
| testcase_03 | WA | - |
| testcase_04 | AC | 129 ms
6,940 KB |
| testcase_05 | AC | 64 ms
6,940 KB |
| testcase_06 | AC | 38 ms
6,940 KB |
| testcase_07 | AC | 31 ms
6,944 KB |
| testcase_08 | AC | 11 ms
6,940 KB |
| testcase_09 | AC | 7 ms
6,944 KB |
| testcase_10 | AC | 8 ms
6,944 KB |
| testcase_11 | AC | 9 ms
6,940 KB |
| testcase_12 | WA | - |
| testcase_13 | WA | - |
| testcase_14 | WA | - |
| testcase_15 | WA | - |
| testcase_16 | WA | - |
| testcase_17 | WA | - |
| testcase_18 | WA | - |
| testcase_19 | AC | 9 ms
6,940 KB |
| testcase_20 | AC | 8 ms
6,940 KB |
| testcase_21 | WA | - |
| testcase_22 | WA | - |
| testcase_23 | WA | - |
| testcase_24 | WA | - |
| testcase_25 | WA | - |
| testcase_26 | AC | 8 ms
6,944 KB |
| testcase_27 | WA | - |
ソースコード
#ifdef NACHIA
// #define _GLIBCXX_DEBUG
#else
#define NDEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <array>
#include <cmath>
#include <atcoder/modint>
using namespace std;
using i64 = long long;
using u64 = unsigned long long;
#define rep(i,n) for(i64 i=0; i<(i64)(n); i++)
#define repr(i,n) for(i64 i=(i64)(n)-1; i>=0; i--)
const i64 INF = 1001001001001001001;
const char* yn(bool x){ return x ? "Yes" : "No"; }
template<typename A> void chmin(A& l, const A& r){ if(r < l) l = r; }
template<typename A> void chmax(A& l, const A& r){ if(l < r) l = r; }
template<typename A> using nega_queue = priority_queue<A,vector<A>,greater<A>>;
using Modint = atcoder::static_modint<998244353>;
#include <iterator>
#include <functional>
template<class Elem> struct vec;
template<class Iter>
struct seq_view{
using Ref = typename std::iterator_traits<Iter>::reference;
using Elem = typename std::iterator_traits<Iter>::value_type;
Iter a, b;
Iter begin() const { return a; }
Iter end() const { return b; }
int size() const { return (int)(b-a); }
seq_view(Iter first, Iter last) : a(first), b(last) {}
seq_view sort() const { std::sort(a, b); return *this; }
Ref& operator[](int x){ return *(a+x); }
template<class F = std::less<Elem>, class ret = vec<int>> ret sorti(F f = F()) const {
ret x(size()); for(int i=0; i<size(); i++) x[i] = i;
x().sort([&](int l, int r){ return f(a[l],a[r]); });
return x;
}
template<class ret = vec<Elem>> ret col() const { return ret(begin(), end()); }
template<class F = std::equal_to<Elem>, class ret = vec<std::pair<Elem, int>>>
ret rle(F eq = F()) const {
auto x = ret();
for(auto& a : (*this)){
if(x.size() == 0 || !eq(x[x.size()-1].first, a)) x.emp(a, 1); else x[x.size()-1].second++;
} return x;
}
template<class F> seq_view sort(F f) const { std::sort(a, b, f); return *this; }
Iter uni() const { return std::unique(a, b); }
Iter lb(const Elem& x) const { return std::lower_bound(a, b, x); }
Iter ub(const Elem& x) const { return std::upper_bound(a, b, x); }
int lbi(const Elem& x) const { return lb(x) - a; }
int ubi(const Elem& x) const { return ub(x) - a; }
seq_view bound(const Elem& l, const Elem& r) const { return { lb(l), lb(r) }; }
template<class F> Iter lb(const Elem& x, F f) const { return std::lower_bound(a, b, x, f); }
template<class F> Iter ub(const Elem& x, F f) const { return std::upper_bound(a, b, x, f); }
template<class F> Iter when_true_to_false(F f) const {
if(a == b) return a;
return std::lower_bound(a, b, *a,
[&](const Elem& x, const Elem&){ return f(x); });
}
seq_view same(Elem x) const { return { lb(x), ub(x) }; }
template<class F> auto map(F f) const {
vec<typename Iter::value_type> r;
for(auto& x : *this) r.emp(f(x));
return r;
}
Iter max() const { return std::max_element(a, b); }
Iter min() const { return std::min_element(a, b); }
template<class F = std::less<Elem>>
Iter min(F f) const { return std::min_element(a, b, f); }
seq_view rev() const { std::reverse(a, b); return *this; }
};
template<class Elem>
struct vec {
using Base = typename std::vector<Elem>;
using Iter = typename Base::iterator;
using CIter = typename Base::const_iterator;
using View = seq_view<Iter>;
using CView = seq_view<CIter>;
vec(){}
explicit vec(int n, const Elem& value = Elem()) : a(0<n?n:0, value) {}
template <class I2> vec(I2 first, I2 last) : a(first, last) {}
vec(std::initializer_list<Elem> il) : a(std::move(il)) {}
vec(Base b) : a(std::move(b)) {}
operator Base() const { return a; }
Iter begin(){ return a.begin(); }
CIter begin() const { return a.begin(); }
Iter end(){ return a.end(); }
CIter end() const { return a.end(); }
int size() const { return a.size(); }
bool empty() const { return a.empty(); }
Elem& back(){ return a.back(); }
const Elem& back() const { return a.back(); }
vec sortunied(){ vec x = *this; x().sort(); x.a.erase(x().uni(), x.end()); return x; }
Iter operator()(int x){ return a.begin() + x; }
CIter operator()(int x) const { return a.begin() + x; }
View operator()(int l, int r){ return { (*this)(l), (*this)(r) }; }
CView operator()(int l, int r) const { return { (*this)(l), (*this)(r) }; }
View operator()(){ return (*this)(0,size()); }
CView operator()() const { return (*this)(0,size()); }
Elem& operator[](int x){ return a[x]; }
const Elem& operator[](int x) const { return a[x]; }
Base& operator*(){ return a; }
const Base& operator*() const { return a; }
vec& push(Elem args){
a.push_back(std::move(args));
return *this;
}
template<class... Args>
vec& emp(Args &&... args){
a.emplace_back(std::forward<Args>(args) ...);
return *this;
}
template<class Range>
vec& app(Range& x){ for(auto& v : a) emp(v); }
Elem pop(){
Elem x = std::move(a.back());
a.pop_back(); return x;
}
bool operator==(const vec& r) const { return a == r.a; }
bool operator!=(const vec& r) const { return a != r.a; }
bool operator<(const vec& r) const { return a < r.a; }
bool operator<=(const vec& r) const { return a <= r.a; }
bool operator>(const vec& r) const { return a > r.a; }
bool operator>=(const vec& r) const { return a >= r.a; }
vec<vec<Elem>> pile(int n) const { return vec<vec<Elem>>(n, *this); }
template<class F> vec& filter(F f){
int p = 0;
for(int q=0; q<size(); q++) if(f(a[q])) std::swap(a[p++],a[q]);
a.resize(p); return *this;
}
private: Base a;
};
template<class IStr, class U, class T>
IStr& operator>>(IStr& is, vec<std::pair<U,T>>& v){ for(auto& x:v){ is >> x.first >> x.second; } return is; }
template<class IStr, class T>
IStr& operator>>(IStr& is, vec<T>& v){ for(auto& x:v){ is >> x; } return is; }
template<class OStr, class T>
OStr& operator<<(OStr& os, const vec<T>& v){
for(int i=0; i<v.size(); i++){
if(i){ os << ' '; } os << v[i];
} return os;
}
#include <cassert>
namespace nachia{
// ax + by = gcd(a,b)
// return ( x, - )
std::pair<long long, long long> ExtGcd(long long a, long long b){
long long x = 1, y = 0;
while(b){
long long u = a / b;
std::swap(a-=b*u, b);
std::swap(x-=y*u, y);
}
return std::make_pair(x, a);
}
} // namespace nachia
#include <unordered_map>
#include <cstdint>
namespace nachia{
class Xoshiro256pp{
public:
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
private:
uint64_t s[4];
// https://prng.di.unimi.it/xoshiro256plusplus.c
static inline uint64_t rotl(const uint64_t x, int k) noexcept {
return (x << k) | (x >> (64 - k));
}
inline uint64_t gen(void) noexcept {
const uint64_t result = rotl(s[0] + s[3], 23) + s[0];
const uint64_t t = s[1] << 17;
s[2] ^= s[0];
s[3] ^= s[1];
s[1] ^= s[2];
s[0] ^= s[3];
s[2] ^= t;
s[3] = rotl(s[3], 45);
return result;
}
// https://xoshiro.di.unimi.it/splitmix64.c
u64 splitmix64(u64& x) {
u64 z = (x += 0x9e3779b97f4a7c15);
z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
return z ^ (z >> 31);
}
public:
void seed(u64 x = 7001){
assert(x != 0);
s[0] = x;
for(int i=1; i<4; i++) s[i] = splitmix64(x);
}
Xoshiro256pp(){ seed(); }
u64 rng64() { return gen(); }
u64 operator()(){ return gen(); }
// generate x : l <= x <= r
u64 random_unsigned(u64 l,u64 r){
assert(l<=r);
r-=l;
auto res = rng64();
if(res<=r) return res+l;
u64 d = r+1;
u64 max_valid = 0xffffffffffffffff/d*d;
while(true){
auto res = rng64();
if(res<=max_valid) break;
}
return res%d+l;
}
// generate x : l <= x <= r
i64 random_signed(i64 l,i64 r){
assert(l<=r);
u64 unsigned_l = (u64)l ^ (1ull<<63);
u64 unsigned_r = (u64)r ^ (1ull<<63);
u64 unsigned_res = random_unsigned(unsigned_l,unsigned_r) ^ (1ull<<63);
return (i64)unsigned_res;
}
// permute x : n_left <= x <= n_right
// output r from the front
template<class Int>
std::vector<Int> random_nPr(Int n_left, Int n_right, Int r){
Int n = n_right-n_left;
assert(n>=0);
assert(r<=(1ll<<27));
if(r==0) return {};
assert(n>=r-1);
std::vector<Int> V;
std::unordered_map<Int,Int> G;
for(int i=0; i<r; i++){
Int p = random_signed(i,n);
Int x = p - G[p];
V.push_back(x);
G[p] = p - (i - G[i]);
}
for(Int& v : V) v+=n_left;
return V;
}
// V[i] := V[perm[i]]
// using swap
template<class E,class PermInt_t>
void permute_inplace(std::vector<E>& V,std::vector<PermInt_t> perm){
assert(V.size() == perm.size());
int N=V.size();
for(int i=0; i<N; i++){
int p=i;
while(perm[p]!=i){
assert(0 <= perm[p] && perm[p] < N);
assert(perm[p] != perm[perm[p]]);
std::swap(V[p],V[perm[p]]);
int pbuf = perm[p]; perm[p] = p; p = pbuf;
}
perm[p] = p;
}
}
template<class E>
std::vector<E> shuffle(const std::vector<E>& V){
int N=V.size();
auto P = random_nPr(0,N-1,N);
std::vector<E> res;
res.reserve(N);
for(int i=0; i<N; i++) res.push_back(V[P[i]]);
return res;
}
// shuffle using swap
template<class E>
void shuffle_inplace(std::vector<E>& V){
int N=V.size();
permute_inplace(V,random_nPr(0,N-1,N));
}
};
} // namespace nachia
#include <random>
#include <chrono>
nachia::Xoshiro256pp rng;
namespace RngInitInstance { struct RngInit { RngInit(){
unsigned long long seed1 = std::random_device()();
unsigned long long seed2 = std::chrono::high_resolution_clock::now().time_since_epoch().count();
rng.seed(seed1 ^ seed2);
} } a; }
void testcase(){
i64 K, Q; cin >> K >> Q;
//while(Q--){
i64 dim = 0, maxval = 1;
while(maxval <= 2'000'000'000){ dim++; maxval *= K; }
vec<vec<i64>> basis(dim);
auto tsum = [K,dim](const vec<i64>& x, const vec<i64>& y, i64 a, i64 b){
vec<i64> res(dim);
rep(i,dim) res[i] = (x[i] * a + y[i] * b) % K;
return res;
};
rep(d,dim){
basis[d] = vec<i64>(dim);
basis[d][d] = K;
}
vec<i64> A;
auto query1 = [&](i64 x) -> void {
A.push(x);
vec<i64> X(dim);
rep(d,dim){ X[d] = x % K; x /= K; }
repr(d,dim) if(X[d] != 0){
auto g1 = (K / basis[d][d]) / nachia::ExtGcd(K / basis[d][d], X[d]).second;
auto [a,g] = nachia::ExtGcd(basis[d][d], X[d] * g1);
i64 b = (g - a * basis[d][d]) / X[d];
if(a == 0){ swap(a,b); swap(basis[d], X); }
if(a < 0) a += K;
if(b < 0) b += K;
basis[d] = tsum(basis[d], X, a, b);
X = tsum(X, basis[d], K - 1, X[d] / basis[d][d]);
}
};
auto query2 = [&](i64 x) -> i64 {
vec<i64> count(dim+1, 1);
rep(d,dim) count[d+1] = count[d] * (K / basis[d][d]);
if(count[dim] <= x) return -1;
vec<i64> res(dim);
repr(d,dim){
i64 f = x / count[d] - res[d] / basis[d][d];
x %= count[d];
if(f < 0) f += K;
res = tsum(res, basis[d], 1, f);
}
i64 resi = 0;
repr(d,dim) resi = resi * K + res[d];
return resi;
};
auto query3 = [&](i64 x) -> i64 {
if(x >= maxval){
i64 c = 1;
rep(d,dim) c *= K / basis[d][d];
return c;
}
vec<i64> X(dim);
rep(d,dim){ X[d] = x % K; x /= K; }
vec<i64> just(dim);
bool make_just = true;
i64 ans = 0;
repr(d,dim){
i64 b = basis[d][d];
ans *= K / b;
if(make_just){
ans += X[d] / b + 1 - (X[d] % b <= just[d] % b ? 1 : 0);
i64 f = (X[d] - just[d] + K) % K / b;
just = tsum(just, basis[d], 1, f);
if(just[d] != X[d]) make_just = false;
}
}
return ans;
};
while(Q--){
i64 t, x; cin >> t >> x;
if(t == 1){
query1(x);
} else if(t == 2){
x--;
cout << query2(x) << '\n';
} else {
x++;
cout << query3(x) << '\n';
}
//rep(d,dim) cout << basis[d] << endl;
//cout << endl;
}
/*
vec<vec<i64>> A2(3);
rep(t,3){
A2[t] = vec<i64>(100);
i64 a = A[t];
rep(b,100){ A2[t][b] = a%K; a /= K; }
}
vec<i64> que;
rep(i,K) rep(j,K) rep(k,K){
i64 a = 0;
repr(b,100) a = a * K + (A2[0][b] * i + A2[1][b] * j + A2[2][b] * k) % K;
que.push(a);
}
que = que.sortunied();
cout << que << endl;
*/
/*
vec<i64> A(3);
rep(t,3) A[t] = rng.random_signed(0, maxval-1);
rep(t,3) query1(A[t]);
vec<vec<i64>> A2(3);
rep(t,3){
A2[t] = vec<i64>(100);
i64 a = A[t];
rep(b,100){ A2[t][b] = a%K; a /= K; }
}
vec<i64> que;
rep(i,K) rep(j,K) rep(k,K){
i64 a = 0;
repr(b,100) a = a * K + (A2[0][b] * i + A2[1][b] * j + A2[2][b] * k) % K;
que.push(a);
}
que = que.sortunied();
que.push(-1);
rep(f,que.size()){
if(query2(f) != que[f]){
cout << "A[0] = " << A[0] << endl;
cout << "A[1] = " << A[1] << endl;
cout << "A[2] = " << A[2] << endl;
cout << "t = " << 2 << endl;
cout << "x = " << (f+1) << endl;
cout << "wrong ans = " << query2(f) << endl;
exit(0);
}
}
}
*/
}
int main(){
ios::sync_with_stdio(false); cin.tie(nullptr);
#ifdef NACHIA
int T; cin >> T; for(int t=0; t<T; T!=++t?(cout<<'\n'),0:0)
#endif
testcase();
return 0;
}