Contest Duration: ~ (local time) (120 minutes)

Submission #3837973

Source Code Expand

Copy
```#include <bits/stdc++.h>
#include <sys/time.h>
using namespace std;

#define rep(i,n) for(long long i = 0; i < (long long)(n); i++)
#define repi(i,a,b) for(long long i = (long long)(a); i < (long long)(b); i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template<class T1, class T2> bool chmin(T1 &a, T2 b) { return b < a && (a = b, true); }
template<class T1, class T2> bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

using ll = long long; using vll = vector<ll>; using vvll = vector<vll>; using P = pair<ll, ll>;
ll ugauss(ll a, ll b) { if (!a) return 0; if (a>0^b>0) return a/b; else return (a+(a>0?-1:1))/b+1; }
ll lgauss(ll a, ll b) { if (!a) return 0; if (a>0^b>0) return (a+(a>0?-1:1))/b-1; else return a/b; }
template <typename T, typename U> ostream &operator<<(ostream &o, const pair<T, U> &v) {  o << "(" << v.first << ", " << v.second << ")"; return o; }
template<size_t...> struct seq{}; template<size_t N, size_t... Is> struct gen_seq : gen_seq<N-1, N-1, Is...>{}; template<size_t... Is> struct gen_seq<0, Is...> : seq<Is...>{};
template<class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch,Tr>& os, Tuple const& t, seq<Is...>){ using s = int[]; (void)s{0, (void(os << (Is == 0? "" : ", ") << get<Is>(t)), 0)...}; }
template<class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr>& os, tuple<Args...> const& t) -> basic_ostream<Ch, Tr>& { os << "("; print_tuple(os, t, gen_seq<sizeof...(Args)>()); return os << ")"; }
ostream &operator<<(ostream &o, const vvll &v) { rep(i, v.size()) { rep(j, v[i].size()) o << v[i][j] << " "; o << endl; } return o; }
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) { o << '['; rep(i, v.size()) o << v[i] << (i != v.size()-1 ? ", " : ""); o << "]";  return o; }
template <typename T> ostream &operator<<(ostream &o, const deque<T> &v) { o << '['; rep(i, v.size()) o << v[i] << (i != v.size()-1 ? ", " : ""); o << "]";  return o; }
template <typename T>  ostream &operator<<(ostream &o, const set<T> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]";  return o; }
template <typename T>  ostream &operator<<(ostream &o, const unordered_set<T> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]";  return o; }
template <typename T, typename U>  ostream &operator<<(ostream &o, const map<T, U> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it << (next(it) != m.end() ? ", " : ""); o << "]";  return o; }
template <typename T, typename U, typename V>  ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) { o << '['; for (auto it = m.begin(); it != m.end(); it++) o << *it; o << "]";  return o; }
vector<int> range(const int x, const int y) { vector<int> v(y - x + 1); iota(v.begin(), v.end(), x); return v; }
template <typename T> istream& operator>>(istream& i, vector<T>& o) { rep(j, o.size()) i >> o[j]; return i;}
template <typename T, typename S, typename U> ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.top(); tmp.pop(); o << x << " ";} return o; }
template <typename T> ostream &operator<<(ostream &o, const queue<T> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.front(); tmp.pop(); o << x << " ";} return o; }
template <typename T> ostream &operator<<(ostream &o, const stack<T> &v) { auto tmp = v; while (tmp.size()) { auto x = tmp.top(); tmp.pop(); o << x << " ";} return o; }
template <typename T> unordered_map<T, ll> counter(vector<T> vec){unordered_map<T, ll> ret; for (auto&& x : vec) ret[x]++; return ret;};
void vizGraph(vvll& g, int mode = 0, string filename = "out.png") { ofstream ofs("./out.dot"); ofs << "digraph graph_name {" << endl; set<P> memo; rep(i, g.size())  rep(j, g[i].size()) { if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i)))) continue; memo.insert(P(i, g[i][j])); ofs << "    " << i << " -> " << g[i][j] << (mode ? " [arrowhead = none]" : "")<< endl;  } ofs << "}" << endl; ofs.close(); system(((string)"dot -T png out.dot >" + filename).c_str()); }
struct timeval start; double sec() { struct timeval tv; gettimeofday(&tv, NULL); return (tv.tv_sec - start.tv_sec) + (tv.tv_usec - start.tv_usec) * 1e-6; }
size_t random_seed; struct init_{init_(){ ios::sync_with_stdio(false); cin.tie(0); gettimeofday(&start, NULL); struct timeval myTime; struct tm *time_st; gettimeofday(&myTime, NULL); time_st = localtime(&myTime.tv_sec); srand(myTime.tv_usec); random_seed = RAND_MAX / 2 + rand() / 2; }} init__;
#define ldout fixed << setprecision(40)

#define EPS (double)1e-14
#define INF (ll)1e18
#define mo  (ll)(1e9+7)
// 素数の個数はO(n / log n)

/**********************************************************/
// 素数テーブルの作成
/**********************************************************/
// 素数テーブル構築: O(n log n)
#define MAX_NUM 20000000
ll prime_size = -1;
bool is_prime[MAX_NUM];
vector<ll> primes;      // 素数リスト
void sieve_of_atkin(ll N) {
ll sqrtN = sqrt(N);
int n;
for (int z = 1; z <= 5; z += 4) {
for (int y = z; y <= sqrtN; y += 6) {
for (int x = 1; x <= sqrtN && (n = 4*x*x+y*y) <= N; ++x)
is_prime[n] = !is_prime[n];
for (int x = y+1; x <= sqrtN && (n = 3*x*x-y*y) <= N; x += 2)
is_prime[n] = !is_prime[n];
}
}
for (int z = 2; z <= 4; z += 2) {
for (int y = z; y <= sqrtN; y += 6) {
for (int x = 1; x <= sqrtN && (n = 3*x*x+y*y) <= N; x += 2)
is_prime[n] = !is_prime[n];
for (int x = y+1; x <= sqrtN && (n = 3*x*x-y*y) <= N; x += 2)
is_prime[n] = !is_prime[n];
}
}
for (int y = 3; y <= sqrtN; y += 6) {
for (int z = 1; z <= 2; ++z) {
for (int x = z; x <= sqrtN && (n = 4*x*x+y*y) <= N; x += 3)
is_prime[n] = !is_prime[n];
}
}
for (int n = 5; n <= sqrtN; ++n)
if (is_prime[n])
for (int k = n*n; k <= N; k+=n*n)
is_prime[k] = false;
is_prime[2] = is_prime[3] = true;
}

void sieve_of_eratosthenes(ll n) {
for (ll i = 2; i < n; ++i)
is_prime[i] = true;
for (ll i = 2; i*i < n; ++i)
if (is_prime[i])
for (ll j = i*i; j < n; j+=i)
is_prime[j] = false;
for (ll i = 0; i < n; i++)
if (is_prime[i])
primes.push_back(i);
}

// n以下の素数リストを作成する
//
// 素数はn個でも、n^2までの素因数分解ができる！
// よほどのことがなければn=1e6+10とかを確保すれば十分。
//
// 1e7は割とMLEするので注意
void constructPrime(ll n) {
assert(n < MAX_NUM);
prime_size = n;
#if 1
sieve_of_atkin(n);
#else
sieve_of_eratosthenes(n);
#endif
primes.reserve(1.2*n*log(n)); // 素数定理よりn>100でOK
rep(i, n) if (is_prime[i]) {
primes.pb(i);
}
}

/**********************************************************/
// 以下はよく行う処理のテンプレート
// そのままは大抵使えないので、改造するつもりで。
/**********************************************************/
// 素因数分解
//
// 小さい素数から見ていって、割れたら割って素因数リストに追加する
// 残ったnが素数リストよりも大きければ、そのnは素数だと見なして返す。
unordered_map<ll, ll> factorize(ll n) {
if (n <= 1) return unordered_map<ll, ll>();
unordered_map<ll, ll> divisors_list;

ll prime;
for (ll i = 0; (prime = primes[i]) && n >= prime * prime; )
if (n % prime)
i++;
else
divisors_list[prime]++, n /= prime;
if (n != 1)
divisors_list[n]++;
return divisors_list;
}

// [0, n]の範囲を全て素因数分解する。「飛び飛びの」高速化。結構速い。
// n < 1,000,000で150ms
// n < 10,000,000で1000ms
//
// 配列rem[i]は、初めiが入っている。
// 素数pを下から見るが、rem[i]を全て見る必要はなく、rem[p*i]だけでいい。
vector<unordered_map<ll, ll>> factorizeRange(ll n) {
vector<unordered_map<ll, ll>> fact(n+1);

vector<ll> rem(n+1); rep(i, n+1) rem[i] = i;
for (auto x : primes) for (ll i = x; i <= n; i += x)
while (rem[i] % x == 0)
rem[i] /= x, fact[i][x]++;
return fact;
}

// lcm(a)
// a[i] < 1e7
unordered_map<ll, ll> lcmSmall(set<ll>& a) {
if (!a.size()) return unordered_map<ll, ll>();

ll n = *(prev(a.end()));
vector<ll> rem(n+1);
rep(i, n+1) rem[i] = i;
unordered_map<ll, ll> ret;
for (auto x : primes) {
ll max_c = 0;
for (ll i = x; i <= n; i += x) if (a.count(i)) {
ll c = 0;
while (rem[i] % x == 0)
rem[i] /= x, c++;
chmax(max_c, c);
}
if (max_c)
ret[x] = max_c;
}
return ret;
}

// lcm(a)
// a[i]>1e7
unordered_map<ll, ll> lcmLarge(set<ll>& a) {
if (!a.size()) return unordered_map<ll, ll>();

unordered_map<ll, ll> ret;
for (auto n : a) {
auto d = factorize(n);
for (auto x : d)
chmax(ret[x.fi], x.se);
}
return ret;
}

// 約数を全列挙する。
//
// 約数を試し割りするより、n=1000000で4倍くらい早い。
vector<ll> divisors(ll n) {
vector<ll> divisors_list;

auto counter = factorize(n);
divisors_list.push_back(1);
for (auto x : counter) {
ll tmp_size = divisors_list.size();
ll p = 1;
for (ll i = 0; i < x.second; i++) {
p *= x.first;
for (ll j = 0; j < tmp_size; j++)
divisors_list.push_back(divisors_list[j] * p);
}
}
return divisors_list;
}

ll getDivisorsNum(ll n) {
unordered_map<ll, ll> divisors_list = factorize(n);
map<ll, ll> num;
rep(i, divisors_list.size())
num[divisors_list[i]]++;
ll p = 1;
for (auto x : num)
p *= x.second + 1;
return p;
}

/**********************************************************/
// 前処理なしの素数判定
/**********************************************************/
using u64 = uint32_t;
using u128 = uint64_t;
u128 mul(u64 a, u64 b, u64 m) { return u128(a) * b % m; };
bool isPrime(unsigned long long n) {
if (n <= 1) return false;
if (n == 2) return true;
static mt19937 mt(time(NULL));
u64 s = n - 1;
int e = 0;
for (; s % 2 == 0; s /= 2) e++;
for (int ii = 0; ii < 8; ii++) {
u64 x = std::uniform_int_distribution<u64>(2, n - 1)(mt);
u64 r = 1;
for (u64 i = s; i > 0; i >>= 1, x = mul(x, x, n)) {
if (i & 1) r = mul(r, x, n);
}
if (r == 1) continue;
for (int i = 1; i < e && r != n - 1; i++) {
r = mul(r, r, n);
}
if (r != n - 1) return false;
}
return true;
}

// O(n^0.25)
// ローのアルゴリズム
// 計算結果はrho_retに保存される
using ull = unsigned long long;
map<ull,int> rho_ret; // {p, k}, pの素因数がk個存在
ull find_factor(ull z) {
if (!(z&1)) return 2;
ull c = rand() % z, x = 2, y = 2, d = 1;
while (d == 1) {
ull tp = (mul(y,y,z) + c) % z;
y = (mul(tp,tp,z) + c) % z;
x = (mul(x,x,z) + c) % z;
d = __gcd(x>y ? x-y : y-x, z);
}
return d;
}
void rhofact_rec(ull z) {
if (z==1) return;
if (isPrime(z)) { rho_ret[z]++; return; }
while(1) {
ull f = find_factor(z);
if (f != z) {
rhofact_rec(f);
rhofact_rec(z/f);
break;
}
}
}
void rho(ull z) {
rho_ret.clear();
rhofact_rec(z);
}

// ガウス素数＝複素数の素数判定
bool isGaussianPrime(ll a, ll b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (a == 0) return b % 4 == 3 && is_prime[b];
if (b == 0) return a % 4 == 3 && is_prime[a];
return is_prime[a*a+b*b];
}

// 区間篩
// O( n log n )．
const ll N = 100000000; // MAXPRIME
const ll M = 10000;     // SQRT(N)
const ll K = 6000000;   // NUMBER OF PRIMES, CHOOSE 9/8 * N / LOG(N)
vector<ll> iterativeSieve() {
static ll p[K], table[M];
for (ll i = 2; i < M; ++i) p[i] = i;
for (ll i = 2; i*i < M; ++i)
if (p[i])
for (ll j = i*i; j < M; j += i)
p[j] = 0;
p[0] = p[1] = 0;
ll num = remove(p, p+M, 0) - p;
for (ll m = M; m < N; m += M) {
for (ll x = m; x < m+M; ++x)
table[x-m] = x;
for (ll i = 0, j; p[i]*p[i] < m+M; ++i) {
if (p[i] >= m)          j = p[i] * p[i];
else if (m % p[i] == 0) j = m;
else                    j = m - (m % p[i]) + p[i];
for (; j < m+M; j += p[i]) table[j-m] = 0;
}
num = remove_copy(table, table+M, p+num, 0) - p;
}
return vector<ll>(p, p+num);
}

int main(void) {
constructPrime(1e7);
ll n, p; cin >> n >> p;

auto d = factorize(p);
ll ret = 1;
for (auto x : d) {
rep(i, x.se / n) {
ret *= x.fi;
}
}
cout << ret << endl;

return 0;
}
```

