結果
| 問題 | No.1411 Hundreds of Conditions Sequences |
| ユーザー |
 NyaanNyaan
|
| 提出日時 | 2021-02-26 21:39:44 |
| 言語 | C++17 (gcc 13.2.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 443 ms / 2,000 ms |
| コード長 | 33,231 bytes |
| コンパイル時間 | 4,252 ms |
| コンパイル使用メモリ | 320,776 KB |
| 実行使用メモリ | 88,972 KB |
| 最終ジャッジ日時 | 2024-04-10 12:16:15 |
| 合計ジャッジ時間 | 29,722 ms |
|
ジャッジサーバーID （参考情報） |
judge4 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 110 ms
58,088 KB |
| testcase_01 | AC | 117 ms
58,040 KB |
| testcase_02 | AC | 117 ms
58,060 KB |
| testcase_03 | AC | 119 ms
58,020 KB |
| testcase_04 | AC | 115 ms
58,196 KB |
| testcase_05 | AC | 115 ms
58,036 KB |
| testcase_06 | AC | 115 ms
58,152 KB |
| testcase_07 | AC | 114 ms
58,088 KB |
| testcase_08 | AC | 111 ms
57,976 KB |
| testcase_09 | AC | 117 ms
58,056 KB |
| testcase_10 | AC | 117 ms
58,076 KB |
| testcase_11 | AC | 117 ms
58,084 KB |
| testcase_12 | AC | 380 ms
84,116 KB |
| testcase_13 | AC | 313 ms
77,568 KB |
| testcase_14 | AC | 217 ms
68,012 KB |
| testcase_15 | AC | 315 ms
77,160 KB |
| testcase_16 | AC | 129 ms
59,316 KB |
| testcase_17 | AC | 304 ms
76,348 KB |
| testcase_18 | AC | 386 ms
83,996 KB |
| testcase_19 | AC | 393 ms
86,432 KB |
| testcase_20 | AC | 212 ms
68,080 KB |
| testcase_21 | AC | 440 ms
88,432 KB |
| testcase_22 | AC | 232 ms
69,188 KB |
| testcase_23 | AC | 376 ms
84,596 KB |
| testcase_24 | AC | 116 ms
58,168 KB |
| testcase_25 | AC | 377 ms
84,068 KB |
| testcase_26 | AC | 301 ms
76,472 KB |
| testcase_27 | AC | 219 ms
68,472 KB |
| testcase_28 | AC | 326 ms
79,780 KB |
| testcase_29 | AC | 152 ms
60,620 KB |
| testcase_30 | AC | 290 ms
74,116 KB |
| testcase_31 | AC | 265 ms
72,680 KB |
| testcase_32 | AC | 421 ms
88,600 KB |
| testcase_33 | AC | 415 ms
88,596 KB |
| testcase_34 | AC | 410 ms
88,592 KB |
| testcase_35 | AC | 416 ms
88,644 KB |
| testcase_36 | AC | 410 ms
88,576 KB |
| testcase_37 | AC | 419 ms
88,684 KB |
| testcase_38 | AC | 429 ms
88,612 KB |
| testcase_39 | AC | 412 ms
88,500 KB |
| testcase_40 | AC | 416 ms
88,500 KB |
| testcase_41 | AC | 422 ms
88,664 KB |
| testcase_42 | AC | 419 ms
88,780 KB |
| testcase_43 | AC | 418 ms
88,604 KB |
| testcase_44 | AC | 420 ms
88,628 KB |
| testcase_45 | AC | 426 ms
88,680 KB |
| testcase_46 | AC | 420 ms
88,672 KB |
| testcase_47 | AC | 420 ms
88,660 KB |
| testcase_48 | AC | 420 ms
88,752 KB |
| testcase_49 | AC | 419 ms
88,604 KB |
| testcase_50 | AC | 423 ms
88,636 KB |
| testcase_51 | AC | 418 ms
88,504 KB |
| testcase_52 | AC | 439 ms
88,792 KB |
| testcase_53 | AC | 442 ms
88,956 KB |
| testcase_54 | AC | 443 ms
88,776 KB |
| testcase_55 | AC | 436 ms
88,728 KB |
| testcase_56 | AC | 425 ms
88,844 KB |
| testcase_57 | AC | 435 ms
88,972 KB |
| testcase_58 | AC | 430 ms
88,800 KB |
| testcase_59 | AC | 435 ms
88,816 KB |
| testcase_60 | AC | 429 ms
88,716 KB |
| testcase_61 | AC | 437 ms
88,788 KB |
| testcase_62 | AC | 208 ms
81,948 KB |
| testcase_63 | AC | 293 ms
82,888 KB |
コンパイルメッセージ
main.cpp:480:7: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
480 | : iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
| ^~~~~~~~
In file included from /home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_algobase.h:65,
from /home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/algorithm:60,
from main.cpp:11:
/home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
main.cpp:482:7: warning: 'template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator' is deprecated [-Wdeprecated-declarations]
482 | iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
| ^~~~~~~~
/home/linuxbrew/.linuxbrew/Cellar/gcc/13.2.0/include/c++/13/bits/stl_iterator_base_types.h:127:34: note: declared here
127 | struct _GLIBCXX17_DEPRECATED iterator
| ^~~~~~~~
ソースコード
/**
* date : 2021-02-26 21:39:40
*/
#define NDEBUG
using namespace std;
// intrinstic
#include <immintrin.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <complex>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <forward_list>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <ratio>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <system_error>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
// utility
namespace Nyaan {
using ll = long long;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
using vi = vector<int>;
using vl = vector<long long>;
using vd = V<double>;
using vs = V<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
template <typename T, typename U>
struct P : pair<T, U> {
template <typename... Args>
P(Args... args) : pair<T, U>(args...) {}
using pair<T, U>::first;
using pair<T, U>::second;
T &x() { return first; }
const T &x() const { return first; }
U &y() { return second; }
const U &y() const { return second; }
P &operator+=(const P &r) {
first += r.first;
second += r.second;
return *this;
}
P &operator-=(const P &r) {
first -= r.first;
second -= r.second;
return *this;
}
P &operator*=(const P &r) {
first *= r.first;
second *= r.second;
return *this;
}
P operator+(const P &r) const { return P(*this) += r; }
P operator-(const P &r) const { return P(*this) -= r; }
P operator*(const P &r) const { return P(*this) *= r; }
};
using pl = P<ll, ll>;
using pi = P<int, int>;
using vp = V<pl>;
constexpr int inf = 1001001001;
constexpr long long infLL = 4004004004004004004LL;
template <typename T>
int sz(const T &t) {
return t.size();
}
template <typename T, size_t N>
void mem(T (&a)[N], int c) {
memset(a, c, sizeof(T) * N);
}
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
for (; n; x *= x, n >>= 1) ret *= (n & 1 ? x : 1);
return ret;
}
template <typename T, typename U>
pair<T, U> mkp(const T &t, const U &u) {
return make_pair(t, u);
}
template <typename T>
vector<T> mkrui(const vector<T> &v, bool rev = false) {
vector<T> ret(v.size() + 1);
if (rev) {
for (int i = int(v.size()) - 1; i >= 0; i--) ret[i] = v[i] + ret[i + 1];
} else {
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
}
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T>
vector<T> reord(const vector<T> &v, const vector<T> &ord) {
int N = v.size();
vector<T> ret(N);
for (int i = 0; i < N; i++) ret[i] = v[ord[i]];
return ret;
};
template <typename T = int>
vector<T> mkiota(int N) {
vector<T> ret(N);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T>
vector<int> mkinv(vector<T> &v, int max_val = -1) {
if (max_val < (int)v.size()) max_val = v.size() - 1;
vector<int> inv(max_val + 1, -1);
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
} // namespace Nyaan
// bit operation
namespace Nyaan {
__attribute__((target("popcnt"))) inline int popcnt(const u64 &a) {
return _mm_popcnt_u64(a);
}
__attribute__((target("bmi"))) inline int lsb(const u64 &a) {
return _tzcnt_u64(a);
}
__attribute__((target("bmi"))) inline int ctz(const u64 &a) {
return _tzcnt_u64(a);
}
__attribute__((target("lzcnt"))) inline int msb(const u64 &a) {
return 63 - _lzcnt_u64(a);
}
__attribute__((target("lzcnt"))) inline int clz64(const u64 &a) {
return _lzcnt_u64(a);
}
template <typename T>
inline int gbit(const T &a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void sbit(T &a, int i, bool b) {
a ^= (gbit(a, i) == b ? 0 : (T(b) << i));
}
constexpr long long PW(int n) { return 1LL << n; }
constexpr long long MSK(int n) { return (1LL << n) - 1; }
} // namespace Nyaan
// inout
namespace Nyaan {
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &... u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &... u) {
cout << t;
if (sizeof...(u)) cout << sep;
out(u...);
}
void outr() {}
template <typename T, class... U, char sep = ' '>
void outr(const T &t, const U &... u) {
cout << t;
outr(u...);
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
} // namespace Nyaan
// debug
namespace DebugImpl {
template <typename U, typename = void>
struct is_specialize : false_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, typename U::iterator, void>::type>
: true_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, decltype(U::first), void>::type>
: true_type {};
template <typename U>
struct is_specialize<U, enable_if_t<is_integral<U>::value, void>> : true_type {
};
void dump(const char& t) { cerr << t; }
void dump(const string& t) { cerr << t; }
template <typename U,
enable_if_t<!is_specialize<U>::value, nullptr_t> = nullptr>
void dump(const U& t) {
cerr << t;
}
template <typename T>
void dump(const T& t, enable_if_t<is_integral<T>::value>* = nullptr) {
string res;
if (t == Nyaan::inf) res = "inf";
if (is_signed<T>::value)
if (t == -Nyaan::inf) res = "-inf";
if (sizeof(T) == 8) {
if (t == Nyaan::infLL) res = "inf";
if (is_signed<T>::value)
if (t == -Nyaan::infLL) res = "-inf";
}
if (res.empty()) res = to_string(t);
cerr << res;
}
template <typename T, typename U>
void dump(const pair<T, U>&);
template <typename T>
void dump(const pair<T*, int>&);
template <typename T>
void dump(const T& t,
enable_if_t<!is_void<typename T::iterator>::value>* = nullptr) {
cerr << "[ ";
for (auto it = t.begin(); it != t.end();) {
dump(*it);
cerr << (++it == t.end() ? "" : ", ");
}
cerr << " ]";
}
template <typename T, typename U>
void dump(const pair<T, U>& t) {
cerr << "( ";
dump(t.first);
cerr << ", ";
dump(t.second);
cerr << " )";
}
template <typename T>
void dump(const pair<T*, int>& t) {
cerr << "[ ";
for (int i = 0; i < t.second; i++) {
dump(t.first[i]);
cerr << (i == t.second - 1 ? "" : ", ");
}
cerr << " ]";
}
void trace() { cerr << endl; }
template <typename Head, typename... Tail>
void trace(Head&& head, Tail&&... tail) {
cerr << " ";
dump(head);
if (sizeof...(tail) != 0) cerr << ",";
trace(forward<Tail>(tail)...);
}
} // namespace DebugImpl
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << "## " << #__VA_ARGS__ << " = "; \
DebugImpl::trace(__VA_ARGS__); \
} while (0)
#else
#define trc(...)
#endif
// macro
#define each(x, v) for (auto&& x : v)
#define each2(x, y, v) for (auto&& [x, y] : v)
#define all(v) (v).begin(), (v).end()
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define regr(i, a, b) for (long long i = (b)-1; i >= (a); i--)
#define repc(i, a, cond) for (long long i = (a); (cond); i++)
#define enm(i, val, vec) \
for (long long i = 0; i < (long long)(vec).size(); i++) \
if (auto& val = vec[i]; false) \
; \
else
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define inc(...) \
char __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define die(...) \
do { \
Nyaan::out(__VA_ARGS__); \
return; \
} while (0)
namespace Nyaan {
void solve();
}
int main() { Nyaan::solve(); }
//
namespace HashMapImpl {
using u32 = uint32_t;
using u64 = uint64_t;
template <typename Key, typename Data>
struct HashMapBase;
template <typename Key, typename Data>
struct itrB
: iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&> {
using base =
iterator<bidirectional_iterator_tag, Data, ptrdiff_t, Data*, Data&>;
using ptr = typename base::pointer;
using ref = typename base::reference;
u32 i;
HashMapBase<Key, Data>* p;
explicit constexpr itrB() : i(0), p(nullptr) {}
explicit constexpr itrB(u32 _i, HashMapBase<Key, Data>* _p) : i(_i), p(_p) {}
explicit constexpr itrB(u32 _i, const HashMapBase<Key, Data>* _p)
: i(_i), p(const_cast<HashMapBase<Key, Data>*>(_p)) {}
friend void swap(itrB& l, itrB& r) { swap(l.i, r.i), swap(l.p, r.p); }
friend bool operator==(const itrB& l, const itrB& r) { return l.i == r.i; }
friend bool operator!=(const itrB& l, const itrB& r) { return l.i != r.i; }
const ref operator*() const {
return const_cast<const HashMapBase<Key, Data>*>(p)->data[i];
}
ref operator*() { return p->data[i]; }
ptr operator->() const { return &(p->data[i]); }
itrB& operator++() {
assert(i != p->cap && "itr::operator++()");
do {
i++;
if (i == p->cap) break;
if (p->flag[i] == true && p->dflag[i] == false) break;
} while (true);
return (*this);
}
itrB operator++(int) {
itrB it(*this);
++(*this);
return it;
}
itrB& operator--() {
do {
i--;
if (p->flag[i] == true && p->dflag[i] == false) break;
assert(i != 0 && "itr::operator--()");
} while (true);
return (*this);
}
itrB operator--(int) {
itrB it(*this);
--(*this);
return it;
}
};
template <typename Key, typename Data>
struct HashMapBase {
using u32 = uint32_t;
using u64 = uint64_t;
using iterator = itrB<Key, Data>;
using itr = iterator;
protected:
template <typename K,
enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<K>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
return u32((u64(key ^ r) * 11995408973635179863ULL) >> shift);
}
template <
typename K, enable_if_t<is_same<K, Key>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::first)>::value, nullptr_t> = nullptr,
enable_if_t<is_integral<decltype(K::second)>::value, nullptr_t> = nullptr>
inline u32 inner_hash(const K& key) const {
u64 a = key.first ^ r;
u64 b = key.second ^ r;
a *= 11995408973635179863ULL;
b *= 10150724397891781847ULL;
return u32((a + b) >> shift);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat);
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline u32 hash(const D& dat) const {
return inner_hash(dat.first);
}
template <typename D = Data,
enable_if_t<is_same<D, Key>::value, nullptr_t> = nullptr>
inline Key dtok(const D& dat) const {
return dat;
}
template <
typename D = Data,
enable_if_t<is_same<decltype(D::first), Key>::value, nullptr_t> = nullptr>
inline Key dtok(const D& dat) const {
return dat.first;
}
void reallocate(u32 ncap) {
vector<Data> ndata(ncap);
vector<bool> nf(ncap);
shift = 64 - __lg(ncap);
for (u32 i = 0; i < cap; i++) {
if (flag[i] == true && dflag[i] == false) {
u32 h = hash(data[i]);
while (nf[h]) h = (h + 1) & (ncap - 1);
ndata[h] = data[i];
nf[h] = true;
}
}
data.swap(ndata);
flag.swap(nf);
cap = ncap;
dflag.resize(cap);
fill(std::begin(dflag), std::end(dflag), false);
}
inline bool extend_rate(u32 x) const { return x * 2 >= cap; }
inline bool shrink_rate(u32 x) const {
return HASHMAP_DEFAULT_SIZE < cap && x * 10 <= cap;
}
inline void extend() { reallocate(cap << 1); }
inline void shrink() { reallocate(cap >> 1); }
public:
u32 cap, s;
vector<Data> data;
vector<bool> flag, dflag;
u32 shift;
static u64 r;
static constexpr uint32_t HASHMAP_DEFAULT_SIZE = 4;
explicit HashMapBase()
: cap(HASHMAP_DEFAULT_SIZE),
s(0),
data(cap),
flag(cap),
dflag(cap),
shift(64 - __lg(cap)) {}
itr begin() const {
u32 h = 0;
while (h != cap) {
if (flag[h] == true && dflag[h] == false) break;
h++;
}
return itr(h, this);
}
itr end() const { return itr(this->cap, this); }
friend itr begin(const HashMapBase& h) { return h.begin(); }
friend itr end(const HashMapBase& h) { return h.end(); }
itr find(const Key& key) const {
u32 h = inner_hash(key);
while (true) {
if (flag[h] == false) return this->end();
if (dtok(data[h]) == key) {
if (dflag[h] == true) return this->end();
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
bool contain(const Key& key) const { return find(key) != this->end(); }
itr insert(const Data& d) {
u32 h = hash(d);
while (true) {
if (flag[h] == false) {
if (extend_rate(s + 1)) {
extend();
h = hash(d);
continue;
}
data[h] = d;
flag[h] = true;
++s;
return itr(h, this);
}
if (dtok(data[h]) == dtok(d)) {
if (dflag[h] == true) {
data[h] = d;
dflag[h] = false;
++s;
}
return itr(h, this);
}
h = (h + 1) & (cap - 1);
}
}
// tips for speed up :
// if return value is unnecessary, make argument_2 false.
itr erase(itr it, bool get_next = true) {
if (it == this->end()) return this->end();
s--;
if (shrink_rate(s)) {
Data d = data[it.i];
shrink();
it = find(dtok(d));
}
int ni = (it.i + 1) & (cap - 1);
if (this->flag[ni]) {
this->dflag[it.i] = true;
} else {
this->flag[it.i] = false;
}
if (get_next) ++it;
return it;
}
itr erase(const Key& key) { return erase(find(key)); }
bool empty() const { return s == 0; }
int size() const { return s; }
void clear() {
fill(std::begin(flag), std::end(flag), false);
fill(std::begin(dflag), std::end(dflag), false);
s = 0;
}
void reserve(int n) {
if (n <= 0) return;
n = 1 << min(23, __lg(n) + 2);
if (cap < u32(n)) reallocate(n);
}
};
template <typename Key, typename Data>
uint64_t HashMapBase<Key, Data>::r =
chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count();
} // namespace HashMapImpl
/**
* @brief Hash Map(base) (ハッシュマップ・基底クラス)
*/
template <typename Key, typename Val>
struct HashMap : HashMapImpl::HashMapBase<Key, pair<Key, Val>> {
using base = typename HashMapImpl::HashMapBase<Key, pair<Key, Val>>;
using HashMapImpl::HashMapBase<Key, pair<Key, Val>>::HashMapBase;
using Data = pair<Key, Val>;
Val& operator[](const Key& k) {
typename base::u32 h = base::inner_hash(k);
while (true) {
if (base::flag[h] == false) {
if (base::extend_rate(base::s + 1)) {
base::extend();
h = base::hash(k);
continue;
}
base::data[h].first = k;
base::data[h].second = Val();
base::flag[h] = true;
++base::s;
return base::data[h].second;
}
if (base::data[h].first == k) {
if (base::dflag[h] == true) base::data[h].second = Val();
return base::data[h].second;
}
h = (h + 1) & (base::cap - 1);
}
}
typename base::itr emplace(const Key& key, const Val& val) {
return base::insert(Data(key, val));
}
};
/*
* @brief ハッシュマップ(連想配列)
* @docs docs/hashmap/hashmap.md
**/
template <uint32_t mod>
struct LazyMontgomeryModInt {
using mint = LazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static constexpr u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i) ret *= 2 - mod * ret;
return ret;
}
static constexpr u32 r = get_r();
static constexpr u32 n2 = -u64(mod) % mod;
static_assert(r * mod == 1, "invalid, r * mod != 1");
static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
u32 a;
constexpr LazyMontgomeryModInt() : a(0) {}
constexpr LazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static constexpr u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
constexpr mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
constexpr mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
constexpr bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
constexpr bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
constexpr mint operator-() const { return mint() - mint(*this); }
constexpr mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
constexpr mint inverse() const { return pow(mod - 2); }
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = LazyMontgomeryModInt<mod>(t);
return (is);
}
constexpr u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static constexpr u32 get_mod() { return mod; }
};
namespace inner {
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
template <typename T>
T gcd(T a, T b) {
while (b) swap(a %= b, b);
return a;
}
template <typename T>
T inv(T a, T p) {
T b = p, x = 1, y = 0;
while (a) {
T q = b / a;
swap(a, b %= a);
swap(x, y -= q * x);
}
assert(b == 1);
return y < 0 ? y + p : y;
}
template <typename T, typename U>
T modpow(T a, U n, T p) {
T ret = 1 % p;
for (; n; n >>= 1, a = U(a) * a % p)
if (n & 1) ret = U(ret) * a % p;
return ret;
}
} // namespace inner
namespace my_rand {
// [0, 2^64 - 1)
uint64_t rng() {
static uint64_t x_ =
uint64_t(chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count()) *
10150724397891781847ULL;
x_ ^= x_ << 7;
return x_ ^= x_ >> 9;
}
// [l, r)
int64_t randint(int64_t l, int64_t r) {
assert(l < r);
return l + rng() % (r - l);
}
// choose n numbers from [l, r) without overlapping
vector<int64_t> randset(int64_t l, int64_t r, int64_t n) {
assert(l <= r && n <= r - l);
unordered_set<int64_t> s;
for (int64_t i = n; i; --i) {
int64_t m = randint(l, r + 1 - i);
if (s.find(m) != s.end()) m = r - i;
s.insert(m);
}
vector<int64_t> ret;
for (auto& x : s) ret.push_back(x);
return ret;
}
// [0.0, 1.0)
double rnd() {
union raw_cast {
double t;
uint64_t u;
};
constexpr uint64_t p = uint64_t(1023 - 64) << 52;
return rng() * ((raw_cast*)(&p))->t;
}
template <typename T>
void randshf(vector<T>& v) {
int n = v.size();
for (int loop = 0; loop < 2; loop++)
for (int i = 0; i < n; i++) swap(v[i], v[randint(0, n)]);
}
} // namespace my_rand
using my_rand::randint;
using my_rand::randset;
using my_rand::randshf;
using my_rand::rnd;
using my_rand::rng;
struct ArbitraryLazyMontgomeryModInt {
using mint = ArbitraryLazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static u32 mod;
static u32 r;
static u32 n2;
static u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i) ret *= 2 - mod * ret;
return ret;
}
static void set_mod(u32 m) {
assert(m < (1 << 30));
assert((m & 1) == 1);
mod = m;
n2 = -u64(m) % m;
r = get_r();
assert(r * mod == 1);
}
u32 a;
ArbitraryLazyMontgomeryModInt() : a(0) {}
ArbitraryLazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0) a += 2 * mod;
return *this;
}
mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0) a += 2 * mod;
return *this;
}
mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
mint operator+(const mint &b) const { return mint(*this) += b; }
mint operator-(const mint &b) const { return mint(*this) -= b; }
mint operator*(const mint &b) const { return mint(*this) *= b; }
mint operator/(const mint &b) const { return mint(*this) /= b; }
bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
mint operator-() const { return mint() - mint(*this); }
mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = ArbitraryLazyMontgomeryModInt(t);
return (is);
}
mint inverse() const { return pow(mod - 2); }
u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static u32 get_mod() { return mod; }
};
typename ArbitraryLazyMontgomeryModInt::u32 ArbitraryLazyMontgomeryModInt::mod;
typename ArbitraryLazyMontgomeryModInt::u32 ArbitraryLazyMontgomeryModInt::r;
typename ArbitraryLazyMontgomeryModInt::u32 ArbitraryLazyMontgomeryModInt::n2;
struct montgomery64 {
using mint = montgomery64;
using i64 = int64_t;
using u64 = uint64_t;
using u128 = __uint128_t;
static u64 mod;
static u64 r;
static u64 n2;
static u64 get_r() {
u64 ret = mod;
for (i64 i = 0; i < 5; ++i) ret *= 2 - mod * ret;
return ret;
}
static void set_mod(u64 m) {
assert(m < (1LL << 62));
assert((m & 1) == 1);
mod = m;
n2 = -u128(m) % m;
r = get_r();
assert(r * mod == 1);
}
u64 a;
montgomery64() : a(0) {}
montgomery64(const int64_t &b) : a(reduce((u128(b) + mod) * n2)){};
static u64 reduce(const u128 &b) {
return (b + u128(u64(b) * u64(-r)) * mod) >> 64;
}
mint &operator+=(const mint &b) {
if (i64(a += b.a - 2 * mod) < 0) a += 2 * mod;
return *this;
}
mint &operator-=(const mint &b) {
if (i64(a -= b.a) < 0) a += 2 * mod;
return *this;
}
mint &operator*=(const mint &b) {
a = reduce(u128(a) * b.a);
return *this;
}
mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
mint operator+(const mint &b) const { return mint(*this) += b; }
mint operator-(const mint &b) const { return mint(*this) -= b; }
mint operator*(const mint &b) const { return mint(*this) *= b; }
mint operator/(const mint &b) const { return mint(*this) /= b; }
bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
mint operator-() const { return mint() - mint(*this); }
mint pow(u128 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = montgomery64(t);
return (is);
}
mint inverse() const { return pow(mod - 2); }
u64 get() const {
u64 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static u64 get_mod() { return mod; }
};
typename montgomery64::u64 montgomery64::mod, montgomery64::r, montgomery64::n2;
namespace fast_factorize {
using u64 = uint64_t;
template <typename mint>
bool miller_rabin(u64 n, vector<u64> as) {
if (mint::get_mod() != n) mint::set_mod(n);
u64 d = n - 1;
while (~d & 1) d >>= 1;
mint e{1}, rev{int64_t(n - 1)};
for (u64 a : as) {
if (n <= a) break;
u64 t = d;
mint y = mint(a).pow(t);
while (t != n - 1 && y != e && y != rev) {
y *= y;
t *= 2;
}
if (y != rev && t % 2 == 0) return false;
}
return true;
}
bool is_prime(u64 n) {
if (~n & 1) return n == 2;
if (n <= 1) return false;
if (n < (1LL << 30))
return miller_rabin<ArbitraryLazyMontgomeryModInt>(n, {2, 7, 61});
else
return miller_rabin<montgomery64>(
n, {2, 325, 9375, 28178, 450775, 9780504, 1795265022});
}
template <typename mint, typename T>
T pollard_rho(T n) {
if (~n & 1) return 2;
if (is_prime(n)) return n;
if (mint::get_mod() != n) mint::set_mod(n);
mint R, one = 1;
auto f = [&](mint x) { return x * x + R; };
auto rnd_ = [&]() { return rng() % (n - 2) + 2; };
while (1) {
mint x, y, ys, q = one;
R = rnd_(), y = rnd_();
T g = 1;
constexpr int m = 128;
for (int r = 1; g == 1; r <<= 1) {
x = y;
for (int i = 0; i < r; ++i) y = f(y);
for (int k = 0; g == 1 && k < r; k += m) {
ys = y;
for (int i = 0; i < m && i < r - k; ++i) q *= x - (y = f(y));
g = inner::gcd<T>(q.get(), n);
}
}
if (g == n) do
g = inner::gcd<T>((x - (ys = f(ys))).get(), n);
while (g == 1);
if (g != n) return g;
}
exit(1);
}
vector<u64> inner_factorize(u64 n) {
if (n <= 1) return {};
u64 p;
if (n <= (1LL << 30))
p = pollard_rho<ArbitraryLazyMontgomeryModInt, uint32_t>(n);
else
p = pollard_rho<montgomery64, uint64_t>(n);
if (p == n) return {p};
auto l = inner_factorize(p);
auto r = inner_factorize(n / p);
copy(begin(r), end(r), back_inserter(l));
return l;
}
vector<u64> factorize(u64 n) {
auto ret = inner_factorize(n);
sort(begin(ret), end(ret));
return ret;
}
using i64 = int64_t;
map<u64, i64> factor_count(u64 n) {
map<u64, i64> mp;
for (auto &x : factorize(n)) mp[x]++;
return mp;
}
vector<u64> divisors(u64 n) {
if (n == 0) return {};
vector<pair<u64, i64>> v;
for (auto &p : factor_count(n)) v.push_back(p);
vector<u64> ret;
auto f = [&](auto rec, int i, u64 x) -> void {
if (i == (int)v.size()) {
ret.push_back(x);
return;
}
for (int j = v[i].second;; --j) {
rec(rec, i + 1, x);
if (j == 0) break;
x *= v[i].first;
}
};
f(f, 0, 1);
sort(begin(ret), end(ret));
return ret;
}
} // namespace fast_factorize
using fast_factorize::divisors;
using fast_factorize::factor_count;
using fast_factorize::factorize;
using fast_factorize::is_prime;
/**
* @brief 高速素因数分解(Miller Rabin/Pollard's Rho)
* @docs docs/prime/fast-factorize.md
*/
using mint = LazyMontgomeryModInt<1000000007>;
using vm = vector<mint>;
using vvm = vector<vm>;
template <typename T>
struct Binomial {
vector<T> fac_, finv_, inv_;
Binomial(int MAX = 0) : fac_(MAX + 10), finv_(MAX + 10), inv_(MAX + 10) {
assert(T::get_mod() != 0);
MAX += 9;
fac_[0] = finv_[0] = inv_[0] = 1;
for (int i = 1; i <= MAX; i++) fac_[i] = fac_[i - 1] * i;
finv_[MAX] = fac_[MAX].inverse();
for (int i = MAX - 1; i > 0; i--) finv_[i] = finv_[i + 1] * (i + 1);
for (int i = 1; i <= MAX; i++) inv_[i] = finv_[i] * fac_[i - 1];
}
void extend() {
int n = fac_.size();
T fac = fac_.back() * n;
T inv = (-inv_[T::get_mod() % n]) * (T::get_mod() / n);
T finv = finv_.back() * inv;
fac_.push_back(fac);
finv_.push_back(finv);
inv_.push_back(inv);
}
T fac(int i) {
if(i < 0) return T(0);
while (i >= (int)fac_.size()) extend();
return fac_[i];
}
T finv(int i) {
if(i < 0) return T(0);
while (i >= (int)finv_.size()) extend();
return finv_[i];
}
T inv(int i) {
if(i < 0) return T(0);
while (i >= (int)inv_.size()) extend();
return inv_[i];
}
T C(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r) * finv(r);
}
T C_naive(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
T ret = T(1);
r = min(r, n - r);
for (int i = 1; i <= r; ++i) ret *= inv(i) * (n--);
return ret;
}
T P(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r);
}
T H(int n, int r) {
if (n < 0 || r < 0) return T(0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
Binomial<mint> C;
using namespace Nyaan;
void Nyaan::solve() {
ini(N);
vl a(N);
in(a);
V<HashMap<int, int>> fs(N);
rep(i, N) {
auto fc = factorize(a[i]);
each(x, fc) fs[i][int(x)] += 1;
}
vvi A(1001001);
mint all = 1;
each(x, a) all *= x;
mint lcm = 1;
rep(i, N) each2(k, v, fs[i]) A[k].push_back(v);
rep(i, sz(A)) {
auto& v = A[i];
v.push_back(0);
v.push_back(0);
sort(all(v));
lcm *= mint(i).pow(v.back());
}
rep(i, N) {
mint al = all / a[i];
mint lc = lcm;
each2(k, v, fs[i]) {
if (A[k].back() == v) {
int dif = A[k][sz(A[k]) - 1] - A[k][sz(A[k]) - 2];
if (dif) lc *= (mint(k).inverse()).pow(dif);
}
}
out(al - lc);
}
}