結果
| 問題 | No.2074 Product is Square ? |
| ユーザー |
 siganai
|
| 提出日時 | 2022-09-16 22:15:31 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
TLE
|
| 実行時間 | - |
| コード長 | 9,026 bytes |
| コンパイル時間 | 2,453 ms |
| コンパイル使用メモリ | 215,004 KB |
| 実行使用メモリ | 13,756 KB |
| 最終ジャッジ日時 | 2024-06-01 13:21:11 |
| 合計ジャッジ時間 | 14,824 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
13,756 KB |
| testcase_01 | AC | 811 ms
6,944 KB |
| testcase_02 | AC | 765 ms
6,944 KB |
| testcase_03 | AC | 801 ms
6,940 KB |
| testcase_04 | AC | 765 ms
6,940 KB |
| testcase_05 | AC | 836 ms
6,940 KB |
| testcase_06 | AC | 818 ms
6,944 KB |
| testcase_07 | AC | 836 ms
6,944 KB |
| testcase_08 | AC | 750 ms
6,940 KB |
| testcase_09 | AC | 719 ms
6,940 KB |
| testcase_10 | AC | 763 ms
6,944 KB |
| testcase_11 | AC | 69 ms
6,940 KB |
| testcase_12 | AC | 693 ms
6,944 KB |
| testcase_13 | TLE | - |
| testcase_14 | -- | - |
| testcase_15 | -- | - |
| testcase_16 | -- | - |
| testcase_17 | -- | - |
| testcase_18 | -- | - |
| testcase_19 | -- | - |
| testcase_20 | -- | - |
| testcase_21 | -- | - |
| testcase_22 | -- | - |
| testcase_23 | -- | - |
| testcase_24 | -- | - |
| testcase_25 | -- | - |
| testcase_26 | -- | - |
| testcase_27 | -- | - |
| testcase_28 | -- | - |
| testcase_29 | -- | - |
| testcase_30 | -- | - |
| testcase_31 | -- | - |
| testcase_32 | -- | - |
| testcase_33 | -- | - |
ソースコード
//#pragma GCC target("avx")
//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#ifdef LOCAL
# include <debug.hpp>
# define debug(...) debug_print::multi_print(#__VA_ARGS__, __VA_ARGS__)
#else
# define debug(...) (static_cast<void>(0))
#endif
//#include "atcoder/convolution.hpp"
//#include "atcoder/modint.hpp"
using namespace std;
//using namespace atcoder;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vvvl = vector<vvl>;
using vs = vector<string>;
template<class T> using pq = priority_queue<T, vector<T>, greater<T>>;
#define overload4(_1, _2, _3, _4, name, ...) name
#define overload3(a,b,c,name,...) name
#define rep1(n) for (ll UNUSED_NUMBER = 0; UNUSED_NUMBER < (n); ++UNUSED_NUMBER)
#define rep2(i, n) for (ll i = 0; i < (n); ++i)
#define rep3(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep4(i, a, b, c) for (ll i = (a); i < (b); i += (c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep1(n) for(ll i = (n) - 1;i >= 0;i--)
#define rrep2(i,n) for(ll i = (n) - 1;i >= 0;i--)
#define rrep3(i,a,b) for(ll i = (b) - 1;i >= (a);i--)
#define rrep4(i,a,b,c) for(ll i = (a) + ((b)-(a)-1) / (c) * (c);i >= (a);i -= c)
#define rrep(...) overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define all1(i) begin(i) , end(i)
#define all2(i,a) begin(i) , begin(i) + a
#define all3(i,a,b) begin(i) + a , begin(i) + b
#define all(...) overload3(__VA_ARGS__, all3, all2, all1)(__VA_ARGS__)
#define sum(...) accumulate(all(__VA_ARGS__),0LL)
template<class T> bool chmin(T &a, const T &b){ if(a > b){ a = b; return 1; } else return 0; }
template<class T> bool chmax(T &a, const T &b){ if(a < b){ a = b; return 1; } else return 0; }
template<class T> auto min(const T& a){ return *min_element(all(a)); }
template<class T> auto max(const T& a){ return *max_element(all(a)); }
template<class... Ts> void in(Ts&... t);
#define elif else if
#define vec(type,name,...) vector<type> name(__VA_ARGS__)
#define vv(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define INT(...) int __VA_ARGS__; in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__; in(__VA_ARGS__)
#define STR(...) string __VA_ARGS__; in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__; in(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__; in(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__; in(__VA_ARGS__)
#define VEC(type, name, size) vector<type> name(size); in(name)
#define VV(type, name, h, w) vector<vector<type>> name(h, vector<type>(w)); in(name)
ll intpow(ll a, ll b){ ll ans = 1; while(b){if(b & 1) ans *= a; a *= a; b /= 2;} return ans;}
ll modpow(ll a, ll b, ll p){ ll ans = 1; a %= p;while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll GCD(ll a,ll b) { if(b == 0) return 0; if(a % b == 0) return b; else return GCD(b,a%b);}
ll LCM(ll a,ll b) { if(a == 0) return b; if(b == 0) return a;return a / GCD(a,b) * b;}
namespace IO{
#define VOID(a) decltype(void(a))
struct setting{ setting(){cin.tie(nullptr); ios::sync_with_stdio(false);fixed(cout); cout.precision(12);}} setting;
template<int I> struct P : P<I-1>{};
template<> struct P<0>{};
template<class T> void i(T& t){ i(t, P<3>{}); }
void i(vector<bool>::reference t, P<3>){ int a; i(a); t = a; }
template<class T> auto i(T& t, P<2>) -> VOID(cin >> t){ cin >> t; }
template<class T> auto i(T& t, P<1>) -> VOID(begin(t)){ for(auto&& x : t) i(x); }
template<class T, size_t... idx> void ituple(T& t, index_sequence<idx...>){
in(get<idx>(t)...);}
template<class T> auto i(T& t, P<0>) -> VOID(tuple_size<T>{}){
ituple(t, make_index_sequence<tuple_size<T>::value>{});}
#undef VOID
}
#define unpack(a) (void)initializer_list<int>{(a, 0)...}
template<class... Ts> void in(Ts&... t){ unpack(IO :: i(t)); }
#undef unpack
constexpr int mod = 1000000007;
//constexpr int mod = 998244353;
static const double PI = 3.1415926535897932;
template <class F> struct REC {
F f;
REC(F &&f_) : f(forward<F>(f_)) {}
template <class... Args> auto operator()(Args &&...args) const { return f(*this, forward<Args>(args)...); }};
namespace FastPrimeFactorization {
template< typename word, typename dword, typename sword >
struct UnsafeMod {
UnsafeMod() : x(0) {}
UnsafeMod(word _x) : x(init(_x)) {}
bool operator==(const UnsafeMod &rhs) const {
return x == rhs.x;
}
bool operator!=(const UnsafeMod &rhs) const {
return x != rhs.x;
}
UnsafeMod &operator+=(const UnsafeMod &rhs) {
if((x += rhs.x) >= mod) x -= mod;
return *this;
}
UnsafeMod &operator-=(const UnsafeMod &rhs) {
if(sword(x -= rhs.x) < 0) x += mod;
return *this;
}
UnsafeMod &operator*=(const UnsafeMod &rhs) {
x = reduce(dword(x) * rhs.x);
return *this;
}
UnsafeMod operator+(const UnsafeMod &rhs) const {
return UnsafeMod(*this) += rhs;
}
UnsafeMod operator-(const UnsafeMod &rhs) const {
return UnsafeMod(*this) -= rhs;
}
UnsafeMod operator*(const UnsafeMod &rhs) const {
return UnsafeMod(*this) *= rhs;
}
UnsafeMod pow(uint64_t e) const {
UnsafeMod ret(1);
for(UnsafeMod base = *this; e; e >>= 1, base *= base) {
if(e & 1) ret *= base;
}
return ret;
}
word get() const {
return reduce(x);
}
static constexpr int word_bits = sizeof(word) * 8;
static word modulus() {
return mod;
}
static word init(word w) {
return reduce(dword(w) * r2);
}
static void set_mod(word m) {
mod = m;
inv = mul_inv(mod);
r2 = -dword(mod) % mod;
}
static word reduce(dword x) {
word y = word(x >> word_bits) - word((dword(word(x) * inv) * mod) >> word_bits);
return sword(y) < 0 ? y + mod : y;
}
static word mul_inv(word n, int e = 6, word x = 1) {
return !e ? x : mul_inv(n, e - 1, x * (2 - x * n));
}
static word mod, inv, r2;
word x;
};
using uint128_t = __uint128_t;
using Mod64 = UnsafeMod< uint64_t, uint128_t, int64_t >;
template<> uint64_t Mod64::mod = 0;
template<> uint64_t Mod64::inv = 0;
template<> uint64_t Mod64::r2 = 0;
using Mod32 = UnsafeMod< uint32_t, uint64_t, int32_t >;
template<> uint32_t Mod32::mod = 0;
template<> uint32_t Mod32::inv = 0;
template<> uint32_t Mod32::r2 = 0;
bool miller_rabin_primality_test_uint64(uint64_t n) {
Mod64::set_mod(n);
uint64_t d = n - 1;
while(d % 2 == 0) d /= 2;
Mod64 e{1}, rev{n - 1};
// http://miller-rabin.appspot.com/ < 2^64
for(uint64_t a : {2, 325, 9375, 28178, 450775, 9780504, 1795265022}) {
if(n <= a) break;
uint64_t t = d;
Mod64 y = Mod64(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 miller_rabin_primality_test_uint32(uint32_t n) {
Mod32::set_mod(n);
uint32_t d = n - 1;
while(d % 2 == 0) d /= 2;
Mod32 e{1}, rev{n - 1};
for(uint32_t a : {2, 7, 61}) {
if(n <= a) break;
uint32_t t = d;
Mod32 y = Mod32(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(uint64_t n) {
if(n == 2) return true;
if(n == 1 || n % 2 == 0) return false;
if(n < uint64_t(1) << 31) return miller_rabin_primality_test_uint32(n);
return miller_rabin_primality_test_uint64(n);
}
uint64_t pollard_rho(uint64_t n) {
if(is_prime(n)) return n;
if(n % 2 == 0) return 2;
Mod64::set_mod(n);
uint64_t d;
Mod64 one{1};
for(Mod64 c{one};; c += one) {
Mod64 x{2}, y{2};
do {
x = x * x + c;
y = y * y + c;
y = y * y + c;
d = __gcd((x - y).get(), n);
} while(d == 1);
if(d < n) return d;
}
assert(0);
}
vector< uint64_t > prime_factor(uint64_t n) {
if(n <= 1) return {};
uint64_t p = pollard_rho(n);
if(p == n) return {p};
auto l = prime_factor(p);
auto r = prime_factor(n / p);
copy(begin(r), end(r), back_inserter(l));
return l;
}
};
int main() {
INT(tt);
while(tt--) {
INT(n);
VEC(ll,a,n);
vl v;
rep(i,n) {
auto ret = FastPrimeFactorization::prime_factor(a[i]);
for(auto &p:ret) {
v.emplace_back(p);
}
}
sort(all(v));
int flg = 1;
int l = 0;
rep(i,1,v.size()) {
if(v[i] != v[i-1]) {
if((i - l) % 2) {
flg = 0;
break;
}
else l = i;
}
}
if((v.size()-l) % 2) flg = 0;
cout << (flg ? "Yes":"No") << '\n';
}
}