#### Submission Info

Submission Time 2018-12-22 21:02:53+0900 C - Product and GCD hamko C++14 (GCC 5.4.1) 300 13685 Byte AC 47 ms 19708 KB

#### Compile Error

```./Main.cpp: In function ‘void vizGraph(vvll&, int, std::string)’:
./Main.cpp:38:478: warning: ignoring return value of ‘int system(const char*)’, declared with attribute warn_unused_result [-Wunused-result]
void vizGraph(vvll& g, int mode = 0, string filename = "out.png") { ofstream ofs("./out.dot"); ofs << "digraph graph_name {" << endl; set<P> memo; rep(i, g.size())  rep(j, g[i].size()) { if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i)))) continue; memo.insert(P(i, g[i][j])); ofs << "    " << i << " -> " << g[i][j] << (mode ? " [arrowhead = none]" : "")<< endl;  } ofs << "}" << endl; ofs.close(); system(((string)"dot -T png out.dot >" + filename).c_str()); }
...```

#### Judge Result

Set Name Score / Max Score Test Cases
Sample 0 / 0 sample1.txt, sample2.txt, sample3.txt, sample4.txt
All 300 / 300 sample1.txt, sample2.txt, sample3.txt, sample4.txt, 1.txt, 10.txt, 11.txt, 12.txt, 13.txt, 14.txt, 15.txt, 16.txt, 17.txt, 18.txt, 19.txt, 2.txt, 20.txt, 21.txt, 22.txt, 23.txt, 24.txt, 25.txt, 26.txt, 3.txt, 4.txt, 5.txt, 6.txt, 7.txt, 8.txt, 9.txt, sample1.txt, sample2.txt, sample3.txt, sample4.txt
Case Name Status Exec Time Memory
1.txt 47 ms 19708 KB
10.txt 43 ms 19324 KB
11.txt 43 ms 18940 KB
12.txt 44 ms 19324 KB
13.txt 43 ms 19068 KB
14.txt 43 ms 18300 KB
15.txt 43 ms 19196 KB
16.txt 43 ms 18300 KB
17.txt 43 ms 18684 KB
18.txt 43 ms 17916 KB
19.txt 43 ms 18556 KB
2.txt 44 ms 18684 KB
20.txt 43 ms 19068 KB
21.txt 43 ms 18812 KB
22.txt 43 ms 19452 KB
23.txt 44 ms 18428 KB
24.txt 43 ms 18300 KB
25.txt 43 ms 19068 KB
26.txt 43 ms 18556 KB
3.txt 43 ms 19068 KB
4.txt 43 ms 18172 KB
5.txt 43 ms 18044 KB
6.txt 43 ms 19196 KB
7.txt 44 ms 18556 KB
8.txt 43 ms 18044 KB
9.txt 43 ms 19452 KB
sample1.txt 43 ms 18940 KB
sample2.txt 43 ms 18172 KB
sample3.txt 43 ms 17788 KB
sample4.txt 44 ms 19580 KB