text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
pair<int, int> arr[n];
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
if (n <= 2)
cout << n << endl;
else {
int cnt = 2;
int prev = arr[0].first;
for (int i = 1; i < n - 1; i++) {
if (arr[i].first - arr[i].second > prev) {
cnt++;
prev = arr[i].first;
} else if (arr[i].first + arr[i].second < arr[i + 1].first) {
cnt++;
prev = arr[i].first + arr[i].second;
} else
prev = arr[i].first;
}
cout << cnt << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b;
vector<pair<int, int>> tree;
tree.assign(n, make_pair(0, 0));
for (int i = 0; i < n; i++) cin >> tree[i].first >> tree[i].second;
int ans[n], left[n], right[n], stay[n];
ans[0] = 1;
left[0] = 1;
right[0] = 1;
stay[0] = 1;
for (int i = 1; i < n; i++) {
stay[i] = max(stay[i - 1], left[i - 1]);
if (tree[i].first > tree[i - 1].first + tree[i - 1].second)
stay[i] = max(stay[i], right[i - 1]);
if (i < n - 1 && tree[i + 1].first > tree[i].first + tree[i].second) {
right[i] = max(left[i - 1], stay[i - 1]);
right[i] = max(right[i], right[i - 1]);
right[i] += 1;
} else if (i == n - 1) {
right[i] = max(left[i - 1], stay[i - 1]);
right[i] = max(right[i], right[i - 1]);
right[i] += 1;
} else {
right[i] = -1000000;
}
int temp1 = -1000000;
if (tree[i].first - tree[i].second > tree[i - 1].first) {
temp1 = max(left[i - 1], stay[i - 1]);
}
if (tree[i].first - tree[i].second >
tree[i - 1].first + tree[i - 1].second) {
temp1 = max(temp1, right[i - 1]);
}
if (temp1 == -1000000)
left[i] = temp1;
else
left[i] = temp1 + 1;
ans[i] = max(left[i], right[i]);
ans[i] = max(ans[i], stay[i]);
}
cout << ans[n - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int a = 0;
cin >> a;
vector<pair<int, int>> x;
int b, c;
for (int i = 0; i < a; i++) {
cin >> b >> c;
x.push_back(make_pair(b, c));
}
if (a < 3)
cout << a;
else {
int count = 2;
int occ = x[0].first;
for (int i = 1; i < a - 1; i++) {
if ((x[i].first - x[i].second > occ)) {
count++;
occ = x[i].first;
} else if (x[i].first + x[i].second < x[i + 1].first) {
occ = x[i].first + x[i].second;
count++;
} else {
occ = x[i].first;
}
}
cout << count;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
int main() {
int n, co = 1;
std::vector<pair<long long, long long>> v;
cin >> n;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
v.push_back(make_pair(a, b));
}
for (int i = 1; i < n; i++) {
if (v[i].first - v[i].second > v[i - 1].first) {
co++;
} else if (v[i].first + v[i].second < v[i + 1].first) {
v[i].first = v[i].first + v[i].second;
co++;
} else if (i == n - 1) {
co++;
}
}
cout << co;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int dirX[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dirY[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const long long MOD = 998244353;
const long long N = 1e5 + 7;
const long long inf = 1e18 + 5;
long long t, n, m, a, b, k, c = 0, d;
long long x11, x22, y11, y22;
long long dp[N][3];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
vector<pair<long long, long long> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
dp[0][0] = 0;
dp[0][1] = 1;
dp[0][2] = (v[0].first + v[0].second < v[1].first) ? 1 : 0;
for (int i = 1; i < n; i++) {
dp[i][0] = max({dp[i - 1][0], dp[i - 1][1], dp[i - 1][2]});
dp[i][1] = dp[i][0];
dp[i][2] = dp[i][0];
if (v[i].first - v[i].second > v[i - 1].first) {
dp[i][1] = 1 + max({dp[i - 1][1], dp[i - 1][0]});
}
if (v[i].first - v[i].second > v[i - 1].first + v[i - 1].second) {
dp[i][1] = max({dp[i - 1][2] + 1, dp[i - 1][1], dp[i - 1][0]});
}
if (i == n - 1 ||
(i < n - 1 && v[i + 1].first > v[i].second + v[i].first)) {
dp[i][2]++;
}
}
cout << max({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2]});
}
|
#include <bits/stdc++.h>
using namespace std;
int knock(vector<long long int> &positions, vector<long long int> &heights,
int n) {
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = 1;
dp[1][0] = 0;
dp[2][0] = positions[0] + heights[0] < positions[1] ? 1 : 0;
for (int i = 1; i < n; i++) {
if (positions[i] - heights[i] > positions[i - 1]) {
dp[0][i] = max(dp[0][i - 1], dp[1][i - 1]) + 1;
}
if (positions[i] - heights[i] > positions[i - 1] + heights[i - 1]) {
dp[0][i] = max(dp[0][i], dp[2][i - 1] + 1);
}
dp[1][i] = max(dp[0][i - 1], max(dp[1][i - 1], dp[2][i - 1]));
if (i == n - 1 || (positions[i] + heights[i] < positions[i + 1])) {
dp[2][i] = max(dp[0][i - 1], max(dp[1][i - 1], dp[2][i - 1])) + 1;
}
}
return max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
}
int main() {
int n;
cin >> n;
vector<long long int> positions, heights;
for (int i = 0; i < n; i++) {
long long int x, h;
cin >> x >> h;
positions.push_back(x);
heights.push_back(h);
}
cout << knock(positions, heights, n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[100004][3], height[100003], pos[100004];
int morningWood(int index, int dir) {
if (index >= n) return 0;
int &d = dp[index][dir];
if (d != -1) return d;
int currOccupy = (dir <= 1) ? pos[index] : pos[index] + height[index];
d = morningWood(index + 1, 0);
if (currOccupy < pos[index + 1] - height[index + 1])
d = max(d, 1 + morningWood(index + 1, 1));
if (index + 2 < n && pos[index + 1] + height[index + 1] < pos[index + 2])
d = max(d, 1 + morningWood(index + 1, 2));
if (index + 2 >= n) d = max(d, 1 + morningWood(index + 1, 2));
return d;
}
int main() {
cin >> n;
for (int i = (int)0; i < int(n); i++) cin >> pos[i] >> height[i];
memset(dp, -1, sizeof(dp));
;
cout << max(morningWood(0, 0), max(morningWood(0, 1), morningWood(0, 2)))
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
long long int x, y;
cin >> x >> y;
v.push_back({x, y});
}
long long int s = v[0].first - v[0].second, e = v[0].first;
long long int t = 2;
if (n == 1)
t = 1;
else {
for (long long int i = 1; i < n - 1; i++) {
if (v[i].first - v[i].second > e) {
t++;
e = v[i].first;
} else if (v[i].first + v[i].second < v[i + 1].first) {
t++;
e = v[i].first + v[i].second;
} else
e = v[i].first;
}
}
cout << t << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x[100000][2];
cin >> n;
if (n == 1) {
cout << 1;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> x[i][0] >> x[i][1];
}
int count = 0;
for (int i = 1; i < n - 1; i++) {
if (x[i][0] - x[i][1] > x[i - 1][0]) {
count++;
} else if (x[i][1] + x[i][0] < x[i + 1][0]) {
count++;
x[i][0] = x[i][1] + x[i][0];
}
}
cout << count + 2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<pair<long long, long long> > A(n);
for (long long i = 0; i < n; i++) {
cin >> A[i].first >> A[i].second;
}
long long sol = 1;
vector<long long> dp(n);
for (long long i = 0; i < n - 1; i++) {
if (i == 0) {
dp[i] = A[i].first;
sol++;
} else {
if (dp[i - 1] < (A[i].first - A[i].second)) {
dp[i] = A[i].first;
sol++;
} else if ((A[i].first + A[i].second) < A[i + 1].first) {
dp[i] = A[i].first + A[i].second;
sol++;
} else {
dp[i] = A[i].first;
}
}
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> x[100005];
int main() {
int n, ans;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x[i].first >> x[i].second;
}
sort(x, x + n);
if (n == 1)
ans = 1;
else if (n >= 2)
ans = 2;
for (int i = 1; i < n - 1; ++i) {
if (x[i].second < x[i].first - x[i - 1].first) {
ans++;
} else if (x[i].second < x[i + 1].first - x[i].first) {
ans++;
x[i].first += x[i].second;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[100001][3], a[100001], h[100001];
int main() {
int n, i;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i] >> h[i];
if (n == 1) {
cout << 1 << endl;
return 0;
}
dp[0][2] = 0;
dp[0][0] = 1;
if (a[1] - h[0] > a[0]) dp[0][1] = 1;
for (i = 1; i < n; i++) {
dp[i][2] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][2]));
if (a[i - 1] + h[i] < a[i]) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][2]) + 1;
if (a[i - 1] + h[i - 1] + h[i] < a[i])
dp[i][0] = max(dp[i][0], dp[i - 1][1] + 1);
}
if (i == n - 1 || a[i] + h[i] < a[i + 1])
dp[i][1] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][2])) + 1;
}
cout << dp[n - 1][1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int kq, n, x[100010], h[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i] >> h[i];
if (n == 1) {
cout << 1;
return 0;
}
if (n == 2) {
cout << 2;
return 0;
}
kq = 2;
for (int i = 2; i < n; i++) {
if (x[i - 1] + h[i] < x[i])
kq++;
else if (x[i] + h[i] < x[i + 1]) {
kq++;
x[i] += h[i];
}
}
cout << kq;
return 0;
}
|
#include <bits/stdc++.h>
int x[100000], h[100000];
int main() {
int N, i, result;
scanf("%d\n", &N);
for (i = 0; i < N; i++) scanf("%d %d\n", x + i, h + i);
result = 0;
for (i = 0; i < N; i++) {
if (i == 0 || x[i] - h[i] > x[i - 1])
result++;
else if (i + 1 == N || x[i] + h[i] < x[i + 1]) {
x[i] += h[i];
result++;
}
}
printf("%d\n", result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[110000][3];
long long dist[110000], ht[110000];
int main() {
int n;
cin >> n;
dp[0][0] = dp[0][1] = dp[0][2] = 0;
dist[0] = -1e10;
ht[0] = 0;
dist[n + 1] = 1e10;
ht[n + 1] = 0;
for (int i = 1; i <= n; i++) cin >> dist[i] >> ht[i];
for (int i = 1; i <= n; i++) {
int mx = max(dp[i - 1][0], dp[i - 1][1]);
mx = max(mx, dp[i - 1][2]);
if (dist[i] + ht[i] < dist[i + 1])
dp[i][2] = mx + 1;
else if (dist[i] + ht[i] >= dist[i + 1])
dp[i][2] = 0;
dp[i][1] = mx;
if (dist[i] - ht[i] > dist[i - 1])
dp[i][0] = max(dp[i - 1][1], dp[i - 1][0]) + 1;
if (dist[i] - ht[i] > dist[i - 1] + ht[i - 1])
dp[i][0] = max(dp[i][0], dp[i - 1][2] + 1);
}
int ans = max(dp[n][0], dp[n][1]);
cout << max(ans, dp[n][2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
int x[n], h[n];
for (int i = 0; i < n; ++i) cin >> x[i] >> h[i];
vector<vector<int>> dp(3, vector<int>(n, 0));
dp[0][0] = 1, dp[1][0] = 0, dp[2][0] = 0;
if ((n > 1 && x[0] + h[0] < x[1] || n == 1)) dp[2][0] = 1;
for (int i = 1; i < n; ++i) {
if (x[i] - h[i] > x[i - 1]) {
if (x[i - 1] + h[i - 1] < x[i] - h[i])
dp[0][i] = 1 + max({dp[0][i - 1], dp[1][i - 1], dp[2][i - 1]});
else
dp[0][i] = 1 + max(dp[0][i - 1], dp[1][i - 1]);
}
dp[1][i] = max({dp[0][i - 1], dp[1][i - 1], dp[2][i - 1]});
if (i == n - 1 || x[i] + h[i] < x[i + 1])
dp[2][i] = 1 + max({dp[0][i - 1], dp[1][i - 1], dp[2][i - 1]});
}
cout << max({dp[0][n - 1], dp[1][n - 1], dp[2][n - 1]});
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
if (n <= 2) {
cout << n << endl;
return 0;
}
int cnt = 2;
for (int i = 1; i < n - 1; i++) {
if (a[i - 1] < a[i] - b[i]) {
cnt++;
} else if (a[i + 1] > a[i] + b[i]) {
cnt++;
a[i] = a[i] + b[i];
}
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void sarray(T *st, T *nd) {
while (st < nd) cin >> *st++;
}
template <class T>
inline void parray(T *st, T *nd) {
while (st < nd) cout << *st++ << endl;
}
long long int tmp, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
vector<pair<int, int>> v;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
v.emplace_back(make_pair(a, b));
}
if (n == 1)
cout << 1 << endl;
else if (n == 2)
cout << 2 << endl;
else {
ans = 2;
for (int i = 1; i < n - 1; i++) {
if (v[i].first - v[i - 1].first > v[i].second)
ans++;
else if (v[i + 1].first - v[i].first > v[i].second) {
ans++;
v[i].first += v[i].second;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int pos[n], ht[n];
long long int dp[n][3];
for (int i = 0; i < n; i++) {
cin >> pos[i] >> ht[i];
}
dp[0][0] = 1;
dp[0][1] = 1;
dp[0][2] = 0;
for (int i = 1; i < n; i++) {
dp[i][0] = 0;
dp[i][1] = 0;
dp[i][2] = 0;
if (pos[i - 1] < pos[i] - ht[i])
dp[i][0] = max(dp[i][0], max(1 + dp[i - 1][0], 1 + dp[i - 1][2]));
if (pos[i - 1] + ht[i - 1] < pos[i] - ht[i])
dp[i][0] = max(dp[i][0], 1 + dp[i - 1][1]);
if (pos[i - 1] < pos[i])
dp[i][1] = max(dp[i][1], max(1 + dp[i - 1][0], 1 + dp[i - 1][2]));
if (pos[i - 1] + ht[i - 1] < pos[i])
dp[i][1] = max(dp[i][1], 1 + dp[i - 1][1]);
if (pos[i - 1] < pos[i])
dp[i][2] = max(dp[i][2], max(dp[i - 1][0], dp[i - 1][2]));
if (pos[i - 1] + ht[i - 1] < pos[i]) dp[i][2] = max(dp[i][2], dp[i - 1][1]);
}
cout << max(dp[n - 1][0], max(dp[n - 1][1], dp[n - 1][2]));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, c = 2;
cin >> n;
int64_t X1, X2, x[n + 5], h[n + 5], S;
for (i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
X1 = x[0], X2 = x[n - 1];
if (n < 2) cout << n << endl, exit(0);
for (i = 1; i < n - 1; i++) {
if (x[i] - h[i] > X1)
c++;
else if (x[i + 1] - x[i] > h[i])
x[i] += h[i], c++;
X1 = x[i];
}
cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, x, h;
cin >> n;
vector<pair<long, long>> arr;
for (int i = 0; i < n; i++) {
cin >> x >> h;
arr.push_back({x, h});
}
long ans = 0, maxd = -3e9;
for (int i = 0; i < n; i++) {
long x = arr[i].first;
long h = arr[i].second;
if (x - h > maxd) {
maxd = x;
ans++;
continue;
}
if (i == n - 1) {
ans++;
continue;
}
if (x + h < arr[i + 1].first) {
ans++;
maxd = x + h;
continue;
}
maxd = x;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[100100][2], x[100100], h[100100], n;
long long int solve(long long int i, long long int st) {
if (i == n - 1) return 1;
if (dp[i][st] != -1) return dp[i][st];
long long int temp = LLONG_MIN;
if (st == 0) {
if (i == 0) {
temp = max(temp, 1 + solve(i + 1, 0));
} else {
if (h[i] < x[i] - x[i - 1]) {
temp = max(temp, 1 + solve(i + 1, 0));
} else {
temp = max(temp, solve(i + 1, 0));
}
}
if (h[i] < x[i + 1] - x[i])
temp = max(temp, 1 + solve(i + 1, 1));
else
temp = max(temp, solve(i + 1, 0));
} else {
if (h[i] < x[i] - x[i - 1] - h[i - 1])
temp = max(temp, 1 + solve(i + 1, 0));
else
temp = max(temp, solve(i + 1, 0));
if (h[i] < x[i + 1] - x[i])
temp = max(temp, 1 + solve(i + 1, 1));
else
temp = max(temp, solve(i + 1, 0));
}
return dp[i][st] = temp;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int i;
memset(dp, -1, sizeof dp);
cin >> n;
for (i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
cout << solve(0, 0) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long x[N];
long long h[N];
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> x[i] >> h[i];
}
int ret = 0;
int last = (long long)INT_MIN;
for (int i = 0; i < n; i++) {
if (x[i] - last > h[i]) {
ret++;
last = x[i];
} else {
if (i + 1 < n) {
if (x[i] + h[i] < x[i + 1]) {
ret++;
last = x[i] + h[i];
} else
last = x[i];
} else
ret++;
}
}
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long vis[100001] = {0};
long long col[100000] = {0};
vector<vector<long long> > v(50);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, i, j;
cin >> n;
vector<pair<int, int> > v;
for (i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
if (n == 1) {
cout << "1";
return 0;
}
if (n == 2) {
cout << "2";
return 0;
}
int c1 = 2;
long long max = v[0].first;
for (i = 1; i < n - 1; i++) {
if (v[i].first - max > v[i].second) {
c1++;
max = v[i].first;
} else if (v[i + 1].first - v[i].first > v[i].second) {
c1++;
max = v[i].second + v[i].first;
} else
max = v[i].first;
}
cout << c1;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[100001], h[100001];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &h[i]);
int cnt = 0;
for (int i = 2; i <= n - 1; i++)
if (x[i] - x[i - 1] > h[i])
cnt++;
else if (x[i + 1] - x[i] > h[i]) {
cnt++;
x[i] += h[i];
}
if (n == 1)
cnt = 1;
else
cnt += 2;
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mini(int a, int b) { return a < b ? a : b; }
unsigned long long lmini(unsigned long long a, unsigned long long b) {
return a < b ? a : b;
}
int maxi(int a, int b) { return a > b ? a : b; }
unsigned long long lmaxi(unsigned long long a, unsigned long long b) {
return a > b ? a : b;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
unsigned long long lgcd(unsigned long long a, unsigned long long b) {
if (b == 0) return a;
return lgcd(b, a % b);
}
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
unsigned long long llcm(unsigned long long a, unsigned long long b) {
return (b * (a / lgcd(a, b)));
}
int dp[100001], x[100005], h[100005], n;
int cal(int i, int l, int r) {
if (i >= n) return 0;
if (dp[i] != -1) return dp[i];
int a1 = 0, a2 = 0, a3 = 0, a4;
if (x[i] - h[i] > l) a1 = 1 + cal(i + 1, x[i], x[i + 2]);
if (x[i] + h[i] < r) a2 = 1 + cal(i + 1, x[i] + h[i], x[i + 2]);
a3 = cal(i + 1, x[i], x[i + 2]);
a4 = maxi(maxi(a1, a2), a3);
dp[i] = a4;
return a4;
}
int main() {
cin >> n;
int i, ans;
for (i = 0; i < n; i++) dp[i] = -1;
for (i = 0; i < n; i++) cin >> x[i] >> h[i];
x[n + 1] = x[n] = 1e18;
ans = cal(0, -1e18, x[1]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const double EPS = 1E-6;
const int INF = 2 * (1e+9) + 1;
const int MAXN = 3 * 100000001;
const int MOD = (1e+9) + 7;
int n;
pair<int, int> x[100100];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> x[i].first >> x[i].second;
}
sort(x, x + n);
int cnt = 1, r = 0;
for (int i = (1); i <= (n - 1); ++i) {
if (r && x[i - 1].first + x[i - 1].second >= x[i].first) {
r = 0;
} else if (r)
cnt++;
if (!r && x[i].first - x[i - 1].first > x[i].second) {
cnt++;
} else {
if (x[i].first - x[i - 1].first > x[i].second + x[i - 1].second) {
cnt++, r = 0;
} else {
r = 1;
}
}
}
if (r) cnt++;
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
pair<long long, long long> p;
map<long long, long long> mp;
set<long long> st;
deque<long long> dq;
priority_queue<long long> pq;
long long mn = INT_MAX, mx = INT_MIN;
long long n, m, tc, i, j, tmp, q, sum, cn, ans, res, pos, flag, l, x, k, dif;
string s, str;
long long pre = 1e15;
long long now = -1e17;
long long a[2000007], b[2000007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n >= 2)
ans = 2;
else
ans = 1;
for (i = 0; i < n; i++) cin >> a[i] >> b[i];
for (i = 1; i < n - 1; i++) {
if (a[i] - b[i] > a[i - 1])
ans++;
else if (a[i] + b[i] < a[i + 1]) {
a[i] += b[i];
ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using std::sort;
using std::swap;
using std::unique;
namespace fastIO {
static char buf[(1 << 19)], *p1 = buf + (1 << 19), *pend = buf + (1 << 19);
inline char nc() {
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, (1 << 19), stdin);
}
return *p1++;
}
inline long long read() {
long long x = 0, f = 1;
register char s = nc();
for (; !isdigit(s); s = nc())
if (s == '-') f = -1;
for (; isdigit(s); s = nc()) x = (x << 1) + (x << 3) + s - '0';
return x * f;
}
} // namespace fastIO
using namespace fastIO;
inline long long mabs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct IT {
long long p;
long long k;
IT(long long p = 0, long long k = 0) : p(p), k(k) {}
};
struct rec {
IT p[1001];
long long num;
void init(long long x) {
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
long long c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = IT(i, c);
}
}
if (x > 1) p[num++] = IT(x, 1);
}
IT query(long long x) {
for (long long i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return IT(x, 0);
}
} A[200], B[200];
long long n;
IT A1[3507], B1[3507], A2[3507], B2[3507];
long long pri[3507], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a);
swap(B, b);
swap(C, c);
}
if (c % b) puts("-1"), exit(0);
x2 = -c / b;
if ((C + B * x2) % A) puts("-1"), exit(0);
x1 = (-C - B * x2) / A;
}
inline void UN(rec &a1, rec &b1, rec &a2, rec &b2) {
num = 0;
for (long long i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (long long i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (long long i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (long long i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (long long i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (long long i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (long long i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (long long i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
long long flg1 = 0;
long long x1, x2;
for (long long i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) puts("-1"), exit(0);
continue;
}
long long g = gcd(a, gcd(-b, mabs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) puts("-1"), exit(0);
if (-c / a < 0) puts("-1"), exit(0);
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
inter(A, B, C, a, b, c, x1, x2);
flg1 = 1;
break;
}
if (C / A != c / a) puts("-1"), exit(0);
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
puts("-1"), exit(0);
}
inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (long long i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) puts("-1"), exit(0);
}
for (long long i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (long long i = 0; i < num; ++i) {
a1.p[i] = A1[i], b1.p[i] = B1[i];
}
a1.num = b1.num = num;
return;
}
long long g = exgcd(A, B, x1, x2);
if (C % g) puts("-1"), exit(0);
x1 *= -C / g, x2 *= -C / g;
long long tx = mabs(-B / g), ty = mabs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (long long i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (long long i = 0; i < num; ++i) {
a1.p[i] = A1[i], b1.p[i] = B1[i];
}
a1.num = b1.num = num;
}
const long long P = 1e9 + 7;
inline long long ksm(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % P;
x = x * x % P;
y >>= 1;
}
return ans;
}
signed main() {
n = read();
for (long long i = 1, a, b; i <= n; ++i) {
a = read();
b = read();
A[i].init(a);
B[i].init(b);
}
for (long long i = 2; i <= n; ++i) {
UN(A[1], B[1], A[i], B[i]);
}
long long ans = 1;
for (long long i = 0; i < A[1].num; ++i) {
ans = ans * 1ll * ksm(A[1].p[i].p, A[1].p[i].k) % P;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read(int f = 1, int x = 0, char ch = ' ') {
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f * x;
}
const int N = 1e2 + 5, M = 3e3 + 5, P = 1e9 + 7;
int n, m, a[N], b[N], p[M];
long long ca[M], cb[M], ans;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long exgcd(long long a, long long b, long long &x, long long &y,
long long d = 0) {
return b ? (d = exgcd(b, a % b, y, x), y -= a / b * x, d) : (x = 1, y = 0, a);
}
long long qpow(long long a, long long b) {
long long c = 1;
for (; b; b >>= 1, a = a * a % P)
if (b & 1) c = c * a % P;
return c;
}
int lg(int a, int b) {
int c = 0;
for (; b % a == 0; ++c, b /= a)
;
return c;
}
void work(int n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0)
for (p[++m] = i; n % i == 0; n /= i)
;
if (n != 1) p[++m] = n;
}
long long solve(long long A, long long B, long long C) {
if (!A) return 0;
if (!B) return C / A;
long long x, y, d;
exgcd(A, -B, x, y);
x *= C, y *= -C, x %= -B, x += -B, x %= -B, y = (C - A * x) / B;
if (y < 0) d = (-y + A - 1) / A, x += -B * d, y += A * d;
return x;
}
void work(int a, int b) {
bool fl1 = false, fl2 = false;
long long x, y, A, B, C;
for (int i = 1; i <= m; ++i) {
long long _A = cb[i], _B = -lg(p[i], b), _C = lg(p[i], a) - ca[i],
d = gcd(_A, -_B);
if (!_A && !_B)
(_C) ? (puts("-1"), exit(0)) : void();
else {
(_C % d) ? (puts("-1"), exit(0)) : void(), _A /= d, _B /= d, _C /= d;
if (fl2)
(_A * x + _B * y != _C) ? (puts("-1"), exit(0)) : void();
else if (!fl1)
fl1 = true, A = _A, B = _B, C = _C;
else if (_A == A && _B == B)
(_C != C) ? (puts("-1"), exit(0)) : void();
else {
long long a = _A * B - _B * A, b = _C * B - _B * C;
(b % a) ? (puts("-1"), exit(0)) : void(), x = b / a;
a = _B * A - B * _A, b = _C * A - C * _A;
(b % a) ? (puts("-1"), exit(0)) : void(), y = b / a;
fl2 = true, (x < 0 || y < 0) ? (puts("-1"), exit(0)) : void();
}
}
}
if (fl2)
for (int i = 1; i <= m; ++i) ca[i] += x * cb[i], cb[i] = 0;
else {
long long x = solve(A, B, C);
for (int i = 1; i <= m; ++i) ca[i] += x * cb[i], cb[i] *= -B;
}
}
int main() {
n = read(), ans = 1;
for (int i = 1; i <= n; ++i)
a[i] = read(), b[i] = read(), work(a[i]), work(b[i]);
sort(p + 1, p + 1 + m), m = unique(p + 1, p + 1 + m) - p - 1;
for (int i = 1; i <= m; ++i) ca[i] = lg(p[i], a[1]), cb[i] = lg(p[i], b[1]);
for (int i = 2; i <= n; ++i) work(a[i], b[i]);
for (int i = 1; i <= m; ++i) ans = ans * qpow(p[i], ca[i]) % P;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 105, mod = 1e9 + 7;
int n;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long ksm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
struct node {
vector<pair<long long, long long> > p;
node() { p.clear(); }
inline void in() {
int x = read();
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int k = 0;
while (x % i == 0) k++, x /= i;
p.push_back(make_pair(i, k));
}
if (x > 1) p.push_back(make_pair(x, 1));
}
inline void out() {
long long ans = 1;
for (auto o : p) ans = ans * ksm(o.first, o.second) % mod;
printf("%lld\n", ans);
}
inline friend node operator*(const node &x, const node &y) {
node z;
int i = 0, j = 0;
while (i < x.p.size() && j < y.p.size()) {
if (x.p[i].first == y.p[j].first)
z.p.push_back(make_pair(x.p[i].first, x.p[i].second + y.p[j].second)),
i++, j++;
else if (x.p[i].first < y.p[j].first)
z.p.push_back(x.p[i]), i++;
else
z.p.push_back(y.p[j]), j++;
}
while (i < x.p.size()) z.p.push_back(x.p[i]), i++;
while (j < y.p.size()) z.p.push_back(y.p[j]), j++;
return z;
}
inline friend bool operator%(const node &x, const node &y) {
for (int i = 0, j = 0; j < y.p.size(); i++, j++) {
while (i < x.p.size() && x.p[i].first != y.p[j].first) i++;
if (i == x.p.size() || x.p[i].second < y.p[j].second) return 1;
}
return 0;
}
inline friend node operator/(const node &x, const node &y) {
node z;
for (int i = 0, j = 0; i < x.p.size(); i++) {
if (j < y.p.size() && x.p[i].first == y.p[j].first) {
z.p.push_back(make_pair(x.p[i].first, x.p[i].second - y.p[j].second));
j++;
if (!z.p.back().second) z.p.pop_back();
} else
z.p.push_back(x.p[i]);
}
return z;
}
inline friend node operator&(const node &x, const node &y) {
node z;
for (int i = 0, j = 0; i < x.p.size(); i++) {
if (j < y.p.size() && x.p[i].first == y.p[j].first)
z.p.push_back(make_pair(x.p[i].first, x.p[i].second - y.p[j].second)),
j++;
else
z.p.push_back(x.p[i]);
}
return z;
}
inline friend bool operator|(const node &x, const node &y) {
if (!x.p.size()) return 0;
long long k = 0;
for (int i = 0, j = 0; i <= x.p.size(); i++, j++) {
while (j < y.p.size() && !y.p[j].second) j++;
if (i == x.p.size()) return j != y.p.size();
if (j == y.p.size()) return 1;
if (x.p[i].first != y.p[j].first || x.p[i].second % y.p[j].second)
return 1;
if (!i)
k = x.p[i].second / y.p[j].second;
else if ((x.p[i].second / y.p[j].second) != k)
return 1;
}
return 0;
}
inline friend node operator^(node x, long long y) {
for (auto &o : x.p) o.second = o.second * y;
return x;
}
inline friend node operator+(const node &x, const node &y) {
node z;
for (int i = 0; i < x.p.size(); i++)
z.p.push_back(make_pair(
x.p[i].first,
x.p[i].second * y.p[i].second / gcd(x.p[i].second, y.p[i].second)));
return z;
}
} a[N], b[N], c[N], A, B;
inline bool check(node x) {
for (int i = 1; i <= n; i++)
if ((x % a[i]) || ((x / a[i]) | b[i])) return 0;
return 1;
}
struct pro {
long long k, b, p;
inline pro(long long k = 0, long long b = 0, long long p = 0)
: k(k), b(b), p(p) {}
inline friend bool operator==(const pro &a, const pro &b) {
return a.k == b.k && a.b == b.b && a.p == b.p;
}
};
inline long long slove(pro x, pro y) {
long long a = x.b * y.p - x.p * y.b, b = x.k * y.p - x.p * y.k;
if (!b || (a % b)) puts("-1"), exit(0);
return a / b;
}
long long exgcd(long long a, long long b, long long &x, long long &y,
long long d = 0) {
return b ? (d = exgcd(b, a % b, y, x), y -= a / b * x, d) : (x = 1, y = 0, a);
}
inline bool merge(int o) {
vector<pro> v;
for (int i = 0; i < A.p.size(); i++) {
long long k1 = B.p[i].second, b1 = A.p[i].second, k2 = b[o].p[i].second,
b2 = a[o].p[i].second;
if (!k1 && !k2) {
if (b1 != b2) puts("-1"), exit(0);
continue;
}
if (!k1) {
if (b1 < b2 || (b1 - b2) % k2) puts("-1"), exit(0);
A = a[o] * (b[o] ^ ((b1 - b2) / k2));
return 0;
}
if (!k2) {
if (b2 < b1 || (b2 - b1) % k1) puts("-1"), exit(0);
A = A * (B ^ ((b2 - b1) / k1));
return 0;
}
long long d = gcd(k1, k2), g = b2 - b1;
if (g % d) puts("-1"), exit(0);
g /= d;
k1 /= d;
k2 /= d;
if (v.size()) {
if (v[0] == pro(k1, g, k2)) continue;
A = A * (B ^ slove(v[0], pro(k1, g, k2)));
return 0;
}
v.push_back(pro(k1, g, k2));
}
if (v.size()) {
long long k = v[0].k, b = v[0].b, p = v[0].p, x, y;
b = (b % p + p) % p;
exgcd(k, p, x, y);
x = (x * b % p + p) % p;
A = A * (B ^ x);
B = B + ::b[o];
}
return 1;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i].in(), b[i].in(), c[i] = a[i] * b[i];
for (int i = 1; i <= n; i++)
if (check(a[i])) return a[i].out(), 0;
for (int i = 1; i <= n; i++) {
if (c[i].p.size() != c[1].p.size()) puts("-1"), exit(0);
for (int j = 0; j < c[1].p.size(); j++)
if (c[i].p[j].first != c[1].p[j].first) puts("-1"), exit(0);
a[i] = c[i] & b[i];
b[i] = c[i] & a[i];
}
A = a[1];
B = b[1];
for (int i = 2; i <= n; i++)
if (!merge(i)) {
if (check(A)) return A.out(), 0;
puts("-1"), exit(0);
}
A.out();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
set<pair<int, int> > s;
vector<long long> p[110], k[110], b[110], ansa, ansp;
int pr[1000010], prn, n, A, B, nw[110], P, x, ans, a[110], bb[110];
long long nwk[110], nwb[110], ansk[110], ansb[110], phi, qaq;
bool bo[5000010];
long long gcd(long long a, long long b) { return (!b) ? a : gcd(b, a % b); }
long long mul(long long a, long long b, long long mod) {
long long t = 0;
a %= mod;
for (; b; b >>= 1, a = (a + a >= mod ? a + a - mod : a + a))
if (b & 1) t = (t + a >= mod ? t + a - mod : t + a);
return t;
}
long long quickmi(long long a, long long b, long long mod) {
long long t = (mod == 1 ? 0 : 1);
a %= mod;
for (; b; b >>= 1, a = mul(a, a, mod))
if (b & 1) t = mul(t, a, mod);
return t;
}
long long getphi(long long x) {
long long ans = x;
for (int i = 1; 1ll * pr[i] * pr[i] <= x; i++)
if (x % pr[i] == 0) {
ans = ans / pr[i] * (pr[i] - 1);
while (x % pr[i] == 0) x /= pr[i];
}
if (x > 1) ans = ans / x * (x - 1);
return ans;
}
void work(int I, long long ansb) {
ansa.clear(), ansp.clear();
long long AA = a[I], BB = bb[I];
if (BB == 1) ansb = 0;
for (int i = 0, sz = p[I].size(); i < sz; i++)
if (ansb * k[I][i] + b[I][i] > 0)
ansp.push_back(p[I][i]), ansa.push_back(ansb * k[I][i] + b[I][i]);
for (int i = 1; i <= n; i++)
if (i != I) {
if (p[i].size() == ansp.size()) {
long long nw = -1;
for (int j = 0, sz = p[i].size(); j < sz; j++) {
if (p[i][j] != ansp[j]) {
if (b[i][j] != 0 || nw > 0) puts("-1"), exit(0);
nw = 0;
} else if (k[i][j] == 0) {
if (b[i][j] != ansa[j]) puts("-1"), exit(0);
} else {
if (nw == -1) {
if (ansa[j] < b[i][j] || (ansa[j] - b[i][j]) % k[i][j] != 0)
puts("-1"), exit(0);
nw = (ansa[j] - b[i][j]) / k[i][j];
} else if (nw * k[i][j] + b[i][j] != ansa[j])
puts("-1"), exit(0);
}
}
} else {
long long ans = AA;
for (int j = 1; j <= ansb; j++) {
ans *= BB;
if (ans > a[i]) puts("-1"), exit(0);
}
if (ans != a[i]) puts("-1"), exit(0);
}
}
printf("%d\n", AA % mod * quickmi(BB, ansb, mod) % mod), exit(0);
}
void work(int i, int j, int po) {
if (!k[j][po]) swap(i, j);
if (b[j][po] > b[i][po]) puts("-1"), exit(0);
if ((b[i][po] - b[j][po]) % k[j][po] != 0) puts("-1"), exit(0);
work(j, (b[i][po] - b[j][po]) / k[j][po]);
}
void work(int i, int j, int p1, int p2) {
int b1 = b[i][p1], b2 = b[j][p1], b3 = b[i][p2], b4 = b[j][p2];
int k1 = k[i][p1], k2 = k[j][p1], k3 = k[i][p2], k4 = k[j][p2];
int kk = k2 * k3 - k4 * k1, bb = b1 * k3 - b3 * k1 - b2 * k3 + b4 * k1;
if (bb == 0) work(j, 0);
if ((bb > 0) != (kk > 0)) puts("-1"), exit(0);
if (bb < 0) bb = -bb, kk = -kk;
if (bb % kk != 0) puts("-1"), exit(0);
work(j, bb / kk);
}
int main() {
for (int i = 2; i <= 5000000; i++)
if (!bo[i]) {
pr[++prn] = i;
for (int j = i; j <= 5000000; j += i) bo[j] = 1;
}
qaq = 32 * 27 * 25;
for (int i = 4; pr[i] <= 30; i++) qaq *= pr[i];
phi = getphi(qaq);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &A, &B), a[i] = A, bb[i] = B;
if (n == 1) return printf("%d\n", A), 0;
for (int j = 1; pr[j] <= 40000; j++)
if (A % pr[j] == 0 || B % pr[j] == 0) {
int nw = p[i].size();
p[i].push_back(pr[j]), k[i].push_back(0), b[i].push_back(0);
while (A % pr[j] == 0) b[i][nw]++, A /= pr[j];
while (B % pr[j] == 0) k[i][nw]++, B /= pr[j];
}
if (A != 1) {
if (A == B)
p[i].push_back(A), k[i].push_back(1), b[i].push_back(1), B = 1;
else
p[i].push_back(A), k[i].push_back(0), b[i].push_back(1);
}
if (B != 1) p[i].push_back(B), k[i].push_back(1), b[i].push_back(0);
}
for (int i = 2; i <= n; i++) {
for (int j = 0, sz = min(p[1].size(), p[i].size()); j < sz; j++)
if (p[1][j] != p[i][j]) {
if (p[1][j] < p[i][j])
work(1, 0);
else
work(i, 0);
}
if (p[1].size() < p[i].size()) work(i, 0);
if (p[i].size() < p[1].size()) work(1, 0);
long long laA = 0, laB = 0;
int la = -1;
for (int j = 0, sz = p[1].size(); j < sz; j++)
if (k[1][j] || k[i][j]) {
if (k[1][j] * laB != k[i][j] * laA) work(1, i, la, j);
laA = k[1][j], laB = k[i][j], la = j;
} else if (!k[1][j] && !k[i][j]) {
if (b[1][j] != b[i][j]) return puts("-1"), 0;
} else
work(1, i, j);
for (int j = 0, sz = p[1].size(); j < sz; j++)
if (k[1][j] || k[i][j])
for (int l = j + 1; l < sz; l++)
if (k[1][l] || k[i][l])
if (1ll * b[1][j] * k[1][l] - 1ll * k[1][j] * b[1][l] !=
1ll * b[i][j] * k[i][l] - 1ll * k[i][j] * b[i][l])
return puts("-1"), 0;
}
s.clear();
for (int i = 1; i <= n; i++)
if (!p[i].empty()) nw[i] = 0, s.insert(make_pair(p[i][0], i));
while (!s.empty()) {
P = (*s.begin()).first;
for (int i = 1; i <= n; i++) nwk[i] = nwb[i] = 0;
while (!s.empty() && (*s.begin()).first == P) {
x = (*s.begin()).second;
nwk[x] = k[x][nw[x]], nwb[x] = b[x][nw[x]];
nw[x]++, s.erase(s.begin());
if (nw[x] < p[x].size()) s.insert(make_pair(p[x][nw[x]], x));
}
long long K, B;
for (int i = 2; i <= n; i++) {
K = nwk[1], B = nwb[1];
if (nwk[i] == 0 && nwb[i] < B) return puts("-1"), 0;
if (K == 0 && nwb[i] > B) return puts("-1"), 0;
long long g = gcd(K, nwk[i]);
if (g && B % g != nwb[i] % g) return puts("-1"), 0;
if (K == 0 || nwk[i] == 0)
B = (K == 0 ? B : nwb[i]), K = 0;
else {
if (B < nwb[i]) B += ((nwb[i] - B) / K + ((nwb[i] - B) % K != 0)) * K;
B += mul(nwk[i] - (B - nwb[i]) / g % nwk[i],
quickmi(K / g, phi - 1, nwk[i] / g), nwk[i] / g) *
K;
K = K / g * nwk[i];
}
if (nwk[1] != 0) {
long long pb = (B - nwb[1]) / nwk[1], pk = K / nwk[1];
for (int j = 0, sz = p[1].size(); j < sz; j++)
b[1][j] += k[1][j] * pb, k[1][j] *= pk;
nwk[1] = k[1][nw[1] - 1], nwb[1] = b[1][nw[1] - 1];
}
if (nwk[i] != 0) {
long long pb = (B - nwb[i]) / nwk[i], pk = K / nwk[i];
for (int j = 0, sz = p[i].size(); j < sz; j++)
b[i][j] += k[i][j] * pb, k[i][j] *= pk;
}
}
}
ans = 1;
for (int i = 0, sz = p[1].size(); i < sz; i++)
ans = 1ll * ans * quickmi(p[1][i], b[1][i], mod) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void gg() {
printf("-1\n");
exit(0);
}
int p[6010], N;
long long A[6010], B[6010];
struct Eq {
long long a, b, c;
} e[6010];
long long chu(long long a, long long b) { return (a + b - 1) / b; }
long long mmul(long long a, long long b, long long M) {
a = (a % M + M) % M;
b = (b % M + M) % M;
long long ans = 0, t = a;
while (b) {
if (b & 1) ans = (ans + t) % M;
t = (t + t) % M;
b >>= 1;
}
return ans;
}
bool merge(int a, int b) {
int cnt = 0;
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a;
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b;
while (t % p[i] == 0) t /= p[i], cnt2++;
if (!B[i] && !cnt2) {
if (cnt1 != A[i]) gg();
continue;
}
cnt++;
e[cnt].a = B[i];
e[cnt].b = -cnt2;
e[cnt].c = cnt1 - A[i];
}
if (!cnt) return false;
bool flag = false;
for (int i = 1; i <= cnt && !flag; i++) {
for (int j = i + 1; j <= cnt && !flag; j++)
if (e[i].a * e[j].b != e[j].a * e[i].b) {
swap(e[i], e[1]);
swap(e[j], e[2]);
flag = true;
} else if (e[i].a * e[j].c != e[j].a * e[i].c ||
e[i].b * e[j].c != e[j].b * e[i].c)
gg();
}
if (flag) {
if (!e[1].a) swap(e[1], e[2]);
long long g = gcd(e[1].a, e[2].a);
long long m1 = e[2].a / g;
long long m2 = e[1].a / g;
long long dc = e[1].c * m1 - e[2].c * m2;
long long db = e[1].b * m1 - e[2].b * m2;
if (dc % db != 0) gg();
long long y = dc / db;
dc = e[1].c - e[1].b * y;
if (dc % e[1].a != 0) gg();
long long x = dc / e[1].a;
for (int i = 1; i <= cnt; i++)
if (x * e[i].a + y * e[i].b != e[i].c) gg();
if (x < 0 || y < 0) gg();
for (int i = 1; i <= N; i++) A[i] += B[i] * x;
return true;
} else {
long long a = e[1].a, b = -e[1].b, c = e[1].c;
if (a == 0) {
if (c % b != 0) gg();
if (c / b < 0) gg();
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a;
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b;
while (t % p[i] == 0) t /= p[i], cnt2++;
A[i] = cnt1 + cnt2 * (c / b);
}
return true;
}
if (b == 0) {
if (c % a != 0) gg();
if (c / a < 0) gg();
for (int i = 1; i <= N; i++) A[i] += c / a * B[i];
return true;
}
long long x, y;
long long g = exgcd(a, b, x, y);
if (c % g != 0) gg();
x = mmul(x, c / g, b / g);
y = -(c - x * a) / b;
long long d = chu(max(0ll, -y), a / g);
x += d * (b / g);
for (int i = 1; i <= N; i++) {
A[i] += B[i] * x;
B[i] *= b / g;
}
return false;
}
}
const int Mod = 1000000007;
int fpow(int a, long long b) {
int ans = 1, t = a;
while (b) {
if (b & 1) ans = (long long)ans * t % Mod;
t = (long long)t * t % Mod;
b >>= 1;
}
return ans;
}
void work(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
p[++N] = i;
while (x % i == 0) x /= i;
}
if (x > 1) p[++N] = x;
return;
}
int a[110], b[110];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &b[i]);
work(a[i]);
work(b[i]);
}
sort(p + 1, p + N + 1);
N = unique(p + 1, p + N + 1) - p - 1;
for (int i = 1; i <= N; i++) {
int t = a[1];
while (t % p[i] == 0) A[i]++, t /= p[i];
t = b[1];
while (t % p[i] == 0) B[i]++, t /= p[i];
}
int now = 2;
while (now <= n && !merge(a[now], b[now])) now++;
while (now <= n) {
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a[now];
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b[now];
while (t % p[i] == 0) t /= p[i], cnt2++;
if (!cnt2) {
if (cnt1 != A[i]) gg();
} else if (A[i] < cnt1 || A[i] % cnt2 != cnt1 % cnt2)
gg();
}
now++;
}
int ans = 1;
for (int i = 1; i <= N; i++) ans = (long long)ans * fpow(p[i], A[i]) % Mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
char c;
int x;
for (c = getchar(); !isdigit(c); c = getchar())
;
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
const int mod = 1e9 + 7;
inline int power(int x, long long y) {
int res = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod) {
if (y & 1) {
res = 1ll * res * x % mod;
}
}
return res;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
__int128 get(__int128 x, long long d) {
return x >= 0 ? x / d : -((-1 - x) / d + 1);
}
const int N = 1e2 + 5, M = 2e3 + 5;
int n, m, _a[N], _b[N], pri[M], a[N][M], b[N][M];
long long ai[M], bi[M], aj[M], bj[M], gcd[M];
long long kx[M], ky[M], dx[M], dy[M], ans[M], sol[N];
void depose(int x) {
for (int d = 2; d * d <= x; d++) {
if (x % d == 0) {
pri[m++] = d;
while (x % d == 0) {
x /= d;
}
}
}
if (x > 1) {
pri[m++] = x;
}
}
void degrade(int x, int a[]) {
for (int i = 0; i < m; i++) {
while (x % pri[i] == 0) {
x /= pri[i];
a[i]++;
}
}
}
void print() {
for (int i = 0; i < n; i++) {
sol[i] = -1;
for (int d = 0; d < m; d++) {
long long tmp = ans[d] - a[i][d];
if (tmp == 0 && b[i][d] == 0) {
continue;
}
if (tmp < 0 || b[i][d] == 0 || tmp % b[i][d] != 0) {
printf("-1\n");
exit(0);
}
if (sol[i] == -1) {
sol[i] = tmp / b[i][d];
} else {
if (sol[i] != tmp / b[i][d]) {
printf("-1\n");
exit(0);
}
}
}
}
long long res = 1;
for (int i = 0; i < m; i++) {
res = 1ll * res * power(pri[i], ans[i]) % mod;
}
printf("%lld\n", res);
exit(0);
}
int main() {
n = read();
for (int i = 0; i < n; i++) {
_a[i] = read();
_b[i] = read();
depose(_a[i]);
depose(_b[i]);
}
std::sort(pri, pri + m);
m = std::unique(pri, pri + m) - pri;
for (int i = 0; i < n; i++) {
degrade(_a[i], a[i]);
degrade(_b[i], b[i]);
}
for (int i = 0; i < n; i++) {
for (int d = 0; d < m; d++) {
ai[d] = a[i][d];
bi[d] = b[i][d];
}
if (i > 0) {
for (int d = 0; d < m; d++) {
if (bi[d] == 0 && bj[d] == 0) {
if (ai[d] != aj[d]) {
printf("-1\n");
exit(0);
}
gcd[d] = 1;
kx[d] = 0;
dx[d] = 0;
ky[d] = 0;
dy[d] = 0;
continue;
}
long long x, y, g = gcd[d] = exgcd(bi[d], bj[d], x, y);
if ((aj[d] - ai[d]) % g != 0) {
printf("-1\n");
exit(0);
}
kx[d] = 0;
dx[d] = bj[d] / g;
ky[d] = 0;
dy[d] = bi[d] / g;
__int128 _x = (__int128)x * (aj[d] - ai[d]) / g;
__int128 _y = (__int128)y * (ai[d] - aj[d]) / g;
if (dx[d] != 0) {
kx[d] = std::max((__int128)kx[d], _x - dx[d] * get(_x, dx[d]));
ky[d] = std::max((__int128)ky[d], _y - dy[d] * get(_x, dx[d]));
}
if (dy[d] != 0) {
kx[d] = std::max((__int128)kx[d], _x - dx[d] * get(_y, dy[d]));
ky[d] = std::max((__int128)ky[d], _y - dy[d] * get(_y, dy[d]));
}
}
long long x = 0, y = 0, p, q;
for (int d = 0; d < m; d++) {
if (dx[d] == 0 && dy[d] == 0) {
continue;
}
if (x == 0 && y == 0) {
p = kx[d];
q = ky[d];
x = dx[d];
y = dy[d];
continue;
}
if (x != dx[d] || y != dy[d]) {
long long k = ((ky[d] - q) * dx[d] - (kx[d] - p) * dy[d]) /
(y * dx[d] - x * dy[d]);
k = p + x * k;
for (int d = 0; d < m; d++) {
ans[d] = ai[d] + bi[d] * k;
}
print();
}
}
}
long long max = *std::max_element(kx, kx + m);
for (int d = 0; d < m; d++) {
if (i == 0) {
aj[d] = ai[d];
bj[d] = bi[d];
continue;
}
aj[d] = ai[d] + bi[d] * max;
bj[d] = bi[d] / gcd[d] * bj[d];
}
}
for (int i = 0; i < m; i++) {
ans[i] = aj[i];
}
print();
return 0;
}
|
#include <bits/stdc++.h>
const int Mod = 1000000007;
inline int qPow(int b, long long e) {
int a = 1;
for (; e; e >>= 1, b = (long long)b * b % Mod)
if (e & 1) a = (long long)a * b % Mod;
return a;
}
int Gcd(long long a, long long b) { return b ? Gcd(b, a % b) : a; }
int exGcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, a;
long long d = exGcd(b, a % b, y, x);
return y -= a / b * x, d;
}
const int MN = 105, MS = 905;
int N, A[MN], B[MN];
int pr[MS], pc;
long long a[MS], b[MS], c[MS], d[MS];
inline void X(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
pr[++pc] = i;
while (x % i == 0) x /= i;
}
if (x > 1) pr[++pc] = x;
}
inline void Z(int x, long long *C) {
for (int i = 1; i <= pc; ++i) {
int p = pr[i];
C[i] = 0;
while (x % p == 0) x /= p, ++C[i];
}
}
inline int Merge() {
long long Sb = 0, Sd = 0;
for (int i = 1; i <= pc; ++i) Sb += b[i], Sd += d[i];
if (!Sb && !Sd) {
for (int i = 1; i <= pc; ++i)
if (a[i] != c[i]) return 0;
return 1;
}
if (!Sb || !Sd) {
if (!Sd) std::swap(a, c), std::swap(b, d), std::swap(Sb, Sd);
long long k = 0;
for (int i = 1; i <= pc; ++i)
if (d[i]) {
k = (a[i] >= c[i] && (a[i] - c[i]) % d[i] == 0) ? (a[i] - c[i]) / d[i]
: -1;
break;
} else if (a[i] != c[i])
return 0;
if (k == -1) return 0;
for (int i = 1; i <= pc; ++i)
if (c[i] + k * d[i] != a[i]) return 0;
return 1;
}
int ok = 0;
for (int i = 1; i <= pc; ++i)
if (b[i] * Sd != d[i] * Sb) {
ok = i;
break;
}
if (ok) {
int p1 = ok, p2 = 0;
for (int i = 1; i <= pc; ++i)
if (b[i] * d[p1] != d[i] * b[p1]) {
p2 = i;
break;
}
long long ka = d[p2] * (c[p1] - a[p1]) - d[p1] * (c[p2] - a[p2]);
long long kc = b[p2] * (c[p1] - a[p1]) - b[p1] * (c[p2] - a[p2]);
long long denom = d[p2] * b[p1] - d[p1] * b[p2];
if (denom < 0) ka = -ka, kc = -kc, denom = -denom;
if (ka < 0 || kc < 0 || ka % denom != 0 || kc % denom != 0) return 0;
ka /= denom, kc /= denom;
for (int i = 1; i <= pc; ++i) {
if (a[i] + ka * b[i] != c[i] + kc * d[i]) return 0;
a[i] = a[i] + ka * b[i], b[i] = 0;
}
return 1;
}
long long kb = 0, kd = 0;
for (int i = 1; i <= pc; ++i)
if (b[i]) {
long long g = Gcd(b[i], d[i]);
kb = b[i] / g, kd = d[i] / g;
break;
}
long long k = 0;
for (int i = 1; i <= pc; ++i)
if (b[i]) {
if ((a[i] - c[i]) % (b[i] / kb)) return 0;
k = (a[i] - c[i]) / (b[i] / kb);
break;
}
for (int i = 1; i <= pc; ++i)
if (c[i] + k * (b[i] / kb) != a[i]) return 0;
if (k < 0) std::swap(a, c), std::swap(b, d), std::swap(kb, kd), k = -k;
long long x, y;
exGcd(kb, kd, x, y);
x = ((long long)x * -k % kd + kd) % kd;
for (int i = 1; i <= pc; ++i) a[i] += x * b[i], b[i] *= kd;
return 1;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d%d", &A[i], &B[i]);
X(A[i]), X(B[i]);
}
std::sort(pr + 1, pr + pc + 1);
pc = std::unique(pr + 1, pr + pc + 1) - pr - 1;
for (int i = 1; i <= N; ++i)
if (i == 1)
Z(A[i], a), Z(B[i], b);
else if (Z(A[i], c), Z(B[i], d), !Merge())
return puts("-1"), 0;
int Ans = 1;
for (int i = 1; i <= pc; ++i) Ans = (long long)Ans * qPow(pr[i], a[i]) % Mod;
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int __SIZE = 1 << 18;
char ibuf[__SIZE], *iS, *iT;
template <typename T>
inline void read(T &x) {
char ch, t = 0;
x = 0;
while (!isdigit(ch = (iS == iT
? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)))
t |= ch == '-';
while (isdigit(ch))
x = x * 10 + (ch ^ 48),
ch = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
x = t ? -x : x;
}
inline int read_int() {
int x;
return read(x), x;
}
inline long long read_ll() {
long long x;
return read(x), x;
}
template <typename T>
inline void chkmin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void chkmax(T &a, T b) {
a = a > b ? a : b;
}
const int mod = 1e9 + 7;
inline int fsp(int x, long long k) {
int s = 1;
while (k) {
if (k & 1) s = 1LL * s * x % mod;
x = 1LL * x * x % mod, k >>= 1;
}
return s;
}
int tot;
int pri[31700];
int chk[31700];
inline void Sieve(int n = 31650) {
for (int i = 2; i <= n; i++) {
if (!chk[i]) pri[++tot] = i;
for (int j = 1; j <= tot; j++) {
if (i * pri[j] > n) break;
chk[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
struct Num {
int sz;
long long p[510], k[510], b[510];
inline int val() {
int res = 1;
for (int i = 1; i <= sz; i++) res = 1LL * res * fsp(p[i], b[i]) % mod;
return res;
}
inline void Ins(int pr, int &x, int &y) {
p[++sz] = pr, k[sz] = b[sz] = 0;
while (x % pr == 0) ++b[sz], x /= pr;
while (y % pr == 0) ++k[sz], y /= pr;
}
inline void init(int x, int y) {
sz = 0;
for (int i = 1; i <= tot; i++) {
int pr = pri[i];
if (pr > x && pr > y) break;
if (x % pr && y % pr) continue;
Ins(pr, x, y);
}
if (x < y) {
if (x > 1) Ins(x, x, y);
if (y > 1) Ins(y, x, y);
} else {
if (y > 1) Ins(y, x, y);
if (x > 1) Ins(x, x, y);
}
p[sz + 1] = 1919810;
}
} res, now, ans;
struct Seq {
int a, b;
} s[110];
int ct;
long long vA[20];
long long vB[20];
long long vC[20];
inline long long sgn(long long x) { return x < 0 ? -1ll : min(x, 1ll); }
inline long long gcd(long long a, long long b) {
return !b ? a : gcd(b, a % b);
}
inline long long lcm(long long a, long long b) {
return !a && !b ? 0ll : a / gcd(a, b) * b;
}
inline void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, void();
exgcd(b, a % b, y, x), y -= a / b * x;
}
inline void Solve(long long A, long long B, long long C, long long a,
long long b, long long c, long long &x, long long &y) {
long long d = gcd(a, A), P = a / d, p = A / d;
long long ta = a, tb = b, tc = c;
B *= P, C *= P;
b *= p, c *= p;
B -= b, C -= c;
if (sgn(C) * sgn(B) > 0 || !B || abs(C) % abs(B)) puts("-1"), exit(0);
y = -C / B, tc += tb * y;
if (!ta || tc % ta) puts("-1"), exit(0);
x = tc / ta;
}
inline void Merge(int x, int y) {
now.init(x, y), ct = 0;
int found_res = 0, val_res = 0;
int found_now = 0, val_now = 0;
for (int i = 1, j = 1;;) {
if (i > res.sz && j > now.sz)
break;
else if (res.p[i] != now.p[j]) {
if (res.p[i] < now.p[j]) {
if (res.b[i] > 0)
puts("-1"), exit(0);
else {
if (found_res) {
if (val_res) puts("-1"), exit(0);
} else
found_res = 1, val_res = 0;
}
++i;
} else {
if (now.b[j] > 0)
puts("-1"), exit(0);
else {
if (found_now) {
if (val_now) puts("-1"), exit(0);
} else
found_now = 1, val_now = 0;
}
++j;
}
} else {
if (!res.k[i] && !now.k[j]) {
if (res.b[i] != now.b[j]) puts("-1"), exit(0);
} else if (!res.k[i]) {
if (res.b[i] < now.b[j] || (res.b[i] - now.b[j]) % now.k[j])
puts("-1"), exit(0);
else {
if (found_now) {
if (val_now != (res.b[i] - now.b[j]) / now.k[j])
puts("-1"), exit(0);
} else
found_now = 1, val_now = (res.b[i] - now.b[j]) / now.k[j];
}
} else if (!now.k[j]) {
if (res.b[i] > now.b[j] || (now.b[j] - res.b[i]) % res.k[i])
puts("-1"), exit(0);
else {
if (found_res) {
if (val_res != (now.b[j] - res.b[i]) / res.k[i])
puts("-1"), exit(0);
} else
found_res = 1, val_res = (now.b[j] - res.b[i]) / res.k[i];
}
} else {
++ct;
vA[ct] = res.k[i];
vB[ct] = now.k[j];
vC[ct] = now.b[j] - res.b[i];
}
++i, ++j;
}
}
if (found_res || found_now) {
if (found_res)
for (int i = 1; i <= res.sz; i++)
res.b[i] += val_res * res.k[i], res.k[i] = 0;
if (found_now)
for (int i = 1; i <= now.sz; i++)
now.b[i] += val_now * now.k[i], now.k[i] = 0;
int flag = 1;
if (!found_res || !found_now) {
flag = 0;
for (int i = 1, j = 1;;) {
if (i > res.sz && j > now.sz) break;
if (res.p[i] != now.p[j]) {
if (res.p[i] < now.p[j] && res.b[i] != 0) puts("-1"), exit(0);
if (res.p[i] > now.p[j] && now.b[j] != 0) puts("-1"), exit(0);
if (res.p[i] < now.p[j])
++i;
else
++j;
} else {
if (!res.k[i] && !now.k[j]) {
if (res.b[i] != now.b[j]) puts("-1"), exit(0);
} else if (!res.k[i]) {
if (res.b[i] < now.b[j] || (res.b[i] - now.b[j]) % now.k[j])
puts("-1"), exit(0);
else {
if (found_now) {
if (val_now != (res.b[i] - now.b[j]) / now.k[j])
puts("-1"), exit(0);
} else
found_now = 1, val_now = (res.b[i] - now.b[j]) / now.k[j];
}
flag = 1;
break;
} else if (!now.k[j]) {
if (res.b[i] > now.b[j] || (now.b[j] - res.b[i]) % res.k[i])
puts("-1"), exit(0);
else {
if (found_res) {
if (val_res != (now.b[j] - res.b[i]) / res.k[i])
puts("-1"), exit(0);
} else
found_res = 1, val_res = (now.b[j] - res.b[i]) / res.k[i];
}
flag = 1;
break;
}
++i, ++j;
}
}
if (found_res)
for (int i = 1; i <= res.sz; i++)
res.b[i] += val_res * res.k[i], res.k[i] = 0;
if (found_now)
for (int i = 1; i <= now.sz; i++)
now.b[i] += val_now * now.k[i], now.k[i] = 0;
}
if (flag) {
for (int i = 1, j = 1;;) {
if (i > res.sz && j > now.sz) break;
if (res.p[i] != now.p[j]) {
if (res.p[i] < now.p[j] && res.b[i] != 0) puts("-1"), exit(0);
if (res.p[i] > now.p[j] && now.b[j] != 0) puts("-1"), exit(0);
if (res.p[i] < now.p[j])
++i;
else
++j;
} else {
if (!res.k[i] && !now.k[j]) {
if (res.b[i] != now.b[j]) puts("-1"), exit(0);
}
++i, ++j;
}
}
}
} else if (ct) {
for (int i = 1; i <= ct; i++) {
long long d = gcd(vA[i], vB[i]);
if (vC[i] % d)
puts("-1"), exit(0);
else
vA[i] /= d, vB[i] /= d, vC[i] /= d;
}
int flag = 1;
for (int i = 2; i <= ct; i++)
if (vA[i] == vA[i - 1] && vB[i] == vB[i - 1] && vC[i] == vC[i - 1])
flag++;
if (flag == ct) {
long long x, y;
exgcd(vA[1], vB[1], x, y);
y = -y, x *= vC[1], y *= vC[1];
if (x > 0) {
long long t = x / vB[1];
x -= vB[1] * t;
y -= vA[1] * t;
}
if (y > 0) {
long long t = y / vA[1];
x -= vB[1] * t;
y -= vA[1] * t;
}
if (x < 0) {
long long t = -x / vB[1] + (x % vB[1] < 0);
x += vB[1] * t;
y += vA[1] * t;
}
if (y < 0) {
long long t = -y / vA[1] + (y % vA[1] < 0);
x += vB[1] * t;
y += vA[1] * t;
}
if (x < 0) puts("-1"), exit(0);
ans.sz = 0;
for (int i = 1, j = 1; i <= res.sz && j <= now.p[j];) {
if (res.p[i] != now.p[j]) {
if (res.p[i] < now.p[j])
++i;
else
++j;
continue;
}
++ans.sz;
long long b = res.b[i], k = res.k[i];
ans.p[ans.sz] = res.p[i];
ans.b[ans.sz] = b + k * x;
ans.k[ans.sz] = lcm(res.k[i], now.k[j]);
++i, ++j;
}
ans.p[ans.sz + 1] = 1919810, res = ans;
return;
} else {
long long x, y;
for (int i = 2; i <= ct; i++) {
if (vA[i] == vA[1] && vB[i] == vB[1] && vC[i] == vC[1]) continue;
Solve(vA[1], vB[1], vC[1], vA[i], vB[i], vC[i], x, y);
break;
}
for (int i = 1; i <= ct; i++)
if (vA[i] * x - vB[i] * y != vC[i]) puts("-1"), exit(0);
for (int i = 1; i <= res.sz; i++) res.b[i] += x * res.k[i], res.k[i] = 0;
for (int i = 1; i <= now.sz; i++) now.b[i] += y * now.k[i], now.k[i] = 0;
}
}
ans.sz = 0;
for (int i = 1, j = 1; i <= res.sz && j <= now.p[j];) {
if (res.p[i] != now.p[j]) {
if (res.p[i] < now.p[j]) {
if (res.b[i]) puts("-1"), exit(0);
++i;
} else {
if (now.b[j]) puts("-1"), exit(0);
++j;
}
continue;
}
if (res.b[i] != now.b[j]) puts("-1"), exit(0);
++ans.sz;
ans.p[ans.sz] = res.p[i];
ans.b[ans.sz] = res.b[i];
ans.k[ans.sz] = 0;
++i, ++j;
}
ans.p[ans.sz + 1] = 1919810, res = ans;
}
int main() {
Sieve();
int n = read_int();
for (int i = 1; i <= n; i++) s[i].a = read_int(), s[i].b = read_int();
res.init(s[1].a, s[1].b);
for (int i = 2; i <= n; i++) Merge(s[i].a, s[i].b), cerr << res.b[1] << endl;
printf("%d\n", res.val());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const long long mod = (1e9) + 7;
const long long M = 998244353;
const double eps = 1e-6;
int n, cnt[110];
long long a[110], b[110], w[110], B[110], tmp;
void No() {
printf("-1\n");
exit(0);
}
int lg(long long x) { return (int)ceil(log(1.0 * x) / log(2.0)); }
long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
long long gcd(long long x, long long y) {
if (!x || !y) return x + y;
return gcd(y, x % y);
}
void solve1(int x) {
for (int i = 1; i <= n; i++) {
if (b[i] == 1 && a[i] != a[x]) No();
if (b[i] > 1) {
tmp = a[i];
while (1) {
if (tmp > a[x] / b[i]) No();
tmp *= b[i];
if (tmp == a[x]) break;
}
}
}
printf("%lld\n", a[x]);
exit(0);
}
void solve2(int x) {
long long t1 = a[1] % M, t2, t3;
int num = -1;
for (int i = 0; i < 400; i++) {
t2 = a[x] % M;
for (int j = 0; j < 400; j++) {
if (t1 == t2) {
t3 = t1, num = i;
break;
}
t2 = t2 * b[x] % M;
}
if (num != -1) break;
t1 = t1 * b[1] % M;
}
if (num == -1) No();
bool flag;
for (int i = 1; i <= n; i++) {
t1 = a[i] % M;
flag = 0;
for (int j = 0; j <= 100000; j++) {
if (t1 == t3) {
flag = 1;
break;
}
t1 = t1 * b[i] % M;
}
if (!flag) No();
}
tmp = a[1];
while (num--) tmp = tmp * b[1] % mod;
printf("%lld\n", tmp);
exit(0);
}
int main() {
srand(time(0));
read(n);
for (int i = 1; i <= n; i++) read(a[i]), read(b[i]);
for (int i = 1; i <= n; i++)
if (b[i] == 1) solve1(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= lg(b[i]); j++) {
tmp = (long long)floor(pow(b[i], 1.0 / j) + 0.5);
if (fabs(pow(tmp, j) - b[i]) < eps) B[i] = j, w[i] = tmp;
}
}
for (int i = 2; i <= n; i++)
if (w[i] != w[1]) solve2(i);
int mx = 0;
for (int i = 1; i <= n; i++) {
while (a[i] % w[i] == 0) a[i] /= w[i], cnt[i]++;
mx = max(mx, cnt[i]);
}
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) No();
long long Lcm = B[1], z, ans = cnt[1];
bool flag = 1;
for (int i = 2; i <= n; i++) {
flag = 0;
for (int j = 0; j < B[i]; j++)
if ((ans + Lcm * j) % B[i] == cnt[i] % B[i]) {
ans += Lcm * j;
flag = 1;
break;
}
if (!flag) No();
z = gcd(Lcm, B[i]);
Lcm = Lcm / z * B[i];
}
while (ans < mx) ans += Lcm;
printf("%lld\n", a[1] * ksm(w[1], ans) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> p;
int n;
struct line {
long long x, y, z;
} a[105];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
vector<pair<int, int> > dv[105];
vector<pair<int, int> > getdiv(int x) {
vector<pair<int, int> > c;
c.clear();
for (int d = 2; d * d <= x; d++) {
if (x % d == 0) {
int cnt = 0;
while (x % d == 0) cnt++, x /= d;
c.push_back(make_pair(d, cnt));
}
}
if (x > 1) c.push_back(make_pair(x, 1));
return c;
}
void FAIL() {
cout << -1 << endl;
exit(0);
}
long long power(long long a, long long b, long long mo = 1e9 + 7) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mo;
a = a * a % mo;
b >>= 1;
}
return ans;
}
void SUC(vector<pair<int, int> > z) {
long long ans = 1, mo = 1e9 + 7;
for (auto i : z) ans = ans * power(i.first, i.second) % mo;
cout << ans << endl;
exit(0);
}
int check(vector<pair<int, int> > z, int i) {
long long x = a[i].x, y = a[i].y;
vector<pair<int, int> > x0 = getdiv(a[i].x), y0 = getdiv(a[i].y);
for (auto i : z) {
while (x % i.first == 0) x /= i.first;
while (y % i.first == 0) y /= i.first;
}
if (x > 1) return 0;
if (y > 1) {
if (x0.size() == z.size()) {
for (int i = 0; i < z.size(); i++) {
if (x0[i] < z[i] || x0[i] > z[i]) return 0;
}
return 1;
}
return 0;
}
x = a[i].x, y = a[i].y;
int las = -1;
for (auto i : z) {
int cntx = 0, cnty = 0;
while (x % i.first == 0) x /= i.first, cntx++;
while (y % i.first == 0) y /= i.first, cnty++;
if (cnty == 0 && cntx != i.second || cntx > i.second) return 0;
if (cnty == 0) continue;
int k = (i.second - cntx) / cnty;
if ((i.second - cntx) % cnty != 0) return 0;
if (las != -1 && k != las) return 0;
las = k;
}
return 1;
}
void merge(vector<pair<int, int> > &a, vector<pair<int, int> > b) {
vector<pair<int, int> > c = a;
for (auto i : b) c.push_back(i);
sort(c.begin(), c.end());
a.clear();
if (c.size()) a.push_back(make_pair(c[0].first, 0));
for (int i = 1; i < c.size(); i++)
if (c[i].first != c[i - 1].first) a.push_back(make_pair(c[i].first, 0));
}
vector<pair<int, int> > check2(int i, int j) {
vector<pair<int, int> > z0 = getdiv(a[i].x);
merge(z0, getdiv(a[i].y));
merge(z0, getdiv(a[j].x));
merge(z0, getdiv(a[j].y));
vector<pair<int, int> > A = z0, B = z0, C = z0, D = z0;
int a0 = a[i].x, b0 = a[i].y, c0 = a[j].x, d0 = a[j].y;
for (int i = 0; i < z0.size(); i++) {
while (a0 % z0[i].first == 0) A[i].second++, a0 /= z0[i].first;
while (b0 % z0[i].first == 0) B[i].second++, b0 /= z0[i].first;
while (c0 % z0[i].first == 0) C[i].second++, c0 /= z0[i].first;
while (d0 % z0[i].first == 0) D[i].second++, d0 /= z0[i].first;
}
int k1 = -1, k2 = -1, suc = 0;
for (k1 = 0; k1 <= 100; k1++) {
for (k2 = 0; k2 <= 100; k2++) {
if (A[0].second + k1 * B[0].second == C[0].second + k2 * D[0].second &&
A[1].second + k1 * B[1].second == C[1].second + k2 * D[1].second) {
suc = 1;
break;
}
}
if (suc) break;
}
if (suc == 0) FAIL();
vector<pair<int, int> > z1;
for (int i = 0; i < z0.size(); i++) {
z0[i].second = A[i].second + B[i].second * k1;
if (z0[i].second) z1.push_back(z0[i]);
}
return z1;
}
int main() {
int tag1 = 0, tag2 = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y, k = 0, y0;
scanf("%d%d", &x, &y);
a[i] = (line){x, y, 0};
for (int d = 2; d * d <= y; d++) {
int cnt = 0;
while (y % d == 0) cnt++, y /= d;
k = gcd(k, cnt);
if (cnt) dv[i].push_back(make_pair(d, cnt));
}
if (y > 1) k = 1, dv[i].push_back(make_pair(y, 1));
if (k) a[i].z = pow(a[i].y, 1.0 / k) + 0.5;
if (a[i].y == 1) tag1 = a[i].x;
if (a[i].z != a[1].z) tag2 = i;
}
if (n == 1) {
printf("%d\n", a[1].x);
return 0;
}
if (tag1) {
int x0 = tag1;
vector<pair<int, int> > z = getdiv(tag1);
for (int i = 1; i <= n; i++) {
if (!check(z, i)) FAIL();
}
SUC(z);
}
if (tag2) {
vector<pair<int, int> > z = check2(1, tag2);
for (int i = 1; i <= n; i++) {
if (!check(z, i)) FAIL();
}
SUC(z);
}
int Z = a[1].z;
for (int i = 1; i <= n; i++) {
int x0 = a[i].x, y0 = a[i].y, z = a[i].z;
a[i].x = a[i].y = 0;
while (y0 % z == 0) y0 /= z, a[i].y++;
while (x0 % z == 0) x0 /= z, a[i].x++;
a[i].z = x0;
if (a[i].z != a[1].z) FAIL();
}
long long A = a[1].y, B = a[1].x;
for (int i = 2; i <= n; i++) {
int suc = 0;
for (int j = 0; j < a[i].y; j++, B += A) {
if (B % a[i].y == a[i].x % a[i].y) {
suc = 1;
break;
}
}
if (!suc)
FAIL();
else
A = A * a[i].y / gcd(A, a[i].y);
}
for (int i = 1; i <= n; i++)
while (B < a[i].x) B += A;
cout << power(Z, B) * a[1].z % (1000000007) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NN = 100 + 117;
const int MM = 3000 + 117;
int read() {
int fl = 1, x;
char c;
for (c = getchar(); (c < '0' || c > '9') && c != '-'; c = getchar())
;
if (c == '-') {
fl = -1;
c = getchar();
}
for (x = 0; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + c - '0';
return x * fl;
}
void open() { freopen("a.in", "r", stdin); }
void close() {
fclose(stdin);
fclose(stdout);
}
const int mod = 1e9 + 7;
long long ksm(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ret = ret * a % mod;
return ret;
}
int m, n;
struct eq {
long long st, d;
} a[NN][MM];
int d[MM] = {};
int dcnt = 0;
long long in[NN][2] = {};
long long ans[MM] = {};
bool vis[MM] = {};
void dvd(int a) {
int top = sqrt(a + 1);
for (int i = 2; i <= top; ++i) {
if (a % i == 0) {
d[++dcnt] = i;
while (a % i == 0) a /= i;
}
}
if (a != 1) d[++dcnt] = a;
}
bool chk() {
for (int i = 1; i <= n; ++i) {
long long x = -1;
for (int j = 1; j <= dcnt; ++j) {
if (ans[j] < a[i][j].st) return false;
if (a[i][j].d) {
if ((ans[j] - a[i][j].st) % a[i][j].d) return false;
long long now = (ans[j] - a[i][j].st) / a[i][j].d;
if (x == -1)
now = x;
else if (now != x)
return false;
} else {
if (ans[j] != a[i][j].st) return false;
}
}
}
return true;
}
void makeans(int id, long long x) {
for (int i = 1; i <= dcnt; ++i) {
ans[i] = a[id][i].st + a[id][i].d * x;
}
}
void WA() {
printf("-1\n");
exit(0);
}
void AC() {
long long op = 1;
for (int i = 1; i <= dcnt; ++i) {
op = op * ksm(d[i], ans[i]) % mod;
}
printf("%lld\n", op);
exit(0);
}
void judge() {
if (chk())
AC();
else
WA();
}
long long x[2][3] = {};
int xiao() {
long long mul1 = x[1][0];
long long mul2 = x[0][0];
x[0][0] *= mul1, x[0][1] *= mul1, x[0][2] *= mul1;
x[1][0] *= mul2, x[1][1] *= mul2, x[1][2] *= mul2;
x[1][0] -= x[0][0], x[1][1] -= x[0][1], x[1][2] -= x[0][2];
if (x[1][1] == 0) {
if (x[1][2] == 0)
return 1;
else
return -1;
}
if (x[1][2] % x[1][1]) return -1;
x[1][2] /= x[1][1];
if (x[1][2] < 0) return -1;
x[0][2] -= x[0][1] * x[1][2];
if (x[0][2] % x[0][0]) return -1;
x[0][2] /= x[0][0];
if (x[0][2] < 0) return -1;
return 0;
}
long long exgcd(long long a, long long &x, long long b, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long nx, ny;
long long g = exgcd(b, nx, a % b, ny);
x = ny;
y = nx - a / b * ny;
return g;
}
long long mul(long long a, long long b, long long mod) {
long long ret = 0;
if (b < 0) b = -b, a = -a;
for (; b; b >>= 1, a = (a + a) % mod) {
if (b & 1) ret = (ret + a) % mod;
}
return ret;
}
bool bind(eq &a, eq b) {
long long x, y;
long long g = exgcd(a.d, x, b.d, y);
long long c = b.st - a.st;
if (c % g) return false;
c /= g;
long long mod = a.d / g * b.d;
long long tp = mul(a.d, x, mod);
tp = mul(tp, c, mod);
tp = (tp + a.st) % mod;
long long rem = tp;
a.st = rem;
a.d = mod;
return true;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
int a = read();
int b = read();
dvd(a);
dvd(b);
in[i][0] = a;
in[i][1] = b;
}
sort(d + 1, d + 1 + dcnt);
dcnt = unique(d + 1, d + 1 + dcnt) - d - 1;
for (int i = 1; i <= n; ++i) {
long long x = in[i][0], y = in[i][1];
for (int j = 1; j <= dcnt; ++j) {
while (x % d[j] == 0) {
a[i][j].st++;
x /= d[j];
}
while (y % d[j] == 0) {
a[i][j].d++;
y /= d[j];
}
}
}
if (n == 1) {
makeans(1, 0);
judge();
}
int rem = dcnt;
for (int j = 1; j <= dcnt; ++j) {
int k = -1;
int pos = -1;
for (int i = 1; i <= n; ++i) {
if (a[i][j].d == 0) {
if (k == -1) {
k = a[i][j].st;
} else {
if (a[i][j].st != k) WA();
}
} else
pos = i;
}
if (k == -1) continue;
if (pos == -1) {
vis[j] = 1;
--rem;
continue;
}
if (k < a[pos][j].st) {
WA();
}
k -= a[pos][j].st;
if (k % a[pos][j].d) WA();
k /= a[pos][j].d;
makeans(pos, k);
judge();
}
if (rem == 0) {
makeans(1, 0);
judge();
}
if (rem > 1) {
int pos = 0;
for (int j = 1; j <= dcnt; ++j)
if (!vis[j]) {
pos = j;
break;
}
for (int j = pos + 1; j <= dcnt; ++j) {
if (vis[j]) continue;
for (int i = 2; i <= n; ++i) {
x[0][0] = a[1][pos].d;
x[0][1] = -a[i][pos].d;
x[0][2] = a[i][pos].st - a[1][pos].st;
x[1][0] = a[1][j].d;
x[1][1] = -a[i][j].d;
x[1][2] = a[i][j].st - a[1][j].st;
int tp = xiao();
if (tp == 1) vis[j] = 1;
if (tp == -1) WA();
if (tp == 0) {
makeans(1, x[0][2]);
judge();
}
}
}
}
int pos = 0;
for (int j = 1; j <= dcnt; ++j)
if (!vis[j]) {
pos = j;
break;
}
eq now;
now.st = 0;
now.d = 1;
for (int i = 1; i <= n; ++i) {
if (!bind(now, a[i][pos])) WA();
}
for (int i = 1; i <= n; ++i) {
while (now.st < a[i][pos].st) {
now.st += now.d;
}
}
long long x = (now.st - a[1][pos].st) / a[1][pos].d;
makeans(1, x);
judge();
close();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void gg() {
printf("-1\n");
exit(0);
}
int p[6010], N;
long long A[6010], B[6010];
struct Eq {
long long a, b, c;
} e[6010];
long long chu(long long a, long long b) { return (a + b - 1) / b; }
long long mmul(long long a, long long b, long long M) {
a = (a % M + M) % M;
b = (b % M + M) % M;
long long ans = 0, t = a;
while (b) {
if (b & 1) ans = (ans + t) % M;
t = (t + t) % M;
b >>= 1;
}
return ans;
}
bool merge(int a, int b) {
int cnt = 0;
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a;
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b;
while (t % p[i] == 0) t /= p[i], cnt2++;
if (!B[i] && !cnt2) {
if (cnt1 != A[i]) gg();
continue;
}
cnt++;
e[cnt].a = B[i];
e[cnt].b = -cnt2;
e[cnt].c = cnt1 - A[i];
}
if (!cnt) return false;
bool flag = false;
for (int i = 1; i <= cnt && !flag; i++) {
for (int j = i + 1; j <= cnt && !flag; j++)
if (e[i].a * e[j].b != e[j].a * e[i].b) {
swap(e[i], e[1]);
swap(e[j], e[2]);
flag = true;
} else if (e[i].a * e[j].c != e[j].a * e[i].c ||
e[i].b * e[j].c != e[j].b * e[i].c)
gg();
}
if (flag) {
if (!e[1].a) swap(e[1], e[2]);
long long g = gcd(e[1].a, e[2].a);
long long m1 = e[2].a / g;
long long m2 = e[1].a / g;
long long dc = e[1].c * m1 - e[2].c * m2;
long long db = e[1].b * m1 - e[2].b * m2;
if (dc % db != 0) gg();
long long y = dc / db;
dc = e[1].c - e[1].b * y;
if (dc % e[1].a != 0) gg();
long long x = dc / e[1].a;
for (int i = 1; i <= cnt; i++)
if (x * e[i].a + y * e[i].b != e[i].c) gg();
if (x < 0 || y < 0) gg();
for (int i = 1; i <= N; i++) A[i] += B[i] * x;
return true;
} else {
long long a = e[1].a, b = -e[1].b, c = e[1].c;
if (a == 0) {
if (c % b != 0) gg();
if (c / b < 0) gg();
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a;
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b;
while (t % p[i] == 0) t /= p[i], cnt2++;
A[i] = cnt1 + cnt2 * (c / b);
}
return true;
}
if (b == 0) {
if (c % a != 0) gg();
if (c / a < 0) gg();
for (int i = 1; i <= N; i++) A[i] += c / a * B[i];
return true;
}
long long x, y;
long long g = exgcd(a, b, x, y);
if (c % g != 0) gg();
x = mmul(x, c / g, b / g);
y = -(c - x * a) / b;
long long d = chu(max(0ll, -y), a / g);
x += d * (b / g);
for (int i = 1; i <= N; i++) {
A[i] += B[i] * x;
B[i] *= b / g;
}
return false;
}
}
const int Mod = 1000000007;
int fpow(int a, long long b) {
int ans = 1, t = a;
while (b) {
if (b & 1) ans = (long long)ans * t % Mod;
t = (long long)t * t % Mod;
b >>= 1;
}
return ans;
}
void work(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
p[++N] = i;
while (x % i == 0) x /= i;
}
if (x > 1) p[++N] = x;
return;
}
int a[110], b[110];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i], &b[i]);
work(a[i]);
work(b[i]);
}
sort(p + 1, p + N + 1);
N = unique(p + 1, p + N + 1) - p - 1;
for (int i = 1; i <= N; i++) {
int t = a[1];
while (t % p[i] == 0) A[i]++, t /= p[i];
t = b[1];
while (t % p[i] == 0) B[i]++, t /= p[i];
}
int now = 2;
while (now <= n && !merge(a[now], b[now])) now++;
while (now <= n) {
for (int i = 1; i <= N; i++) {
int cnt1 = 0, cnt2 = 0;
int t = a[now];
while (t % p[i] == 0) t /= p[i], cnt1++;
t = b[now];
while (t % p[i] == 0) t /= p[i], cnt2++;
if (!cnt2) {
if (cnt1 != A[i]) gg();
} else if (A[i] < cnt1 || A[i] % cnt2 != cnt1 % cnt2)
gg();
}
now++;
}
int ans = 1;
for (int i = 1; i <= N; i++) ans = (long long)ans * fpow(p[i], A[i]) % Mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline long long kpow(long long a, long long b) {
a %= mod, b %= (mod - 1);
long long s = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) s = s * a % mod;
return s;
}
void no() {
printf("-1");
exit(0);
}
long long n, a[110], b[110], mib = 0x3f3f3f3f;
bool bj[100010];
long long su[100010], sunum;
void init() {
bj[1] = 1;
for (long long i = 2; i <= 100000; ++i) {
if (!bj[i]) su[++sunum] = i;
for (long long j = 1; j <= sunum && su[j] * i <= 100000; ++j) {
bj[su[j] * i] = 1;
if (i % su[j] == 0) break;
}
}
}
map<long long, long long> mp;
bool check(long long w) {
for (long long s = w, i = 1; s <= 1000000000; s *= w, ++i) mp[s] = i;
for (long long i = 1; i <= n; ++i)
if (!mp[b[i]]) return 0;
return 1;
}
map<long long, long long> da[110], db[110];
void divi(long long x, map<long long, long long> &mp) {
for (long long i = 1; su[i] * su[i] <= x; ++i)
if (x % su[i] == 0) {
long long cnt = 0;
while (x % su[i] == 0) ++cnt, x /= su[i];
mp[su[i]] = cnt;
}
if (x > 1) mp[x] = 1;
}
void work(long long w) {
for (long long i = 1; i <= n; ++i) {
long long c = a[i];
while (c < w) c *= b[i];
if (c != w) no();
}
printf("%lld", w);
exit(0);
}
void work1(long long A, long long B, long long N) {
if (N < 0) no();
map<long long, long long> dw, dA, dB, dC;
divi(A, dA), divi(B, dB);
dw = dA;
for (auto p : dB) dw[p.first] += N * p.second;
for (long long i = 1; i <= n; ++i) {
dC = da[i];
for (auto p : dw) dC[p.first];
for (auto p : dC)
if (p.second != dw[p.first]) {
if (!db[i][p.first]) no();
long long c = (dw[p.first] - p.second) / db[i][p.first];
if (c < 0) no();
for (auto q : db[i]) dC[q.first] += q.second * c;
break;
}
for (auto p : dC)
if (p.second != dw[p.first]) no();
}
long long ans = 1;
for (auto p : dw) ans = ans * kpow(p.first, p.second) % mod;
printf("%lld", ans);
exit(0);
}
long long gcd(long long a, long long b) {
if (!a || !b) return a + b;
return gcd(b, a % b);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
if (!a) {
x = 0, y = 1;
return b;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void solve1(long long s) {
long long sa = 0;
long long k[110], t[110];
for (long long i = 1; i <= n; ++i) {
long long x = a[i];
t[i] = 0;
k[i] = mp[b[i]];
while (x % s == 0) x /= s, ++t[i];
if (sa && sa != x) no();
sa = x;
}
long long nk = 1, nt = 0, x, y;
for (long long i = 1; i <= n; ++i) {
long long g = exgcd(nk, -k[i], x, y);
if (g < 0) g = -g, x = -x, y = -y;
if ((t[i] - nt) % g) no();
x *= (t[i] - nt) / g, y *= (t[i] - nt) / g;
if (x < 0) {
long long c = (-x + k[i] / g - 1) / (k[i] / g);
x += c * k[i] / g;
y += c * nk / g;
}
if (y < 0) {
long long c = (-y + nk / g - 1) / (nk / g);
x += c * k[i] / g;
y += c * nk / g;
}
long long c = min(x / (k[i] / g), y / (nk / g));
x -= c * k[i] / g, y -= c * nk / g;
nt = x * nk + nt;
nk = nk * k[i] / g;
}
work1(sa, s, nt);
}
void solve2() {
long long p;
for (long long i = 2; i <= n; ++i)
if (!mp[b[i]]) {
p = i;
break;
}
for (auto q : db[1])
if (!db[p].count(q.first))
work1(a[1], b[1], (da[p][q.first] - da[1][q.first]) / q.second);
for (auto q : db[p])
if (!db[1].count(q.first))
work1(a[p], b[p], (da[1][q.first] - da[p][q.first]) / q.second);
long long a1 = db[1].begin()->second, b1 = -db[p].begin()->second,
c1 = da[p][db[1].begin()->first] - da[1][db[1].begin()->first];
long long a2, b2, c2;
for (auto q : db[1]) {
a2 = q.second, b2 = -db[p][q.first], c2 = da[p][q.first] - da[1][q.first];
if (a1 * b2 != a2 * b1)
work1(a[1], b[1], (c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1));
}
}
int main() {
init();
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%lld %lld", &a[i], &b[i]);
divi(a[i], da[i]);
divi(b[i], db[i]);
mib = min(mib, b[i]);
}
if (mib == 1) {
for (long long i = 1; i <= n; ++i)
if (b[i] == 1) {
work(a[i]);
break;
}
return 0;
}
long long g = 0;
for (auto p : db[1]) g = gcd(g, p.second);
long long s = 1;
for (auto p : db[1]) {
long long cnt = p.second / g;
while (cnt--) s *= p.first;
}
if (check(s))
solve1(s);
else
solve2();
return 0;
}
|
#include <bits/stdc++.h>
int N;
std::map<int, std::pair<long long, long long> > A[100];
void read(std::map<int, std::pair<long long, long long> > &M) {
int x, y;
scanf("%d%d", &x, &y);
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int count = 0;
do x /= i, count++;
while (x % i == 0);
M[i].first += count;
}
if (x > 1) M[x].first++;
for (int i = 2; i * i <= y; i++)
if (y % i == 0) {
int count = 0;
do y /= i, count++;
while (y % i == 0);
M[i].second += count;
}
if (y > 1) M[y].second++;
}
long long gcd(long long x, long long y) {
if (x < 0) x = -x;
if (y < 0) y = -y;
long long r;
while (y) {
r = x % y;
x = y;
y = r;
}
return x;
}
long long MUL(long long a, long long b, long long c) {
long long r = 0;
for (; b; b >>= 1) {
if (b & 1) r = r + a < c ? r + a : r + a - c;
a = a + a < c ? a + a : a + a - c;
}
return r;
}
long long POWER(long long a, long long b, long long c) {
long long r = 1;
for (; b; b >>= 1) {
if (b & 1) r = MUL(r, a, c);
a = MUL(a, a, c);
}
return r;
}
long long phi(long long x) {
long long r = x;
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) {
do x /= i;
while (x % i == 0);
r = r / i * (i - 1);
}
if (x > 1) r = r / x * (x - 1);
return r;
}
long long first(long long a, long long b, long long c) {
if (a == 0) return 0;
if (b == 0) return c / a;
long long ta = MUL(POWER(a, phi(-b) - 1, -b), (c % -b + -b) % -b, -b),
tb = (c - ta * a) / b;
if (tb < 0) {
long long D = (-tb + a - 1) / a;
ta += -b * D;
tb += a * D;
}
return ta;
}
std::map<int, std::pair<long long, long long> > merge(
std::map<int, std::pair<long long, long long> > a,
std::map<int, std::pair<long long, long long> > b) {
for (auto &i : a) b[i.first];
for (auto &i : b) a[i.first];
long long line = 0, line_a = 0, line_b = 0, line_c = 0;
long long point = 0, point_x = 0, point_y = 0;
for (auto &i : a) {
std::pair<long long, long long> &pa = i.second, &pb = b[i.first];
long long A = pa.second, B = -pb.second, C = pb.first - pa.first,
G = gcd(A, B);
if (A == 0 && B == 0) {
if (C) {
puts("-1");
exit(0);
}
continue;
}
if (C % G) {
puts("-1");
exit(0);
}
A /= G;
B /= G;
C /= G;
if (A < 0 || A == 0 && B < 0) {
A = -A;
B = -B;
C = -C;
}
if (point) {
if (point_x * A + point_y * B != C) {
puts("-1");
exit(0);
}
} else if (line) {
if (line_a == A && line_b == B) {
if (line_c != C) {
puts("-1");
exit(0);
}
} else {
long long X0 = A * line_b - line_a * B, X1 = C * line_b - line_c * B,
Y0 = B * line_a - line_b * A, Y1 = C * line_a - line_c * A;
if (X1 % X0 || Y1 % Y0) {
puts("-1");
exit(0);
}
line = 0;
point = 1;
point_x = X1 / X0;
point_y = Y1 / Y0;
if (point_x < 0 || point_y < 0) {
puts("-1");
exit(0);
}
}
} else {
line = 1;
line_a = A;
line_b = B;
line_c = C;
}
}
if (line) {
std::map<int, std::pair<long long, long long> > ans;
for (auto &i : a)
ans.insert(
{i.first,
{i.second.first + i.second.second * first(line_a, line_b, line_c),
i.second.second * -line_b}});
return ans;
} else if (point) {
std::map<int, std::pair<long long, long long> > ans;
for (auto &i : a)
ans.insert({i.first, {point_x * i.second.second + i.second.first, 0}});
return ans;
} else
return a;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) read(A[i]);
while (N > 1) {
A[N - 2] = merge(A[N - 2], A[N - 1]);
N--;
}
long long O = 1;
for (auto &i : A[0])
O = O * POWER(i.first, i.second.first, 1000000007) % 1000000007;
printf("%lld\n", O);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long al[100][40] = {}, be[100][40] = {};
map<int, long long> ex;
map<int, long long> X;
vector<long long> p;
int primos[10000];
bool criba[40000];
unsigned long long m = 1000000007;
long long sq(long long a) { return a * a; }
long long potMod(long long a, unsigned long long b) {
return b ? ((sq(potMod(a, b >> 1)) % m) * (b & 1 ? a : 1)) % m : 1;
}
long long pot(long long a, unsigned long long b) {
return b ? sq(pot(a, b >> 1)) * (b & 1 ? a : 1) : 1;
}
int factorizar2(int N, int M) {
int F = 0;
for (int i = 0; primos[i] * primos[i] <= N || primos[i] * primos[i] <= M;
i++) {
if (N % primos[i] == 0 || M % primos[i] == 0) {
++F;
p.push_back(primos[i]);
}
while (N % primos[i] == 0) {
al[0][F - 1]++;
N /= primos[i];
}
while (M % primos[i] == 0) {
be[0][F - 1]++;
M /= primos[i];
}
}
if (N > 1 && M > 1) {
if (N == M) {
p.push_back(N);
al[0][F] = be[0][F] = 1;
F++;
} else {
p.push_back(N);
p.push_back(M);
al[0][F++] = 1;
be[0][F++] = 1;
}
} else if (N > 1) {
p.push_back(N);
al[0][F++] = 1;
} else if (M > 1) {
p.push_back(M);
be[0][F++] = 1;
}
return F;
}
map<int, long long> factorizar(int N) {
map<int, long long> e;
for (int i = 0; primos[i] * primos[i] <= N; i++) {
if (!(N % primos[i]))
while (!(N % primos[i])) {
e[primos[i]]++;
N /= primos[i];
}
}
if (N > 1) e[N]++;
return e;
}
pair<long long, long long> egcd(long long a, long long b) {
if (b == 0) return make_pair(1, 0);
pair<long long, long long> RES = egcd(b, a % b);
return make_pair(RES.second, RES.first - RES.second * (a / b));
}
long long inv(long long n, long long m) {
pair<long long, long long> EDGC = egcd(n, m);
return ((EDGC.first % m) + m) % m;
}
long long tcr(int k, long long n[], long long a[]) {
int i;
long long temp, MOD, RES;
MOD = 1;
for (i = 0; i < k; i++) MOD *= n[i];
RES = 0;
for (i = 0; i < k; i++) {
temp = MOD / n[i];
temp *= inv(temp, n[i]);
RES += (temp * a[i]) % MOD;
}
return RES % MOD;
}
int k;
long long x, y, A, B, C;
int intersectar(int j) {
for (int i = 1; i < k; i++) {
int D = be[j][0] * be[0][i] - be[0][0] * be[j][i];
if (D == 0) {
if (be[0][0] * (al[j][i] - al[0][i]) !=
be[0][i] * (al[j][0] - al[0][0])) {
return 0;
}
} else {
int d1 =
(al[j][i] - al[0][i]) * be[j][0] - (al[j][0] - al[0][0]) * be[j][i];
int d2 =
(al[j][i] - al[j][i]) * be[j][0] - (al[j][0] - al[0][0]) * be[0][i];
if (d1 % D || d2 % D)
return 0;
else {
x = d1 / D;
y = d2 / D;
if (x < 0 || y < 0) return 0;
for (int h = 0; h < k; h++) al[0][h] += (be[0][h] * x);
return 1;
}
}
}
int h = 0;
for (; h < k - 1 && !(be[0][h] || be[j][h]); h++)
;
A = be[0][h], B = be[j][h], C = al[j][h] - al[0][h];
pair<long long, long long> r = egcd(A, -B);
x = r.first;
y = r.second;
int d = A * x - B * y;
if (d < 0) {
d = -d;
x = -x;
y = -y;
}
if (C < 0) {
C = -C;
x = -x;
y = -y;
}
if (d == 0) {
x = y = 0;
return 1;
}
if (C % d) return 0;
A /= d;
B /= d;
C /= d;
while (x < 0 || y < 0) {
x += B;
y += A;
}
while (x - B > 0 && y - A > 0) {
x -= B;
y -= A;
}
x *= C;
y *= C;
return 2;
}
bool validar(int i) {
int j = 0;
for (; j < k - 1 && !be[i][j]; j++)
;
if (be[i][j] && (al[0][j] < al[i][j] || (al[0][j] - al[i][j]) % be[i][j]))
return false;
if (!be[i][j])
y = 0;
else
y = (al[0][j] - al[i][j]) / be[i][j];
for (int h = 1; h < k; h++)
if (al[0][h] != al[i][h] + be[i][h] * y) return false;
return true;
}
int main() {
int n, a0, b0, a, b, tipo;
k = 0;
primos[k++] = 2;
memset(criba, true, sizeof(criba));
for (int i = 4; i < 40000; i += 2) criba[i] = false;
for (int i = 3; i < 40000; i += 2)
if (criba[i]) {
primos[k++] = i;
for (int j = i * i; j < 40000; j += i) criba[j] = false;
}
scanf("%d", &n);
scanf("%d%d", &a0, &b0);
k = factorizar2(a0, b0);
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
for (int j = 0; j < k; j++) {
while (a % p[j] == 0) {
al[i][j]++;
a /= p[j];
}
while (b % p[j] == 0) {
be[i][j]++;
b /= p[j];
}
}
if (a != 1) {
printf("-1\n");
return 0;
}
if (b != 1)
for (int j = 0; j < k; j++) be[i][j] = 0;
}
long long maxX = 0;
for (int i = 1; i < n; i++) {
tipo = intersectar(i);
if (!tipo) {
printf("-1\n");
return 0;
}
if (tipo == 1) {
for (int j = 0; j < n; j++)
if (!validar(j)) {
printf("-1\n");
return 0;
}
long long res = (a0 * potMod(b0, x)) % m;
;
printf("%d\n", (int)res);
return 0;
}
map<int, long long> e = factorizar(B);
map<int, long long>::iterator it;
for (it = e.begin(); it != e.end(); it++) {
int p = it->first;
int z1 = ex[p], z = it->second;
if (!z1) {
ex[p] = z;
X[p] = x % pot(p, z);
} else {
long long x1 = X[p];
if (z1 <= z) {
long long po = pot(p, z1);
if (x1 % po != x % po) {
printf("-1\n");
return 0;
}
ex[p] = z;
X[p] = x % pot(p, z);
} else {
long long po = pot(p, z);
if (x1 % po != x % po) {
printf("-1\n");
return 0;
}
}
}
}
maxX = max(maxX, x);
}
long long mo[100];
long long resi[100];
int s = 0;
map<int, long long>::iterator it;
for (it = ex.begin(); it != ex.end(); it++)
mo[s++] = pot(it->first, it->second);
s = 0;
for (it = X.begin(); it != X.end(); it++) resi[s++] = it->second;
long long MOD = 1;
for (int i = 0; i < s; i++) MOD *= mo[i];
long long EXP = tcr(s, mo, resi);
while (EXP < maxX) EXP += MOD;
long long res = (a0 * potMod(b0, EXP)) % m;
printf("%d\n", (int)res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long msk(long long a, long long b, long long k, int md) {
a %= md;
k %= md;
while (b) {
if (b & 1) k = k * a % md;
a = a * a % md;
b >>= 1;
}
return k;
}
pair<int, int> a[N];
map<int, int> mp;
int n;
long long t[N], s[N], r[N], p[N],
P[20]{0, 998244353, 1000000007, 19260817,
998244853, 1919810, 114514, 191981011451};
bool chk(int x) {
for (int i = (1); i <= (n); i++) {
if (x % a[i].first) return 0;
int y = x / a[i].first;
while (y != 1) {
if (y % a[i].second || a[i].second == 1) return 0;
y /= a[i].second;
}
}
return 1;
}
bool chk(int x, int i, int y) {
int u = (i * log(a[x].second) + log(a[x].first) - log(a[y].first)) /
log(a[y].second) +
0.5;
for (int k = (max(0, u - 10)); k <= (min(1919, u + 10)); k++) {
int ty = 1;
for (int l = (1); l <= (7); l++) {
int md = P[l];
if (msk(a[x].second, i, a[x].first, md) !=
msk(a[y].second, k, a[y].first, md)) {
ty = 0;
break;
}
}
if (ty) return 1;
}
return 0;
}
void sol(int x, int y) {
for (int i = (0); i <= (1919); i++) {
if (chk(x, i, y)) {
int ty = 1;
for (int j = (1); j <= (n); j++)
if (!chk(x, i, j)) {
ty = 0;
break;
}
if (ty) {
printf("%lld", msk(a[x].second, i, a[x].first, 1e9 + 7));
exit(0);
}
}
}
{
puts("-1");
exit(0);
};
}
void chai(int x) {
mp.clear();
for (int i = 2; i <= sqrt(x); ++i)
while (x % i == 0) x /= i, mp[i]++;
if (x > 1) mp[x]++;
}
int main() {
scanf("%d", &n);
srand(time(0));
for (int i = (1); i <= (n); i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + n + 1);
if (chk(a[n].first)) {
printf("%d", a[n].first);
return 0;
}
for (int i = (1); i <= (n); i++) {
chai(a[i].second);
s[i] = 1;
for (auto& j : mp) t[i] = gcd(t[i], j.second);
for (auto& j : mp) {
j.second /= t[i];
for (int k = (0); k <= (j.second - 1); k++) s[i] *= j.first;
}
if (s[i] != s[1]) sol(1, i);
}
long long md = 1, al = 0;
for (int i = (1); i <= (n); i++) {
r[i] = a[i].first;
while (!(r[i] % s[i])) r[i] /= s[i], p[i]++;
if (r[i] != r[1]) {
puts("-1");
exit(0);
};
long long x = gcd(t[i], md);
if (al % x != p[i] % x) {
puts("-1");
exit(0);
};
while (al % t[i] != p[i] % t[i]) al += md;
md = md / x * t[i];
al %= md;
}
for (int i = (1); i <= (n); i++)
while (al < p[i]) al += md;
printf("%lld\n", msk(s[1], al, r[1], 1e9 + 7));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105, L = 1e3 + 5;
const int mod = 1e9 + 7;
int n, va[N], vb[N], cta[N][L], ctb[N][L];
namespace utils {
template <class T>
inline void apn(T &x, const T y) {
x = x < y ? x : y;
}
template <class T>
inline void apx(T &x, const T y) {
x = x > y ? x : y;
}
inline int nxi() {
int x = 0;
char c;
while (((c = getchar()) > '9' || c < '0') && c != '-')
;
const bool f = c == '-' && (c = getchar());
while (x = x * 10 - 48 + c, (c = getchar()) >= '0' && c <= '9')
;
return f ? -x : x;
}
} // namespace utils
using namespace utils;
namespace D {
int cnt, v[L];
inline void add(const int x) { v[++cnt] = x; }
inline void build() {
sort(v + 1, v + cnt + 1);
cnt = unique(v + 1, v + cnt + 1) - v - 1;
}
inline int ask(const int x) { return lower_bound(v + 1, v + cnt + 1, x) - v; }
} // namespace D
void getzyz(int x) {
for (int i = 2; i <= 3.5e4; ++i) {
if (x % i) continue;
D::add(i);
while (x % i == 0) x /= i;
}
if (x > 1) D::add(x);
}
int qcnt(int t, const int z) {
int ans = 0;
assert(t);
for (; t % z == 0; t /= z, ++ans)
;
return ans;
}
inline int fpow(int x, long long t) {
int ans = 1;
for (; t; x = (long long)x * x % mod, t >>= 1) {
if (t & 1) ans = (long long)ans * x % mod;
}
return ans;
}
inline long long smul(long long x, long long y, const long long mod) {
long long ans = 0;
bool f = (y < 0) ^ (x < 0);
if (y < 0) y = -y;
for (; y; x = x * 4 % mod, y >>= 2) {
ans = (ans + x * (y & 3)) % mod;
}
ans = f ? mod - ans : ans;
return ans;
}
int qans(const int p, const long long tot) {
static long long tgt[L];
int ans = va[p];
for (int i = 1; i <= D::cnt; ++i) {
tgt[i] = qcnt(va[p], D::v[i]) + qcnt(vb[p], D::v[i]) * tot;
while (ans % D::v[i] == 0) ans /= D::v[i];
}
for (int i = 1; i <= n; ++i) {
int cc = -1;
for (int j = 1; j <= D::cnt; ++j) {
int wa = qcnt(va[i], D::v[j]), wb = qcnt(vb[i], D::v[j]);
if (!wb) {
if (wa != tgt[j]) return -1;
continue;
}
long long curt = tgt[j] - wa;
if (curt < 0 || curt % wb) {
return -1;
}
curt /= wb;
if (cc == -1)
cc = curt;
else if (cc != curt)
return -1;
}
}
for (int i = 1; i <= D::cnt; ++i) {
ans = (long long)ans * fpow(D::v[i], tgt[i]) % mod;
}
return ans;
}
bool san0() {
for (int i = 1; i <= D::cnt; ++i) {
for (int j = 1; j <= n; ++j) {
if (vb[j] % D::v[i] == 0) continue;
int tgt = qcnt(va[j], D::v[i]), p = 1;
for (; p <= n && vb[p] % D::v[i]; ++p)
;
if (p > n) {
for (int k = 2; k <= n; ++k) {
if (qcnt(va[k], D::v[i]) != qcnt(va[1], D::v[i]))
return puts("-1"), 0;
}
for (int k = i + 1; k <= D::cnt; ++k) {
D::v[k - 1] = D::v[k];
}
--D::cnt, --i;
break;
}
int tot = tgt - qcnt(va[p], D::v[i]);
if (tot % qcnt(vb[p], D::v[i])) return puts("-1"), 0;
tot /= qcnt(vb[p], D::v[i]);
return printf("%d\n", qans(p, tot)), 0;
}
}
return 1;
}
bool sanmulp() {
using namespace D;
for (int i = 2; i <= cnt; ++i) {
for (int j = 2; j <= n; ++j) {
if (ctb[1][i] * ctb[j][1] == ctb[1][1] * ctb[j][i]) {
int tmp1 = cta[1][i] * ctb[1][1] - ctb[1][i] * cta[1][1];
int tmp2 = cta[j][i] * ctb[1][1] - ctb[1][i] * cta[j][1];
if (tmp1 != tmp2) return puts("-1"), 0;
} else {
int numj = cta[1][i] * ctb[1][1] - cta[1][1] * ctb[1][i];
numj -= cta[j][i] * ctb[1][1] - cta[j][1] * ctb[1][i];
int denomj = ctb[j][i] * ctb[1][1] - ctb[j][1] * ctb[1][i];
if (numj % denomj || numj / denomj < 0) return puts("-1"), 0;
return printf("%d\n", qans(j, numj / denomj)), 0;
}
}
}
return 1;
}
long long exgcd(long long x, long long y, long long &a, long long &b) {
if (!y) {
a = 1, b = 0;
return x;
}
long long res = exgcd(y, x % y, a, b), tmp = a - (x / y) * b;
a = b, b = tmp;
return res;
}
bool merge(long long &m1, long long &r1, long long m2, long long r2) {
long long a, b, g = exgcd(m1, -m2, a, b);
if ((r2 - r1) % g) return 0;
m1 = m1 / g * m2;
if (m1 < 0) m1 = -m1;
a = smul(a, (r2 - r1) / g, m1), b = smul(b, (r2 - r1) / g, m1);
r1 = ((smul(b, m2, m1) + r2) % m1 + m1) % m1;
return 1;
}
int main() {
n = nxi();
for (int i = 1; i <= n; ++i) {
va[i] = nxi(), vb[i] = nxi();
getzyz(va[i]), getzyz(vb[i]);
}
D::build();
if (!san0()) return 0;
if (!D::cnt) return printf("%d\n", qans(1, 0)), 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= D::cnt; ++j) {
cta[i][j] = qcnt(va[i], D::v[j]);
ctb[i][j] = qcnt(vb[i], D::v[j]);
}
}
if (!sanmulp()) return 0;
{
long long st = 1, rs = 0;
for (int i = 1; i <= n; ++i) {
int si = ctb[i][1], ri = cta[i][1] % si;
if (!merge(st, rs, si, ri)) return puts("-1"), 0;
}
for (int i = 1; i <= n; ++i) {
while (rs < cta[i][1]) rs += st;
}
for (int i = 1; i <= n; ++i) {
assert((rs - cta[i][1]) % ctb[i][1] == 0);
}
printf("%d\n", qans(1, (rs - cta[1][1]) / ctb[1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long msk(long long a, long long b, long long k, int md) {
a %= md;
k %= md;
while (b) {
if (b & 1) k = k * a % md;
a = a * a % md;
b >>= 1;
}
return k;
}
pair<int, int> a[N];
map<int, int> mp;
int n;
long long t[N], s[N], r[N], p[N];
bool chk(int x) {
for (int i = (1); i <= (n); i++) {
if (x % a[i].first) return 0;
int y = x / a[i].first;
while (y != 1) {
if (y % a[i].second || a[i].second == 1) return 0;
y /= a[i].second;
}
}
return 1;
}
bool chk(int x, int i, int y) {
int u = (i * log(a[x].second) + log(a[x].first) - log(a[y].first)) /
log(a[y].second) +
0.5;
for (int k = (max(0, u - 10)); k <= (min(1919, u + 10)); k++) {
int ty = 1;
for (int l = (0); l <= (4); l++) {
int md = rand() % 1919810 + 1e9;
if (msk(a[x].second, i, a[x].first, md) !=
msk(a[y].second, k, a[y].first, md)) {
ty = 0;
break;
}
}
if (ty) return 1;
}
return 0;
}
void sol(int x, int y) {
for (int i = (0); i <= (1919); i++) {
if (chk(x, i, y)) {
int ty = 1;
for (int j = (1); j <= (n); j++)
if (!chk(x, i, j)) {
ty = 0;
break;
}
if (ty) {
printf("%lld", msk(a[x].second, i, a[x].first, 1e9 + 7));
exit(0);
}
}
}
{
puts("-1");
exit(0);
};
}
void chai(int x) {
mp.clear();
for (int i = 2; i <= sqrt(x); ++i)
while (x % i == 0) x /= i, mp[i]++;
if (x > 1) mp[x]++;
}
int main() {
scanf("%d", &n);
srand(time(0));
for (int i = (1); i <= (n); i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + n + 1);
if (chk(a[n].first)) {
printf("%d", a[n].first);
return 0;
}
for (int i = (1); i <= (n); i++) {
chai(a[i].second);
s[i] = 1;
for (auto& j : mp) t[i] = gcd(t[i], j.second);
for (auto& j : mp) {
j.second /= t[i];
for (int k = (0); k <= (j.second - 1); k++) s[i] *= j.first;
}
if (s[i] != s[1]) sol(1, i);
}
long long md = 1, al = 0;
for (int i = (1); i <= (n); i++) {
r[i] = a[i].first;
while (!(r[i] % s[i])) r[i] /= s[i], p[i]++;
if (r[i] != r[1]) {
puts("-1");
exit(0);
};
long long x = gcd(t[i], md);
if (al % x != p[i] % x) {
puts("-1");
exit(0);
};
while (al % t[i] != p[i] % t[i]) al += md;
md = md / x * t[i];
al %= md;
}
for (int i = (1); i <= (n); i++)
while (al < p[i]) al += md;
printf("%lld\n", msk(s[1], al, r[1], 1e9 + 7));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y), t = x;
x = y, y = t - a / b * y;
return g;
}
long long mypow(long long a, long long n) {
long long ans = 1;
a %= mod;
for (long long i = n; i; i >>= 1, a = a * a % mod)
if (i & 1) ans = ans * a % mod;
return ans;
}
const int maxn = 110, maxp = 2010;
int p[maxp], pn;
int a[maxn][maxp], b[maxn][maxp], n;
bool init() {
static int u[maxn], v[maxn];
scanf("%d", &n), pn = 0;
for (int i = 1, x, y; i <= n; ++i) {
scanf("%d%d", u + i, v + i);
for (x = u[i], y = 2; y <= x / y; ++y)
if (x % y == 0)
for (p[++pn] = y; x % y == 0; x /= y)
;
if (x != 1) p[++pn] = x;
for (x = v[i], y = 2; y <= x / y; ++y)
if (x % y == 0)
for (p[++pn] = y; x % y == 0; x /= y)
;
if (x != 1) p[++pn] = x;
}
if (n == 1) {
printf("%d\n", u[1]);
return true;
}
sort(p + 1, p + pn + 1), pn = unique(p + 1, p + pn + 1) - p - 1;
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= pn; ++j)
while (u[i] % p[j] == 0) ++b[i][j], u[i] /= p[j];
for (int j = 1; j <= pn; ++j)
while (v[i] % p[j] == 0) ++a[i][j], v[i] /= p[j];
}
return false;
}
struct equation {
long long A, B, C;
equation() : A(0), B(0), C(0) {}
equation(long long newA, long long newB, long long newC)
: A(newA), B(newB), C(newC) {}
};
bool empty(equation &t) {
if (!t.A && !t.B) return t.C;
long long g = gcd(abs(t.A), abs(t.B));
if (t.C % g) return true;
t.A /= g, t.B /= g, t.C /= g;
return false;
}
int merge(equation p, equation q, long long &x, long long &y) {
long long D = p.A * q.B - p.B * q.A;
x = p.C * q.B - q.C * p.B, y = p.A * q.C - p.C * q.A;
if (D) {
if (x % D || y % D) {
x = -1, y = -1;
return -1;
}
x /= D, y /= D;
return +1;
}
if (x || y) {
x = -1, y = -1;
return -1;
}
return 0;
}
long long check(long long x) {
if (x < 0) return -1;
for (int i = 2; i <= n; ++i) {
vector<long long> s;
s.clear();
for (int u = 1; u <= pn; ++u) {
long long z = a[1][u] * x + b[1][u] - b[i][u];
if (a[i][u]) {
if (z % a[i][u]) return -1;
s.push_back(z / a[i][u]);
} else if (z)
return -1;
}
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
if (s.size() > 1 || (s.size() == 1 && s.front() < 0)) return -1;
}
long long ans = 1;
for (int i = 1; i <= pn; ++i)
ans = ans * mypow(p[i], a[1][i] * x + b[1][i]) % mod;
return ans;
}
void solve() {
long long x = 0, y = 0;
bool find = false;
for (int i = 2; !find && i <= n; ++i)
for (int u = 1; !find && u <= pn; ++u) {
equation p(a[1][u], -a[i][u], b[i][u] - b[1][u]);
if (empty(p)) {
puts("-1");
return;
}
if (!p.B && p.A) {
x = p.C / p.A, find = true;
break;
}
for (int v = u + 1; v <= pn; ++v) {
equation q(a[1][v], -a[i][v], b[i][v] - b[1][v]);
int t = merge(p, q, x, y);
if (t == +1) {
find = true;
break;
}
if (t == -1) {
puts("-1");
return;
}
}
}
if (find) {
printf("%I64d\n", check(x));
return;
}
static long long c[maxn], d[maxn];
int m = 0;
long long minx = 0;
for (int i = 2; i <= n; ++i) {
for (int u = 1; u <= pn; ++u)
if (a[1][u]) {
long long A = a[1][u], B = a[i][u], C = b[i][u] - b[1][u];
long long g = exgcd(A, B, x, y);
++m;
minx = max(minx, (long long)ceil(1.0 * C / A));
c[m] = (C / g) * x % B, d[m] = B / g;
break;
}
}
for (int i = 2; i <= m; ++i) {
long long A = d[1], B = d[i], C = c[i] - c[1];
long long g = exgcd(A, B, x, y);
if (C % g) {
puts("-1");
return;
}
x = x * (C / g) % B;
c[1] = c[1] + x * A, d[1] = A / g * B;
c[1] %= d[1];
if (c[1] < 0) c[1] += d[1];
}
c[1] += ceil(1.0 * (minx - c[1]) / d[1]);
printf("%I64d\n", check(c[1]));
}
int main() {
if (!init()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105, MOD = 1000 * 1000 * 1000 + 7;
int n;
map<int, long long> a[MAXN], b[MAXN];
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
pair<long long, long long> extGcd(long long x, long long y) {
if (!y) return make_pair(1, 0);
pair<long long, long long> p = extGcd(y, x % y);
return make_pair(p.second, p.first - (x / y) * p.second);
}
int powMod(int x, long long p) {
int y = 1;
while (p) {
if (p & 1ll) y = (long long)y * x % MOD;
p >>= 1;
x = (long long)x * x % MOD;
}
return y;
}
void fact(int x, map<int, long long> &mp) {
for (int i = 2; i * i <= x; i++)
if (!(x % i)) {
int y = 0;
while (!(x % i)) {
x /= i;
y++;
}
mp[i] = y;
}
if (x > 1) mp[x] = 1;
}
bool intersect(long long &a0, long long &b0, long long a1, long long b1) {
long long c = a1 - a0, g = gcd(b0, b1);
if (c % g) return false;
pair<long long, long long> p = extGcd(b0, b1);
p.first *= c / g;
p.second *= -c / g;
long long lcm = b0 / g * b1;
if (p.first < 0) {
long long k = (-p.first + (lcm / b0) - 1) / (lcm / b0);
p.first += k * (lcm / b0);
p.second += k * (lcm / b1);
}
long long k = p.first / (lcm / b0);
p.first -= k * (lcm / b0);
p.second -= k * (lcm / b1);
if (p.second < 0) {
k = (-p.second + (lcm / b1) - 1) / (lcm / b1);
p.first += k * (lcm / b0);
p.second += k * (lcm / b1);
}
a0 = a0 + b0 * p.first;
b0 = lcm;
return true;
}
map<int, long long> get(int id, long long k) {
map<int, long long> mp;
for (map<int, long long>::iterator it = a[id].begin(); it != a[id].end();
it++)
if (it->second) mp[it->first] = it->second;
if (k)
for (map<int, long long>::iterator it = b[id].begin(); it != b[id].end();
it++)
mp[it->first] += k * it->second;
return mp;
}
bool check(const map<int, long long> &mp) {
for (int i = 0; i < n; i++) {
long long k;
if (b[i].empty())
k = 0;
else {
int p = b[i].begin()->first;
long long aa = a[i][p], bb = b[i].begin()->second;
k = (mp.find(p) == mp.end() ? 0 : mp.find(p)->second) - aa;
if (k < 0 || k % bb) return false;
k /= bb;
}
map<int, long long> mp0 = get(i, k);
if (mp != mp0) return false;
}
return true;
}
void getAns(int id, long long k) {
map<int, long long> mp = get(id, k);
if (!check(mp)) {
cout << -1 << '\n';
return;
}
int ans = 1;
for (map<int, long long>::iterator it = mp.begin(); it != mp.end(); it++)
ans = (long long)ans * powMod(it->first, it->second) % MOD;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int aa, bb;
cin >> aa >> bb;
fact(aa, a[i]);
fact(bb, b[i]);
for (map<int, long long>::iterator it = b[i].begin(); it != b[i].end();
it++)
a[i][it->first];
}
for (int i = 0; i < n; i++)
if (b[i].empty()) {
getAns(i, 0);
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
long long aa = -1, bb = -1, cc = -1;
for (map<int, long long>::iterator it = b[i].begin(); it != b[i].end();
it++) {
int p = it->first;
long long a0 = a[i][p], b0 = it->second,
a1 = (a[j].find(p) == a[j].end() ? 0 : a[j][p]),
b1 = (b[j].find(p) == b[j].end() ? 0 : b[j][p]);
if (b1 == 0) {
if (a1 < a0 || (a1 - a0) % b0)
cout << -1 << '\n';
else
getAns(i, (a1 - a0) / b0);
return 0;
}
long long na = b0, nb = -b1, nc = a1 - a0, g = gcd(b0, b1);
if (nc % g) {
cout << -1 << '\n';
return 0;
}
na /= g;
nb /= g;
nc /= g;
if (aa == -1) {
aa = na;
bb = nb;
cc = nc;
continue;
}
if (aa == na && bb == nb && cc == nc) continue;
long long x = nb * cc - bb * nc, y = aa * nb - na * bb;
if (!y || x % y || x / y < 0) {
cout << -1 << '\n';
return 0;
}
getAns(i, x / y);
return 0;
}
}
int p = b[0].begin()->first;
long long aa = a[0][p], bb = b[0].begin()->second;
for (int i = 1; i < n; i++)
if (!intersect(aa, bb, a[i][p], b[i][p])) {
cout << -1 << '\n';
return 0;
}
getAns(0, (aa - a[0][p]) / b[0].begin()->second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rand_small() { return rand() % 32768; }
inline long long rand_big() { return 32768 * rand_small() + rand_small(); }
const int N = 105;
const long long mod = 1000000007ll;
const double eps = 1e-7;
long long gcd(long long x, long long y) {
if (x < y) swap(x, y);
return y ? gcd(y, x % y) : x;
}
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
long long qpow(long long x, long long y) {
long long res = 1ll;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod, y >>= 1;
}
return res;
}
int n, pos = -1, t[N], r[N];
long long a[N], b[N], b_[N];
void solve1() {
bool has_sol = true;
for (int i = 0; i < n; i++) {
if (!has_sol) break;
if (b[i] == 1ll && a[i] != a[pos]) has_sol = false;
if (b[i] > 1ll) {
long long now = a[i];
has_sol = false;
for (int j = 0; j <= (int)ceil(log(1.0 * a[pos]) / log(2.0));
j++, now *= b[i]) {
if (now == a[pos]) has_sol = true;
}
}
}
if (has_sol)
printf("%lld\n", a[pos] % mod);
else
printf("-1\n");
}
void init2() {
for (int i = 0; i < n; i++) {
for (int j = 1; j <= (int)ceil(log(1.0 * b[i]) / log(2.0)); j++) {
long long rt = (long long)floor(pow(b[i], 1.0 / j) + 0.5);
if (fabs(pow(rt, j) - b[i]) < eps) t[i] = j, b_[i] = rt;
}
}
}
void solve2(int x) {
long long m = rand_big() + 1ll, num1 = a[0] % m, num2 = a[x] % m, num = -1;
int posi, posj,
T = (int)ceil(log(1.0 * a[0]) + log(1.0 * a[x]) +
log(1.0 * b[0]) * log(1.0 * b[x]))
<< 2;
for (int i = 0; i < T; i++, num1 = num1 * b[0] % m) {
num2 = a[x] % m;
for (int j = 0; j < T; j++, num2 = num2 * b[x] % m) {
if (num1 == num2) {
posi = i, posj = j;
num = num1;
}
}
}
bool has_sol = (num >= 0ll);
for (int i = 0; i < n; i++) {
long long tmp = a[i] % m;
if (!has_sol) break;
has_sol = false;
for (int j = 0; j <= (int)ceil(T * log(1.0 * b[0]) / log(2.0));
j++, tmp = tmp * b[i] % m) {
if (tmp == num) {
has_sol = true;
break;
}
}
}
if (has_sol) {
num = a[0] % mod;
for (int i = 0; i < posi; i++) num = num * b[0] % mod;
printf("%lld\n", num);
} else
printf("-1\n");
}
int main() {
srand(clock());
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
if (b[i] == 1ll) pos = i;
}
if (~pos)
solve1();
else {
init2();
bool flag = false;
for (int i = 1; i < n; i++) {
if (b_[i] != b_[0]) {
flag = true, solve2(i);
break;
}
}
if (!flag) {
for (int i = 0; i < n; i++) {
r[i] = 0;
while (a[i] % b_[i] == 0ll) r[i]++, a[i] /= b_[i];
}
bool has_sol = true;
long long L = t[0], ans = r[0];
for (int i = 1; i < n; i++) {
if (a[i] != a[0]) has_sol = false;
}
for (int i = 1; i < n; i++) {
if (!has_sol) break;
has_sol = false;
for (int j = 0; j < t[i]; j++) {
if ((ans + L * j) % t[i] == r[i] % t[i]) {
has_sol = true, ans += L * j;
break;
}
}
L = lcm(L, t[i]);
}
if (!has_sol)
printf("-1\n");
else {
int mx = r[0];
for (int i = 1; i < n; i++) mx = max(mx, r[i]);
while (ans < mx) ans += L;
printf("%lld\n", a[0] * qpow(b_[0], ans) % mod);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2111;
const int mod = 1e9 + 7;
int n;
int pri[N], tot;
long long a[N], b[N];
struct node {
long long k, b;
node(long long _k = 0, long long _b = 0) {
k = _k;
b = _b;
}
} f[N], g[N];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long ksm(long long base, long long x) {
long long ans = 1;
while (x) {
if (x & 1) ans = ans * base % mod;
base = base * base % mod;
x >>= 1;
}
return ans;
}
void get(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
pri[++tot] = i;
while (x % i == 0) x /= i;
}
}
if (x > 1) pri[++tot] = x;
}
void get_g(int id) {
for (int i = 1; i <= tot; i++) {
g[i].b = g[i].k = 0;
while (a[id] % pri[i] == 0) {
g[i].b++;
a[id] /= pri[i];
}
while (b[id] % pri[i] == 0) {
g[i].k++;
b[id] /= pri[i];
}
}
}
long long ex_gcd(long long A, long long B, long long &x, long long &y) {
if (!B) {
x = 1;
y = 0;
return A;
}
long long xx, yy;
long long d = ex_gcd(B, A % B, xx, yy);
x = yy;
y = xx - A / B * yy;
return d;
}
bool merge() {
bool flag = 0;
for (int t = 0; t < 3; t++) {
for (int i = 1; i <= tot; i++) {
long long fk = f[i].k, fb = f[i].b;
long long gk = g[i].k, gb = g[i].b;
bool fl = 0;
if (!fk && !gk) {
if (fb != gb) return 0;
} else {
if (!gk || !fk) {
if (!fk) swap(fk, gk), swap(fb, gb), fl = 1;
if (fb > gb || (gb - fb) % fk != 0) return 0;
long long k = (gb - fb) / fk;
if (fl)
for (int j = 1; j <= tot; j++) g[j].b += g[j].k * k, g[j].k = 0;
else
for (int j = 1; j <= tot; j++) f[j].b += f[j].k * k, f[j].k = 0;
flag = 1;
}
}
}
}
if (flag) return 1;
int fl = 0;
long long A = 0, B = 0, C = 0;
for (int i = 1; i <= tot; i++) {
if (!f[i].k || !g[i].k) continue;
if (!fl)
A = f[i].k, B = -g[i].k, C = g[i].b - f[i].b, fl = 1;
else if (fl == 1) {
long long nA = f[i].k, nB = -g[i].k, nC = g[i].b - f[i].b;
long long d = gcd(nA, A);
A *= nA / d;
B *= nA / d;
C *= nA / d;
nA *= A / d;
nB *= A / d;
nC *= A / d;
if (B == nB) {
if (C != nC) return 0;
long long d = gcd(A, gcd(abs(B), abs(C)));
A /= d;
B /= d;
C /= d;
continue;
} else {
if ((C - nC) % (B - nB)) return 0;
long long y = (C - nC) / (B - nB);
if (y < 0) return 0;
if ((C - B * y) % A) return 0;
long long x = (C - B * y) / A;
if (x < 0) return 0;
for (int j = 1; j <= tot; j++) f[j].b += f[j].k * x, f[j].k = 0;
for (int j = i + 1; j <= tot; j++) {
nA = f[j].k, nB = -g[j].k, nC = g[j].b - f[j].b;
if (nA * x + nB * y != nC) return 0;
}
return 1;
}
}
}
long long x = -1, y = -1;
long long d = ex_gcd(A, -B, x, y);
if (C % d) return 0;
y *= -1;
long long kx = (-B) / d;
long long ky = A / d;
x *= C / d, y *= C / d;
long long tx = x < 0 ? -(-x + kx - 1) / kx : x / kx;
long long ty = y < 0 ? -(-y + ky - 1) / ky : y / ky;
x -= min(tx, ty) * kx;
y -= min(tx, ty) * ky;
for (int i = 1; i <= tot; i++) {
f[i].b += f[i].k * x;
f[i].k = f[i].k * kx;
}
return 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
get(a[i]);
get(b[i]);
}
sort(pri + 1, pri + 1 + tot);
tot = unique(pri + 1, pri + 1 + tot) - (pri + 1);
for (int i = 1; i <= tot; i++) {
while (a[1] % pri[i] == 0) {
f[i].b++;
a[1] /= pri[i];
}
while (b[1] % pri[i] == 0) {
f[i].k++;
b[1] /= pri[i];
}
}
for (int i = 2; i <= n; i++) {
get_g(i);
if (!merge()) {
puts("-1");
return 0;
}
}
int ans = 1;
for (int i = 1; i <= tot; i++) {
ans = 1LL * ans * ksm(pri[i], f[i].b) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxp = 31623;
bool isprimes[maxp + 1];
vector<int> primes;
int n;
vector<pair<int, long long> > fa[100], fb[100];
pair<int, int> x[100];
struct Point {
long long x, y;
Point(long long x = 0, long long y = 0) : x(x), y(y) {}
};
long long powmod(long long a, long long k) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
k >>= 1;
}
return ret;
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = exgcd(b, a % b, y, x);
y -= x * (a / b);
return d;
}
long long find(const vector<pair<int, long long> >& f, int p) {
int pos = lower_bound(f.begin(), f.end(), make_pair(p, -1ll)) - f.begin();
if (pos != f.size() && f[pos].first == p) {
return f[pos].second;
}
return 0;
}
vector<pair<int, long long> > factor(int x) {
vector<pair<int, long long> > ret;
for (int i = 0; i < primes.size() && x > 1; ++i) {
long long cnt = 0;
while (x % primes[i] == 0) {
cnt++;
x /= primes[i];
}
if (cnt) {
ret.push_back(make_pair(primes[i], cnt));
}
}
if (x > 1) {
ret.push_back(make_pair(x, 1));
}
return ret;
}
int main() {
memset(isprimes, true, sizeof isprimes);
for (int i = 2; i <= maxp; ++i) {
if (isprimes[i]) {
primes.push_back(i);
for (int j = i * i; j <= maxp; j += i) {
isprimes[j] = false;
}
}
}
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &x[i].first, &x[i].second);
}
sort(x, x + n);
n = unique(x, x + n) - x;
for (int i = 0; i < n; ++i) {
fa[i] = factor(x[i].first);
fb[i] = factor(x[i].second);
}
bool flag = true;
int pos = n;
for (int k = pos - 1; k >= 1 && flag; k = pos - 1) {
pos = 0;
for (int i = 0; i < k && flag; ++i) {
vector<int> v;
for (int j = 0; j < fa[i].size(); ++j) {
if (fa[i][j].second) {
v.push_back(fa[i][j].first);
}
}
for (int j = 0; j < fa[i + 1].size(); ++j) {
if (fa[i + 1][j].second) {
v.push_back(fa[i + 1][j].first);
}
}
for (int j = 0; j < fb[i].size(); ++j) {
if (fb[i][j].second) {
v.push_back(fb[i][j].first);
}
}
for (int j = 0; j < fb[i + 1].size(); ++j) {
if (fb[i + 1][j].second) {
v.push_back(fb[i + 1][j].first);
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
Point p(-1, -1);
Point s(-1, -1);
Point must(-1, -1);
for (int j = 0; j < v.size(); ++j) {
long long a1 = find(fa[i], v[j]);
long long a2 = find(fa[i + 1], v[j]);
long long b1 = find(fb[i], v[j]);
long long b2 = find(fb[i + 1], v[j]);
long long x, y, dx, dy;
long long d = exgcd(b1, -b2, x, y);
if (b1 == 0 && b2 == 0) {
if (a1 != a2) {
flag = false;
break;
}
continue;
} else if (b1 == 0) {
if (a1 >= a2 && (a1 - a2) % b2 == 0) {
y = (a1 - a2) / b2;
if (must.y != -1 && must.y != y) {
flag = false;
break;
}
must.y = y;
} else {
flag = false;
break;
}
} else if (b2 == 0) {
if (a2 >= a1 && (a2 - a1) % b1 == 0) {
x = (a2 - a1) / b1;
if (must.x != -1 && must.x != x) {
flag = false;
break;
}
must.x = x;
} else {
flag = false;
break;
}
} else if ((a2 - a1) % d == 0) {
x *= (a2 - a1) / d;
y *= (a2 - a1) / d;
dx = b2 / abs(d);
dy = b1 / abs(d);
if (x > 0) {
if (dx != 0) {
long long t = (x - 1) / dx + 1;
x -= t * dx;
y -= t * dy;
}
}
if (y > 0) {
if (dy != 0) {
long long t = (y - 1) / dy + 1;
x -= t * dx;
y -= t * dy;
}
}
if (x < 0) {
if (dx == 0) {
flag = false;
break;
}
long long t = (-x - 1) / dx + 1;
x += t * dx;
y += t * dy;
}
if (y < 0) {
if (dy == 0) {
flag = false;
break;
}
long long t = (-y - 1) / dy + 1;
x += t * dx;
y += t * dy;
}
if (p.x == -1 && p.y == -1) {
p = Point(x, y);
s = Point(dx, dy);
} else {
if (s.x == 0 && s.y == 0) {
if (p.x < x || p.y < y || (p.x - x) * dy - dx * (p.y - y) != 0) {
flag = false;
break;
}
} else {
if (s.x == dx && s.y == dy) {
if ((p.x - x) * dy - dx * (p.y - y) != 0) {
flag = false;
break;
}
if (p.x < x) {
p = Point(x, y);
}
} else {
long long k1 = (x * dy - y * dx + dx * p.y - dy * p.x) /
(s.x * dy - s.y * dx);
long long nx = p.x + s.x * k1;
long long ny = p.y + s.y * k1;
if (nx < x || ny < y || (nx - x) * dy - dx * (ny - y) != 0) {
flag = false;
break;
}
p = Point(nx, ny);
s = Point(0, 0);
}
}
}
} else {
flag = false;
break;
}
}
if (flag) {
if (p.x == -1 && p.y == -1) {
if (must.x == -1 && must.y == -1) {
continue;
} else if (must.x == -1) {
p.x = 0;
s.x = 1;
} else {
p.x = must.x;
s.x = 0;
}
} else {
if (must.x != -1 && must.y != -1) {
if (s.x == 0 && s.y == 0 && (p.x != must.x || p.y != must.y)) {
flag = false;
break;
}
if (must.x < p.x || must.y < p.y ||
(must.x - p.x) * s.y - s.x * (must.y - p.y) != 0) {
flag = false;
break;
}
p.x = must.x;
s.x = 0;
} else if (must.x != -1) {
if (must.x < p.x || (s.x != 0 && (must.x - p.x) % s.x != 0) ||
(s.x == 0 && must.x != p.x)) {
flag = false;
break;
}
p.x = must.x;
s.x = 0;
} else if (must.y != -1) {
if (must.y < p.y || (s.y != 0 && (must.y - p.y) % s.y != 0) ||
(s.y == 0 && must.y != p.y)) {
flag = false;
break;
}
if (s.y != 0) {
long long t = (must.y - p.y) / s.y;
p.x = p.x + t * s.x;
s.x = 0;
}
}
}
vector<pair<int, long long> > nfa;
vector<pair<int, long long> > nfb;
for (int j = 0; j < v.size(); ++j) {
long long a1 = find(fa[i], v[j]);
long long b1 = find(fb[i], v[j]);
if (b1 * p.x + a1) {
nfa.push_back(make_pair(v[j], b1 * p.x + a1));
}
if (b1 * s.x) {
nfb.push_back(make_pair(v[j], b1 * s.x));
}
}
fa[pos] = nfa;
fb[pos++] = nfb;
}
}
}
if (flag) {
long long ans = 1;
for (int i = 0; i < fa[0].size(); ++i) {
ans = ans * powmod(fa[0][i].first, fa[0][i].second) % mod;
}
printf("%I64d\n", ans);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
const int Mod = 1000000007;
inline int qPow(int b, long long e) {
int a = 1;
for (; e; e >>= 1, b = (long long)b * b % Mod)
if (e & 1) a = (long long)a * b % Mod;
return a;
}
int Gcd(long long a, long long b) { return b ? Gcd(b, a % b) : a; }
int exGcd(long long a, long long b, long long &x, long long &y) {
if (!b) return x = 1, y = 0, a;
long long d = exGcd(b, a % b, y, x);
return y -= a / b * x, d;
}
const int MN = 105, MS = 905;
int N, A[MN], B[MN];
int pr[MS], pc;
long long a[MS], b[MS], c[MS], d[MS];
inline void X(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
pr[++pc] = i;
while (x % i == 0) x /= i;
}
if (x > 1) pr[++pc] = x;
}
inline void Z(int x, long long *C) {
for (int i = 1; i <= pc; ++i) {
int p = pr[i];
C[i] = 0;
while (x % p == 0) x /= p, ++C[i];
}
}
inline int Merge() {
long long Sb = 0, Sd = 0;
for (int i = 1; i <= pc; ++i) Sb += b[i], Sd += d[i];
if (!Sb && !Sd) {
for (int i = 1; i <= pc; ++i)
if (a[i] != c[i]) return 0;
return 1;
}
if (!Sb || !Sd) {
if (!Sd) std::swap(a, c), std::swap(b, d), std::swap(Sb, Sd);
long long k = 0;
for (int i = 1; i <= pc; ++i)
if (d[i]) {
k = (a[i] >= c[i] && (a[i] - c[i]) % d[i] == 0) ? (a[i] - c[i]) / d[i]
: -1;
break;
} else if (a[i] != c[i])
return 0;
if (k == -1) return 0;
for (int i = 1; i <= pc; ++i)
if (c[i] + k * d[i] != a[i]) return 0;
return 1;
}
int ok = 0;
for (int i = 1; i <= pc; ++i)
if (b[i] * Sd != d[i] * Sb) {
ok = i;
break;
}
if (ok) {
int p1 = ok, p2 = 0;
for (int i = 1; i <= pc; ++i)
if (b[i] * d[p1] != d[i] * b[p1]) {
p2 = i;
break;
}
long long ka = d[p2] * (c[p1] - a[p1]) - d[p1] * (c[p2] - a[p2]);
long long kc = b[p2] * (c[p1] - a[p1]) - b[p1] * (c[p2] - a[p2]);
long long denom = d[p2] * b[p1] - d[p1] * b[p2];
if (denom < 0) ka = -ka, kc = -kc, denom = -denom;
if (ka < 0 || kc < 0 || ka % denom != 0 || kc % denom != 0) return 0;
ka /= denom, kc /= denom;
for (int i = 1; i <= pc; ++i) {
if (a[i] + ka * b[i] != c[i] + kc * d[i]) return 0;
a[i] = a[i] + ka * b[i], b[i] = 0;
}
return 1;
}
long long kb = 0, kd = 0;
for (int i = 1; i <= pc; ++i)
if (b[i]) {
long long g = Gcd(b[i], d[i]);
kb = b[i] / g, kd = d[i] / g;
break;
}
long long k = 0;
for (int i = 1; i <= pc; ++i)
if (b[i]) {
if ((a[i] - c[i]) % (b[i] / kb)) return 0;
k = (a[i] - c[i]) / (b[i] / kb);
break;
}
for (int i = 1; i <= pc; ++i)
if (c[i] + k * (b[i] / kb) != a[i]) return 0;
if (k < 0) std::swap(a, c), std::swap(b, d), std::swap(kb, kd), k = -k;
long long x, y;
exGcd(kb, kd, x, y);
x = ((long long)x * -k % kd + kd) % kd;
for (int i = 1; i <= pc; ++i) a[i] += x * b[i], b[i] *= kd;
return 1;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%d%d", &A[i], &B[i]);
X(A[i]), X(B[i]);
}
std::sort(pr + 1, pr + pc + 1);
pc = std::unique(pr + 1, pr + pc + 1) - pr - 1;
for (int i = 1; i <= N; ++i)
if (i == 1)
Z(A[i], a), Z(B[i], b);
else if (Z(A[i], c), Z(B[i], d), !Merge())
return puts("-1"), 0;
int Ans = 1;
for (int i = 1; i <= pc; ++i) Ans = (long long)Ans * qPow(pr[i], a[i]) % Mod;
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
const int N = 1145141, P = 1e9 + 7;
inline long long fpow(long long x, long long y) {
long long ret = 1;
for (; y; y >>= 1, x = x * x % P)
if (y & 1) ret = ret * x % P;
return ret;
}
int n, A[N], B[N];
int pr[N], tot;
long long a[N], b[N], c[N], d[N];
inline void init(int x) {
for (int i = 2; i * i <= x; ++i) {
if (x % i) continue;
pr[++tot] = i;
while (!(x % i)) x /= i;
}
if (x > 1) pr[++tot] = x;
}
inline void work(int x, long long f[]) {
for (int i = 1; i <= tot; ++i) {
int p = pr[i];
f[i] = 0;
while (!(x % p)) x /= p, ++f[i];
}
}
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
inline long long lcm(long long x, long long y) {
if (!x && !y) return 0;
return x / gcd(x, y) * y;
}
long long exgcd(long long x, long long y, long long &a, long long &b) {
if (!y) return a = 1, b = 0, x;
int g = exgcd(y, x % y, b, a);
return b -= x / y * a, g;
}
inline int merge(int kase) {
long long sumb = 0, sumd = 0;
for (int i = 1; i <= tot; ++i) sumb += b[i], sumd += d[i];
if (!sumb && !sumd) {
for (int i = 1; i <= tot; ++i)
if (a[i] != c[i]) return 0;
return 1;
}
if (!sumb || !sumd) {
if (!sumd) {
std::swap(sumb, sumd);
std::swap(a, c);
std::swap(b, d);
}
long long y = 0;
for (int i = 1; i <= tot; ++i) {
if (!d[i]) {
if (a[i] != c[i]) return 0;
} else {
if (a[i] < c[i] || (a[i] - c[i]) % d[i]) return 0;
y = (a[i] - c[i]) / d[i];
break;
}
}
for (int i = 1; i <= tot; ++i)
if (a[i] != c[i] + y * d[i]) return 0;
return 1;
}
int flag = 0;
for (int i = 1; i <= tot; ++i)
if (b[i] * sumd != d[i] * sumb) {
flag = i;
break;
}
if (flag) {
int pi = flag, pj = 0;
for (int i = 1; i <= tot; ++i)
if (b[i] * d[pi] != d[i] * b[pi]) {
pj = i;
break;
}
long long t1 = d[pj] * (c[pi] - a[pi]) - d[pi] * (c[pj] - a[pj]),
t2 = b[pj] * (c[pi] - a[pi]) - b[pi] * (c[pj] - a[pj]),
t3 = b[pi] * d[pj] - b[pj] * d[pi];
if (t3 == 0 || t1 % t3 || t2 % t3) return 0;
long long x = t1 / t3, y = t2 / t3;
if (x < 0 || y < 0) return 0;
for (int i = 1; i <= tot; ++i) {
if (a[i] + x * b[i] != c[i] + y * d[i]) return 0;
a[i] = a[i] + x * b[i], b[i] = 0;
}
return 1;
}
long long x, y, tb = 0, td = 0, t = 0, g = 0;
for (int i = 1; i <= tot; ++i)
if (b[i]) {
g = gcd(b[i], d[i]);
tb = b[i] / g, td = d[i] / g;
if ((a[i] - c[i]) % g) return 0;
t = (a[i] - c[i]) / g;
break;
}
for (int i = 1; i <= tot; ++i)
if (c[i] + t * g != a[i]) return 0;
if (t < 0) {
std::swap(a, c);
std::swap(b, d);
std::swap(tb, td);
t = -t;
}
exgcd(tb, td, x, y);
x = (x * -t % td + td) % td;
for (int i = 1; i <= tot; ++i) {
a[i] += x * b[i];
b[i] *= td;
}
return 1;
}
int main() {
std::cin >> n;
for (int i = 1; i <= n; ++i) {
std::cin >> A[i] >> B[i];
init(A[i]), init(B[i]);
}
std::sort(pr + 1, pr + tot + 1);
tot = std::unique(pr + 1, pr + tot + 1) - pr - 1;
work(A[1], a), work(B[1], b);
for (int i = 2; i <= n; ++i) {
work(A[i], c), work(B[i], d);
if (!merge(i)) return puts("-1"), 0;
}
long long ans = 1;
for (int i = 1; i <= tot; ++i) ans = ans * fpow(pr[i], a[i]) % P;
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
inline long long Abs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct item {
int p;
long long k;
item(int p = 0, long long k = 0) : p(p), k(k) {}
};
struct Num {
item p[810];
int num;
void init(int x) {
for (int i = 2; i * (long long)i <= x; ++i)
if (x % i == 0) {
int c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = item(i, c);
}
if (x > 1) p[num++] = item(x, 1);
}
item query(int x) {
for (int i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return item(x, 0);
}
} A[110], B[110];
int n;
void FAIL() {
puts("-1");
exit(0);
}
item A1[3210], B1[3210], A2[3210], B2[3210];
int pri[3210], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void Inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a), swap(B, b), swap(C, c);
}
if (!b) {
printf("FUCK");
exit(0);
}
if (c % b) FAIL();
x2 = -c / b;
if (!A) {
printf("FUCK 2 ");
exit(0);
}
if ((C + B * x2) % A) FAIL();
x1 = (-C - B * x2) / A;
}
void UN(Num &a1, Num &b1, Num &a2, Num &b2) {
num = 0;
for (int i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (int i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (int i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (int i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (int i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (int i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (int i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (int i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
int flg1 = 0;
long long x1, x2;
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) FAIL();
continue;
}
long long g = gcd(a, gcd(-b, Abs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) FAIL();
if (-c / a < 0) FAIL();
}
if (!a) {
if (c % b) FAIL();
if (-c / b < 0) FAIL();
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (C / A != c / a) FAIL();
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
FAIL();
}
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) FAIL();
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
return;
}
if (!A && !B) return;
long long g = exgcd(A, B, x1, x2);
if (C % g) FAIL();
x1 *= -C / g, x2 *= -C / g;
long long tx = Abs(-B / g), ty = Abs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
}
const int mod = 1e9 + 7;
int Pow(int x, long long y) {
int res = 1;
for (y %= (mod - 1); y; x = x * (long long)x % mod, y >>= 1)
if (y & 1) res = res * (long long)x % mod;
return res;
}
int main() {
rd(n);
for (int i = 1, a, b; i <= n; ++i) rd(a), rd(b), A[i].init(a), B[i].init(b);
for (int i = 2; i <= n; ++i) UN(A[1], B[1], A[i], B[i]);
long long ans = 1;
for (int i = 0; i < A[1].num; ++i)
ans = ans * (long long)Pow(A[1].p[i].p, A[1].p[i].k) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace zyt {
template <typename T>
inline bool read(T &x) {
char c;
bool f = false;
x = 0;
do c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF) return false;
if (c == '-') f = true, c = getchar();
do x = x * 10 + c - '0', c = getchar();
while (isdigit(c));
if (f) x = -x;
return true;
}
template <typename T>
inline void write(T x) {
static char buf[20];
char *pos = buf;
if (x < 0) putchar('-'), x = -x;
do *pos++ = x % 10 + '0';
while (x /= 10);
while (pos > buf) putchar(*--pos);
}
const int N = 1e2 + 10, M = 2000, P = 1e9 + 7;
int a[N], b[N], n, pcnt, prime[M];
int power(int a, long long b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % P;
a = (long long)a * a % P;
b >>= 1;
}
return ans;
}
struct prgrs {
long long a[M], b[M];
prgrs() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
} arr[N];
void get(int n) {
for (int i = 0; i < pcnt; i++)
while (n % prime[i] == 0) n /= prime[i];
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
prime[pcnt++] = i;
while (n % i == 0) n /= i;
}
if (n > 1) prime[pcnt++] = n;
}
void get(int n, long long *const a) {
for (int i = 0; i < pcnt; i++) {
a[i] = 0;
while (n % prime[i] == 0) ++a[i], n /= prime[i];
}
}
long long exgcd(const long long a, const long long b, long long &x,
long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long xx, yy, tmp = exgcd(b, a % b, xx, yy);
x = yy;
y = xx - a / b * yy;
return tmp;
}
long long gcd(const long long a, const long long b) {
return b ? gcd(b, a % b) : a;
}
void FAIL() {
puts("-1");
exit(0);
}
prgrs merge(const prgrs &A, const prgrs &B) {
prgrs ans;
int cnt = 0;
long long a, b, c, x, y;
for (int i = 0; i < pcnt; i++) {
if (A.b[i] || B.b[i]) {
if (cnt == 0)
a = A.b[i], b = -B.b[i], c = B.a[i] - A.a[i], ++cnt;
else if (cnt == 1) {
long long aa = A.b[i], bb = -B.b[i], cc = B.a[i] - A.a[i],
g = gcd(a, aa);
if (g < 0) g = -g;
if (!a) swap(a, aa), swap(b, bb), swap(c, cc);
if (a * bb == b * aa) {
if (a * cc != c * aa) FAIL();
} else {
if (aa) {
int t1 = a / g, t2 = aa / g;
a *= t2, b *= t2, c *= t2;
aa *= t1, bb *= t1, cc *= t1;
bb -= b, cc -= c;
}
if (cc % bb) FAIL();
y = cc / bb;
if ((c - b * y) % a) FAIL();
x = (c - b * y) / a;
if (x < 0 || y < 0) FAIL();
++cnt;
}
} else if (A.b[i] * x + A.a[i] != B.b[i] * y + B.a[i])
FAIL();
} else if (A.a[i] != B.a[i])
FAIL();
}
if (cnt == 0)
ans = A;
else if (cnt == 1) {
long long g = gcd(a, b);
if (c % g) FAIL();
a /= g, b /= g, c /= g;
exgcd(a, b, x, y);
x *= c, y *= c;
if (g < 0) a = -a, b = -b, c = -c, g = -g;
if (a && b) {
if (x < 0 || y < 0) {
long long t = LLONG_MIN;
if (x < 0) t = max(t, (-x - b - 1) / -b);
if (y < 0) t = max(t, (-y + a - 1) / a);
x -= t * b, y += t * a;
}
long long t = min(x / -b, y / a);
x += t * b, y -= t * a;
}
if (x < 0 || y < 0) FAIL();
if (a * x + b * y != c) fprintf(stderr, "gg");
for (int i = 0; i < pcnt; i++)
ans.a[i] = A.a[i] + A.b[i] * x,
ans.b[i] = (A.b[i] || B.b[i] ? a * B.b[i] : 0);
} else
for (int i = 0; i < pcnt; i++) ans.a[i] = A.a[i] + A.b[i] * x, ans.b[i] = 0;
return ans;
}
int work() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]), read(b[i]);
get(a[i]), get(b[i]);
}
sort(prime, prime + pcnt);
for (int i = 1; i <= n; i++) get(a[i], arr[i].a), get(b[i], arr[i].b);
for (int i = 2; i <= n; i++) arr[1] = merge(arr[1], arr[i]);
int ans = 1;
for (int i = 0; i < pcnt; i++)
ans = (long long)ans * power(prime[i], arr[1].a[i]) % P;
write(ans);
return 0;
}
} // namespace zyt
int main() { return zyt::work(); }
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100;
const int MAXVAL = 1000000000;
const int MAXSQRTVAL = 31622;
const int MOD = 1000000007;
void print(const vector<pair<int, int> > &a) {
printf("(");
if (((int)(a).size()) == 0) printf("1");
for (int i = (0); i < (((int)(a).size())); ++i) {
if (i != 0) printf("*");
printf("%d", a[i].first);
if (a[i].second != 1) printf("^%d", a[i].second);
}
printf(")");
}
int n;
int aa[MAXN], bb[MAXN];
vector<pair<int, int> > a[MAXN], b[MAXN];
bool isp[MAXSQRTVAL + 1];
int p[MAXSQRTVAL + 1], np;
long long modpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1) return a * modpow(a, n - 1) % MOD;
return modpow(a * a % MOD, n / 2);
}
vector<pair<int, int> > getpp(int x) {
vector<pair<int, int> > ret;
for (int i = 0; p[i] * p[i] <= x; ++i)
if (x % p[i] == 0) {
ret.push_back(make_pair(p[i], 1));
x /= p[i];
while (x % p[i] == 0) ++ret[((int)(ret).size()) - 1].second, x /= p[i];
}
if (x != 1) ret.push_back(make_pair(x, 1));
return ret;
}
long long egcd(long long a, long long b, long long &n, long long &m) {
if (b == 0) {
n = 1, m = 0;
return a;
}
long long g = egcd(b, a % b, m, n);
m = -m - n * (a / b);
n = -n;
return g;
}
const int ARG = 0;
const int RES = 1;
bool _insersect(pair<long long, long long> &a, pair<long long, long long> &b,
int mode) {
if (a.second == 0 && b.second == 0) {
bool ret = a.first == b.first;
if (mode == ARG) a = b = make_pair(-1, -1);
return ret;
}
if (a.second == 0) {
bool ret = a.first >= b.first && (a.first - b.first) % b.second == 0;
if (mode == ARG)
a = make_pair(0, 1), b = make_pair((a.first - b.first) / b.second, 0LL);
return ret;
}
if (b.second == 0) {
bool ret = b.first >= a.first && (b.first - a.first) % a.second == 0;
if (mode == ARG)
a = make_pair((b.first - a.first) / a.second, 0LL), b = make_pair(0, 1);
else
a = b;
return ret;
}
long long n, m;
long long g = egcd(a.second, b.second, n, m);
if ((b.first - a.first) % g != 0) return false;
long long times = (b.first - a.first) / g;
n *= times, m *= times;
long long aa = a.second / g, bb = b.second / g;
if (n < 0) {
long long x = (-n + bb - 1) / bb;
n += bb * x;
m += aa * x;
}
if (m < 0) {
long long x = (-m + aa - 1) / aa;
n += bb * x;
m += aa * x;
}
if (n >= bb && m >= aa) {
long long x = min(n / bb, m / aa);
n -= bb * x;
m -= aa * x;
}
if (mode == ARG)
a = make_pair(n, bb), b = make_pair(m, aa);
else
a.first += a.second * n, a.second *= bb;
return true;
}
bool intersect(pair<long long, long long> &a, pair<long long, long long> &b,
int mode) {
bool ret = _insersect(a, b, mode);
return ret;
}
bool _combine(pair<long long, long long> &n, pair<long long, long long> &m,
const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.first == -1 && a.second == -1 && b.first == -1 && b.second == -1)
return true;
;
if (n.first == -1 && n.second == -1 && m.first == -1 && m.second == -1) {
n = a, m = b;
return true;
}
if (b.second * n.second == a.second * m.second) {
if (n.first * b.second - m.first * a.second !=
a.first * b.second - b.first * a.second)
return false;
if (n.first * m.second - m.first * n.second !=
a.first * m.second - b.first * n.second)
return false;
if (n.second == 0) {
if (a.second == 0) {
if (n.first != a.first) return false;
if (m.second == 0) {
if (b.second == 0) {
if (m.first != b.first) return false;
n = n, m = m;
} else {
if (m.first - b.first < 0 || (m.first - b.first) % b.second != 0)
return false;
n = n, m = m;
}
} else {
if (b.second == 0) {
if (b.first - m.first < 0 || (b.first - m.first) % m.second != 0)
return false;
m.first = b.first;
m.second = 0;
} else {
long long x = b.first - m.first;
long long p, q, g;
g = egcd(m.second, b.second, p, q);
if (x % g != 0) return false;
long long bb = b.second / g, mm = m.second / g, xx = x / g;
p *= xx, q *= xx;
if (p < 0) {
long long x = (-p + bb - 1) / bb;
p += x * bb, q += x * mm;
}
if (q < 0) {
long long x = (-q + mm - 1) / mm;
p += x * bb, q += x * mm;
}
if (p >= bb && q >= mm) {
long long x = min(p / bb, q / mm);
p -= x * bb, q -= x * mm;
}
m.first += p * m.second;
m.second *= bb;
}
}
} else {
assert(m.second == 0);
if (n.first - a.first < 0 || (n.first - a.first) % a.second != 0)
return false;
if (b.second == 0 && b.first != m.first) return false;
if (b.second != 0 &&
(m.first - b.first < 0 || (m.first - b.first) % b.second != 0))
return false;
n = n, m = m;
}
} else {
if (a.second == 0) {
assert(b.second == 0);
if (a.first - n.first < 0 || (a.first - n.first) % n.second != 0)
return false;
if (m.second == 0 && m.first != b.first) return false;
if (m.second != 0 &&
(b.first - m.first < 0 || (b.first - m.first) % m.second != 0))
return false;
n.first = a.first;
n.second = 0;
m.first = b.first;
m.second = 0;
} else {
long long x = a.first - n.first;
long long p, q, g;
g = egcd(n.second, a.second, p, q);
if (x % g != 0) return false;
long long aa = a.second / g, nn = n.second / g, xx = x / g;
p *= xx, q *= xx;
if (p < 0) {
long long x = (-p + aa - 1) / aa;
p += x * aa, q += x * nn;
}
if (q < 0) {
long long x = (-q + nn - 1) / nn;
p += x * aa, q += x * nn;
}
if (p >= aa && q >= nn) {
long long x = min(p / aa, q / nn);
p -= x * aa, q -= x * nn;
}
n.first += p * n.second;
n.second *= aa;
m.first += p * m.second;
m.second *= aa;
}
}
} else {
long long num1 =
(m.first - b.first) * a.second + (a.first - n.first) * b.second;
long long num2 =
(m.first - b.first) * n.second + (a.first - n.first) * m.second;
long long den = b.second * n.second - a.second * m.second;
if (num1 % den != 0 || num2 % den != 0) return false;
long long p = num1 / den, q = num2 / den;
if (p < 0 || q < 0) return false;
n.first += p * n.second;
n.second = 0;
m.first += p * m.second;
m.second = 0;
}
return true;
}
bool combine(pair<long long, long long> &n, pair<long long, long long> &m,
const pair<long long, long long> &a,
const pair<long long, long long> &b) {
bool ret = _combine(n, m, a, b);
return ret;
}
bool calc(const vector<pair<int, int> > &a0, const vector<pair<int, int> > &b0,
const vector<pair<int, int> > &a1, const vector<pair<int, int> > &b1,
pair<long long, long long> &res) {
int i0 = 0, j0 = 0, i1 = 0, j1 = 0;
pair<long long, long long> n = make_pair(-1, -1), m = make_pair(-1, -1);
while (true) {
int cur = INT_MAX;
if (i0 < ((int)(a0).size()) && a0[i0].first < cur) cur = a0[i0].first;
if (j0 < ((int)(b0).size()) && b0[j0].first < cur) cur = b0[j0].first;
if (i1 < ((int)(a1).size()) && a1[i1].first < cur) cur = a1[i1].first;
if (j1 < ((int)(b1).size()) && b1[j1].first < cur) cur = b1[j1].first;
if (cur == INT_MAX) break;
pair<long long, long long> a, b;
if (i0 < ((int)(a0).size()) && a0[i0].first == cur)
a.first = a0[i0++].second;
if (j0 < ((int)(b0).size()) && b0[j0].first == cur)
a.second = b0[j0++].second;
if (i1 < ((int)(a1).size()) && a1[i1].first == cur)
b.first = a1[i1++].second;
if (j1 < ((int)(b1).size()) && b1[j1].first == cur)
b.second = b1[j1++].second;
if (!intersect(a, b, ARG)) return false;
if (!combine(n, m, a, b)) return false;
}
res = n;
return true;
}
void run() {
for (int i = (0); i <= (MAXSQRTVAL); ++i) isp[i] = true;
isp[0] = isp[1] = false;
for (int i = 2; i * i <= MAXSQRTVAL; ++i)
if (isp[i])
for (int j = i * i; j <= MAXSQRTVAL; j += i) isp[j] = false;
np = 0;
for (int i = (0); i <= (MAXSQRTVAL); ++i)
if (isp[i]) p[np++] = i;
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d%d", &aa[i], &bb[i]);
for (int i = (0); i < (n); ++i) a[i] = getpp(aa[i]);
for (int i = (0); i < (n); ++i) b[i] = getpp(bb[i]);
pair<long long, long long> res = make_pair(0, 1);
for (int i = (1); i < (n); ++i) {
pair<long long, long long> cur;
if (!calc(a[0], b[0], a[i], b[i], cur)) {
printf("-1\n");
return;
}
if (!intersect(res, cur, RES)) {
printf("-1\n");
return;
}
}
int ret = (long long)aa[0] * modpow(bb[0], res.first) % MOD;
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int modulo = 1000000007;
int esprimo[100000];
vector<int> primo;
vector<pair<int, int> > factorizacion(int x) {
vector<pair<int, int> > f;
for (int i = 0; i < int(primo.size()) and primo[i] <= x; i++) {
int p = primo[i];
int e = 0;
while (x % p == 0) {
x /= p;
e++;
}
if (e) f.push_back(pair<int, int>(p, e));
}
if (x > 1) f.push_back(pair<int, int>(x, 1));
return f;
}
int exponente(int p, vector<pair<int, int> > &f) {
for (int i = 0; i < int(f.size()); i++)
if (f[i].first == p) return f[i].second;
return 0;
}
long long int eleva(long long int b, long long int e) {
if (e == 0) return 1;
if (e % 2 == 0) return eleva(b * b % modulo, e / 2);
return b * eleva(b * b % modulo, e / 2) % modulo;
}
long long int mcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return mcd(a % b, b);
}
long long int mcm(long long int a, long long int b) {
return a / mcd(a, b) * b;
}
long long int absolut(long long int x) {
if (x < 0) return -x;
return x;
}
void chino(long long int a, long long int b, long long int &fa,
long long int &fb, long long int c) {
if (absolut(a) < absolut(b)) {
chino(b, a, fb, fa, c);
return;
}
if (b == 0) {
if (c % a != 0) {
cout << -1 << endl;
exit(0);
}
fa = c / a;
fb = 0;
return;
}
chino(a % b, b, fa, fb, c);
fb -= fa * (a / b);
}
void chino(long long int ini1, long long int salto1, long long int ini2,
long long int salto2, long long int &con1, long long int &fac1,
long long int &con2, long long int &fac2) {
chino(salto1, -salto2, con1, con2, ini2 - ini1);
fac1 = mcm(salto1, salto2) / salto1;
fac2 = mcm(salto1, salto2) / salto2;
long long int desp1 = 0;
if (con1 < 0) {
desp1 += -con1 / fac1;
con1 %= fac1;
if (con1 < 0) {
con1 += fac1;
desp1++;
}
}
desp1 -= con1 / fac1;
con1 %= fac1;
con2 += desp1 * fac2;
long long int desp2 = 0;
if (con2 < 0) {
desp2 += -con2 / fac2;
con2 %= fac2;
if (con2 < 0) {
con2 += fac2;
desp2++;
}
}
con1 += desp2 * fac1;
}
void chino(long long int &ini, long long int &salto, long long int ininew,
long long int saltonew) {
long long int con, fac, connew, facnew;
chino(ini, salto, ininew, saltonew, con, fac, connew, facnew);
ini = ini + con * salto;
salto = fac * salto;
}
void comprueba(vector<pair<int, int> > &fa1, vector<pair<int, int> > &fb1,
vector<pair<int, int> > &fa2, vector<pair<int, int> > &fb2,
int p, long long int &fac1, long long int fac2) {
if (not(exponente(p, fb1) == 0 or fac1 != -1)) {
fac1 = (exponente(p, fa2) + fac2 * exponente(p, fb2) - exponente(p, fa1)) /
exponente(p, fb1);
if (fac1 < 0) {
cout << -1 << endl;
exit(0);
}
}
if (exponente(p, fa1) + fac1 * exponente(p, fb1) !=
exponente(p, fa2) + fac2 * exponente(p, fb2)) {
cout << -1 << endl;
exit(0);
}
}
void comprueba(vector<pair<int, int> > &fa1, vector<pair<int, int> > &fb1,
vector<pair<int, int> > &fa2, vector<pair<int, int> > &fb2,
vector<pair<int, int> > &f, long long int &fac1,
long long int fac2) {
for (int i = 0; i < int(f.size()); i++)
comprueba(fa1, fb1, fa2, fb2, f[i].first, fac1, fac2);
}
void comprueba(vector<pair<int, int> > &fa1, vector<pair<int, int> > &fb1,
vector<pair<int, int> > &fa2, vector<pair<int, int> > &fb2,
long long int fac2) {
long long int fac1 = -1;
comprueba(fa1, fb1, fa2, fb2, fa1, fac1, fac2);
comprueba(fa1, fb1, fa2, fb2, fb1, fac1, fac2);
comprueba(fa1, fb1, fa2, fb2, fa2, fac1, fac2);
comprueba(fa1, fb1, fa2, fb2, fb2, fac1, fac2);
}
void escribe(long long int a, vector<pair<int, int> > &fb, long long int fac) {
long long int sol = a;
for (int i = 0; i < int(fb.size()); i++) {
long long int p = fb[i].first;
long long int e = fb[i].second;
e = fac * e;
sol = sol * eleva(p, e) % modulo;
}
cout << sol << endl;
exit(0);
}
void arregla(vector<pair<int, int> > &fa, vector<pair<int, int> > &fb) {
int ib = 0;
vector<pair<int, int> > nextfa;
for (int ia = 0; ia < int(fa.size()); ia++, ib++) {
for (; fb[ib].first != fa[ia].first; ib++)
nextfa.push_back(pair<int, int>(fb[ib].first, 0));
nextfa.push_back(fa[ia]);
}
for (; ib < int(fb.size()); ib++)
nextfa.push_back(pair<int, int>(fb[ib].first, 0));
fa = nextfa;
}
int n;
long long int a[100], b[100];
vector<pair<int, int> > fa[100], fb[100];
void intenta(int ind, long long int fac) {
for (int i = 0; i < n; i++)
if (i != ind) comprueba(fa[i], fb[i], fa[ind], fb[ind], fac);
escribe(a[ind], fb[ind], fac);
}
void elimina(set<int> &s, vector<pair<int, int> > &f) {
vector<pair<int, int> > nextf;
for (int i = 0; i < int(f.size()); i++)
if (s.count(f[i].first) == 0) nextf.push_back(f[i]);
f = nextf;
}
int main() {
for (int i = 2; i < 100000; i++) esprimo[i] = 1;
for (int i = 2; i < 100000; i++) {
if (esprimo[i]) {
primo.push_back(i);
for (int j = i + i; j < 100000; j += i) esprimo[j] = 0;
}
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
fa[i] = factorizacion(a[i]);
fb[i] = factorizacion(b[i]);
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < int(fb[0].size()); j++) {
int p = fb[0][j].first;
int e = fb[0][j].second;
if (exponente(p, fb[i]) == 0) {
long long int x = exponente(p, fa[i]) - exponente(p, fa[0]);
if (x < 0 or x % e != 0) {
cout << -1 << endl;
exit(0);
}
intenta(0, x / e);
}
}
for (int j = 0; j < int(fb[i].size()); j++) {
int p = fb[i][j].first;
int e = fb[i][j].second;
if (exponente(p, fb[0]) == 0) {
long long int x = exponente(p, fa[0]) - exponente(p, fa[i]);
if (x < 0 or x % e != 0) {
cout << -1 << endl;
exit(0);
}
intenta(i, x / e);
}
}
}
set<int> s;
for (int i = 0; i < n; i++)
for (int j = 0; j < int(fa[i].size()); j++)
if (exponente(fa[i][j].first, fb[i]) == 0) s.insert(fa[i][j].first);
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
int p = *it;
int e = exponente(p, fa[0]);
for (int i = 1; i < n; i++) {
if (exponente(p, fa[i]) != e) {
cout << -1 << endl;
exit(0);
}
}
}
for (int i = 0; i < n; i++) elimina(s, fa[i]);
for (int i = 0; i < n; i++) arregla(fa[i], fb[i]);
if (int(fb[0].size()) == 0) {
intenta(0, 0);
}
long long int con = 0, salto = 1;
for (int i = 1; i < n; i++) {
long long int l1, ll1, l2, ll2;
chino(fa[0][0].second, fb[0][0].second, fa[i][0].second, fb[i][0].second,
l1, ll1, l2, ll2);
for (int j = 0; j < int(fb[0].size()); j++) {
long long int t1, tt1, t2, tt2;
chino(fa[0][j].second, fb[0][j].second, fa[i][j].second, fb[i][j].second,
t1, tt1, t2, tt2);
if (ll1 == tt1 and ll2 == tt2) {
if ((t1 - l1) % ll1 != 0 or (t2 - l2) % ll2 != 0 or
(t1 - l1) / ll1 != (t2 - l2) / ll2) {
cout << -1 << endl;
exit(0);
}
long long int nextl1 = max(l1, t1);
chino(con, salto, nextl1, ll1);
} else {
long long int x = t1 * tt2 - t2 * tt1;
long long int y = l1 * tt2 - l2 * tt1;
long long int z = ll1 * tt2 - ll2 * tt1;
long long int xy = x - y;
if (xy % z != 0) {
cout << -1 << endl;
exit(0);
}
intenta(0, l1 + xy / z * ll1);
}
}
}
intenta(0, con);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2111;
const int mod = 1e9 + 7;
int n;
int pri[N], tot;
long long a[N], b[N];
struct node {
long long k, b;
node(long long _k = 0, long long _b = 0) {
k = _k;
b = _b;
}
} f[N], g[N];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long ksm(long long base, long long x) {
long long ans = 1;
while (x) {
if (x & 1) ans = ans * base % mod;
base = base * base % mod;
x >>= 1;
}
return ans;
}
void get(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
pri[++tot] = i;
while (x % i == 0) x /= i;
}
}
if (x > 1) pri[++tot] = x;
}
void get_g(int id) {
for (int i = 1; i <= tot; i++) {
g[i].b = g[i].k = 0;
while (a[id] % pri[i] == 0) {
g[i].b++;
a[id] /= pri[i];
}
while (b[id] % pri[i] == 0) {
g[i].k++;
b[id] /= pri[i];
}
}
}
long long ex_gcd(long long A, long long B, long long &x, long long &y) {
if (!B) {
x = 1;
y = 0;
return A;
}
long long xx, yy;
long long d = ex_gcd(B, A % B, xx, yy);
x = yy;
y = xx - A / B * yy;
return d;
}
bool merge() {
bool flag = 0;
for (int t = 0; t < 3; t++) {
for (int i = 1; i <= tot; i++) {
long long fk = f[i].k, fb = f[i].b;
long long gk = g[i].k, gb = g[i].b;
bool fl = 0;
if (!fk && !gk) {
if (fb != gb) return 0;
} else {
if (!gk || !fk) {
if (!fk) swap(fk, gk), swap(fb, gb), fl = 1;
if (fb > gb || (gb - fb) % fk != 0) return 0;
long long k = (gb - fb) / fk;
if (fl)
for (int j = 1; j <= tot; j++) g[j].b += g[j].k * k, g[j].k = 0;
else
for (int j = 1; j <= tot; j++) f[j].b += f[j].k * k, f[j].k = 0;
flag = 1;
}
}
}
}
if (flag) return 1;
int fl = 0;
long long A = 0, B = 0, C = 0;
for (int i = 1; i <= tot; i++) {
if (!f[i].k || !g[i].k) continue;
if (!fl)
A = f[i].k, B = -g[i].k, C = g[i].b - f[i].b, fl = 1;
else if (fl == 1) {
long long nA = f[i].k, nB = -g[i].k, nC = g[i].b - f[i].b;
long long d = gcd(nA, A);
A *= nA / d;
B *= nA / d;
C *= nA / d;
nA *= A / d;
nB *= A / d;
nC *= A / d;
if (B == nB) {
if (C != nC) return 0;
long long d = gcd(A, gcd(abs(B), abs(C)));
A /= d;
B /= d;
C /= d;
continue;
} else {
if ((C - nC) % (B - nB)) return 0;
long long y = (C - nC) / (B - nB);
if (y < 0) return 0;
if ((C - B * y) % A) return 0;
long long x = (C - B * y) / A;
if (x < 0) return 0;
for (int j = 1; j <= tot; j++) f[j].b += f[j].k * x, f[j].k = 0;
for (int j = i + 1; j <= tot; j++) {
nA = f[j].k, nB = -g[j].k, nC = g[j].b - f[j].b;
if (nA * x + nB * y != nC) return 0;
}
return 1;
}
}
}
long long x = -1, y = -1;
long long d = ex_gcd(A, -B, x, y);
if (C % d) return 0;
y *= -1;
long long kx = (-B) / d;
long long ky = A / d;
x *= C / d, y *= C / d;
long long tx = x < 0 ? -(-x + kx - 1) / kx : x / kx;
long long ty = y < 0 ? -(-y + ky - 1) / ky : y / ky;
x -= min(tx, ty) * kx;
y -= min(tx, ty) * ky;
for (int i = 1; i <= tot; i++) {
f[i].b += f[i].k * x;
f[i].k = f[i].k * kx;
}
return 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
get(a[i]);
get(b[i]);
}
sort(pri + 1, pri + 1 + tot);
tot = unique(pri + 1, pri + 1 + tot) - (pri + 1);
for (int i = 1; i <= tot; i++) {
while (a[1] % pri[i] == 0) {
f[i].b++;
a[1] /= pri[i];
}
while (b[1] % pri[i] == 0) {
f[i].k++;
b[1] /= pri[i];
}
}
for (int i = 2; i <= n; i++) {
get_g(i);
if (!merge()) {
puts("-1");
return 0;
}
}
int ans = 1;
for (int i = 1; i <= tot; i++) {
ans = 1LL * ans * ksm(pri[i], f[i].b) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 105;
const long long MOD = 1000000007;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = 1, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (f) x = -x;
}
long long qpow(long long x, long long t) {
long long ans = 1;
while (t) {
if (t & 1) ans = ans * x % MOD;
x = x * x % MOD;
t >>= 1;
}
return ans;
}
struct PRI {
long long base, step;
PRI(const long long &a = 0, const long long &b = 0) : base(a), step(b) {}
PRI f(PRI x) const { return PRI(base + step * x.base, step * x.step); }
};
vector<pair<int, int> > GetDiv(int x) {
vector<pair<int, int> > ret;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int c = 0;
while (x % i == 0) c++, x /= i;
ret.push_back(make_pair(i, c));
}
if (x != 1) ret.push_back(make_pair(x, 1));
return ret;
}
void Exgcd(long long x, long long y, long long &a, long long &b) {
if (!y)
a = 1, b = 0;
else
Exgcd(y, x % y, b, a), b -= (x / y) * a;
}
vector<int> prm;
int ax[MX], bx[MX];
vector<PRI> px[MX];
vector<PRI> GetPri(int a, int b) {
vector<PRI> ret;
vector<pair<int, int> > da = GetDiv(a), db = GetDiv(b);
for (int i = 0; i < prm.size(); i++) {
ret.push_back(PRI(0, 0));
auto it = lower_bound(da.begin(), da.end(), make_pair(prm[i], 0));
if (it != da.end() && it->first == prm[i]) ret.back().base = it->second;
it = lower_bound(db.begin(), db.end(), make_pair(prm[i], 0));
if (it != db.end() && it->first == prm[i]) ret.back().step = it->second;
}
return ret;
}
void Fuck() {
puts("-1");
exit(0);
}
long long Gcd(long long x, long long y) {
if (y == 0)
return x;
else
return Gcd(y, x % y);
}
pair<PRI, PRI> MinSolve(PRI e1, PRI e2) {
if (!e1.step && !e2.step && e1.base != e2.base)
Fuck();
else if (!e1.step && !e2.step && e1.base == e2.base)
return make_pair(PRI(0, 1), PRI(0, 1));
else if (!e1.step) {
long long delt = (e1.base - e2.base) / e2.step;
if (e2.base + delt * e2.step != e1.base)
Fuck();
else
return make_pair(PRI(0, 1), PRI(delt, 0));
} else if (!e2.step) {
long long delt = (e2.base - e1.base) / e1.step;
if (e1.base + delt * e1.step != e2.base)
Fuck();
else if (delt < 0)
Fuck();
else
return make_pair(PRI(delt, 0), PRI(0, 1));
}
long long g = Gcd(e1.step, e2.step);
long long k1, k2;
Exgcd(e1.step, e2.step, k1, k2);
if ((e2.base - e1.base) % g) Fuck();
long long delt1 = abs(e2.step / g), delt2 = abs(e1.step / g);
k1 *= (e2.base - e1.base) / g, k2 *= -(e2.base - e1.base) / g;
long long mov = max((k1 < 0) ? ((-k1 - 1) / delt1 + 1) : -(k1 / delt1),
(k2 < 0) ? ((-k2 - 1) / delt2 + 1) : -(k2 / delt2));
k1 += delt1 * mov, k2 += delt2 * mov;
return make_pair(PRI(k1, delt1), PRI(k2, delt2));
}
PRI CombineEquation(PRI e1, PRI e2) {
PRI sol = MinSolve(e1, e2).first;
return e1.f(sol);
}
long long SolveProgression(PRI e1, PRI e2) {
if (e1.step == e2.step) {
if (e1.base == e2.base)
return -1;
else
Fuck();
} else {
long long r = e2.base - e1.base, l = e1.step - e2.step;
if (r % l)
Fuck();
else if (r / l < 0)
Fuck();
else
return r / l;
}
}
int main() {
int n;
read(n);
for (int i = 1; i <= n; i++) read(ax[i]), read(bx[i]);
for (int i = 1; i <= n; i++) {
auto da = GetDiv(ax[i]), db = GetDiv(bx[i]);
for (auto j : da) prm.push_back(j.first);
for (auto j : db) prm.push_back(j.first);
}
sort(prm.begin(), prm.end());
prm.erase(unique(prm.begin(), prm.end()), prm.end());
for (auto i : prm) px[0].push_back(PRI(0, 1));
for (int i = 1; i <= n; i++) px[i] = GetPri(ax[i], bx[i]);
for (int i = 2; i <= n; i++) {
PRI now1(0, 1);
for (int j = 0; j < prm.size(); j++) {
auto tmp = MinSolve(px[i][j], px[i - 1][j]);
now1 = CombineEquation(now1, tmp.first);
}
vector<PRI> pro;
for (int j = 0; j < prm.size(); j++) {
if (!px[i - 1][j].step) continue;
PRI tmp((now1.base * px[i][j].step + px[i][j].base - px[i - 1][j].base) /
px[i - 1][j].step,
now1.step * px[i][j].step / px[i - 1][j].step);
pro.push_back(tmp);
}
long long lst = -1;
for (int j = 0; j < pro.size(); j++)
for (int k = j + 1; k < pro.size(); k++) {
long long tmp = SolveProgression(pro[j], pro[k]);
if (tmp != -1) {
if (lst != -1) {
if (lst != tmp) Fuck();
} else
lst = tmp;
}
}
if (lst == -1)
for (auto &it : px[i]) it = it.f(now1);
else
for (auto &it : px[i])
it.base += it.step * (now1.step * lst + now1.base), it.step = 0;
}
long long ans = 1;
for (int i = 0; i < prm.size(); i++)
ans = ans * qpow(prm[i], px[n][i].base) % MOD;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
inline int ksm(int x, long long y) {
int res = 1;
while (y > 0) {
if (y & 1) res = 1ll * res * x % MOD;
x = 1ll * x * x % MOD;
y >>= 1;
}
return res;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long gcd1 = exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
return gcd1;
}
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int n, a[105], b[105], pri[2005], m;
struct node {
long long a[2005], b[2005];
bool merge(node x) {
long long sum1 = 0, sum2 = 0;
for (int i = 1; i <= m; i++) sum1 += b[i], sum2 += x.b[i];
if (sum1 == 0 && sum2 == 0) {
for (int i = 1; i <= m; i++)
if (a[i] != x.a[i]) return 0;
return 1;
}
if (sum1 == 0 || sum2 == 0) {
if (sum2 == 0) {
swap(a, x.a);
swap(b, x.b);
swap(sum1, sum2);
}
long long res = 0;
for (int i = 1; i <= m; i++)
if (x.b[i] != 0) {
res = ((a[i] >= x.a[i]) && ((a[i] - x.a[i]) % x.b[i] == 0))
? (a[i] - x.a[i]) / x.b[i]
: -1;
break;
} else if (a[i] != x.a[i])
return 0;
if (res == -1) return 0;
for (int i = 1; i <= m; i++)
if ((x.a[i] + res * x.b[i]) != a[i]) return 0;
return 1;
}
long long sta = -1;
for (int i = 1; i <= m; i++)
if (b[i] * sum2 != x.b[i] * sum1) {
sta = i;
break;
}
if (sta == -1) {
long long b1 = 0, b2 = 0, gcd1;
for (int i = 1; i <= m; i++)
if (b[i] != 0) {
gcd1 = gcd(b[i], x.b[i]);
b1 = b[i] / gcd1;
b2 = x.b[i] / gcd1;
break;
}
long long res = 0;
for (int i = 1; i <= m; i++)
if (b[i] != 0) {
if ((a[i] - x.a[i]) % gcd1) return 0;
res = (a[i] - x.a[i]) / gcd1;
break;
}
for (int i = 1; i <= m; i++)
if ((x.a[i] + res * gcd1) != a[i]) return 0;
if (res < 0) {
swap(a, x.a);
swap(b, x.b);
swap(b1, b2);
res = -res;
}
long long xx, yy;
exgcd(b1, b2, xx, yy);
res = -res;
xx = (xx * res % b2 + b2) % b2;
for (int i = 1; i <= m; i++) a[i] += xx * b[i], b[i] *= b2;
} else {
long long p1 = sta, p2 = 0;
for (int i = 1; i <= m; i++)
if (b[p1] * x.b[i] != x.b[p1] * b[i]) {
p2 = i;
break;
}
long long xx = x.b[p2] * (x.a[p1] - a[p1]) - x.b[p1] * (x.a[p2] - a[p2]);
long long yy = b[p2] * (x.a[p1] - a[p1]) - b[p1] * (x.a[p2] - a[p2]);
long long fenm = x.b[p2] * b[p1] - b[p2] * x.b[p1];
if (fenm < 0) xx = -xx, yy = -yy, fenm = -fenm;
if (xx < 0 || yy < 0 || xx % fenm != 0 || yy % fenm != 0) return 0;
xx /= fenm, yy /= fenm;
for (int i = 1; i <= m; i++) {
if ((a[i] + xx * b[i]) != (x.a[i] + yy * x.b[i])) return 0;
a[i] += xx * b[i];
b[i] = 0;
}
}
return 1;
}
} s[105];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
int a1 = a[i], b1 = b[i];
for (int j = 2; j * j <= a[i]; j++)
if (a1 % j == 0) {
pri[++m] = j;
while (a1 % j == 0) a1 /= j;
}
if (a1 != 1) pri[++m] = a1;
for (int j = 2; j * j <= b[i]; j++)
if (b1 % j == 0) {
pri[++m] = j;
while (b1 % j == 0) b1 /= j;
}
if (b1 != 1) pri[++m] = b1;
}
sort(pri + 1, pri + m + 1);
m = unique(pri + 1, pri + m + 1) - pri - 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
while (a[i] % pri[j] == 0) a[i] /= pri[j], s[i].a[j]++;
for (int j = 1; j <= m; j++)
while (b[i] % pri[j] == 0) b[i] /= pri[j], s[i].b[j]++;
}
for (int i = 2; i <= n; i++)
if (!s[i].merge(s[i - 1])) return printf("-1"), 0;
int ans = 1;
for (int i = 1; i <= m; i++) ans = 1ll * ans * ksm(pri[i], s[n].a[i]) % MOD;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
inline long long Abs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct item {
int p;
long long k;
item(int p = 0, long long k = 0) : p(p), k(k) {}
};
struct Num {
item p[810];
int num;
void init(int x) {
for (int i = 2; i * (long long)i <= x; ++i)
if (x % i == 0) {
int c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = item(i, c);
}
if (x > 1) p[num++] = item(x, 1);
}
item query(int x) {
for (int i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return item(x, 0);
}
} A[110], B[110];
int n;
void FAIL() {
puts("-1");
exit(0);
}
item A1[3210], B1[3210], A2[3210], B2[3210];
int pri[3210], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void Inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a), swap(B, b), swap(C, c);
}
if (c % b) FAIL();
x2 = -c / b;
if ((C + B * x2) % A) FAIL();
x1 = (-C - B * x2) / A;
}
void UN(Num &a1, Num &b1, Num &a2, Num &b2) {
num = 0;
for (int i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (int i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (int i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (int i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (int i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (int i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (int i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (int i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
int flg1 = 0;
long long x1, x2;
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) FAIL();
continue;
}
long long g = gcd(a, gcd(-b, Abs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) FAIL();
if (-c / a < 0) FAIL();
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (C / A != c / a) FAIL();
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
FAIL();
}
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) FAIL();
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
return;
}
long long g = exgcd(A, B, x1, x2);
if (C % g) FAIL();
x1 *= -C / g, x2 *= -C / g;
long long tx = Abs(-B / g), ty = Abs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
}
const int mod = 1e9 + 7;
int Pow(int x, long long y) {
int res = 1;
for (y %= (mod - 1); y; x = x * (long long)x % mod, y >>= 1)
if (y & 1) res = res * (long long)x % mod;
return res;
}
int main() {
rd(n);
for (int i = 1, a, b; i <= n; ++i) rd(a), rd(b), A[i].init(a), B[i].init(b);
for (int i = 2; i <= n; ++i) UN(A[1], B[1], A[i], B[i]);
long long ans = 1;
for (int i = 0; i < A[1].num; ++i)
ans = ans * (long long)Pow(A[1].p[i].p, A[1].p[i].k) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void GG() {
puts("-1");
exit(0);
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
void exgcd(long long x, long long y, long long &a, long long &b) {
if (!y) {
a = 1;
b = 0;
return;
}
exgcd(y, x % y, b, a);
b -= (x / y) * a;
}
long long getinv(long long x, long long y) {
long long a, b;
exgcd(x, y, a, b);
return (a % y + y) % y;
}
long long mul(long long x, long long y, long long mod) {
long long s = 0;
for (; y; y /= 2, x = (x + x) % mod)
if (y & 1) s = (s + x) % mod;
return s;
}
pair<long long, long long> operator/(pair<long long, long long> a,
pair<long long, long long> b) {
assert(a.first % b.first == 0);
assert(a.second >= b.second);
a.second -= b.second;
assert(a.second % b.first == 0);
return pair<long long, long long>(a.first / b.first, a.second / b.first);
}
pair<long long, long long> operator*(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first * b.first,
a.first * b.second + a.second);
}
void equation(pair<long long, long long> x, pair<long long, long long> y,
pair<long long, long long> &v1, pair<long long, long long> &v2) {
bool fl = (x < y);
if (fl) swap(x, y);
if (x == y) {
if (!x.first)
v1 = v2 = pair<long long, long long>(-1, 0);
else
v1 = v2 = pair<long long, long long>(1, 0);
} else if (!x.first)
GG();
else if (!y.first) {
if (x.second > y.second || (y.second - x.second) % x.first) GG();
v1 = pair<long long, long long>(0, (y.second - x.second) / x.first);
v2 = pair<long long, long long>(1, 0);
} else if (x.first == y.first) {
if ((x.second - y.second) % x.first) GG();
v1 = pair<long long, long long>(1, 0);
v2 = pair<long long, long long>(1, (x.second - y.second) / x.first);
} else {
long long G = gcd(x.first, y.first);
if (x.second % G != y.second % G) GG();
long long rem = x.second % G;
pair<long long, long long> X = x, Y = y;
x.first /= G;
y.first /= G;
x.second /= G;
y.second /= G;
long long mod = x.first * y.first;
long long val = (mul(x.second % x.first,
mul(y.first, getinv(y.first, x.first), mod), mod) +
mul(y.second % y.first,
mul(x.first, getinv(x.first, y.first), mod), mod)) %
mod;
if (val < x.second) val += ((x.second - val - 1) / mod + 1) * mod;
if (val < y.second) val += ((y.second - val - 1) / mod + 1) * mod;
pair<long long, long long> res(mod * G, val * G + rem);
v1 = res / X;
v2 = res / Y;
}
if (fl) swap(v1, v2);
}
void equationeq(pair<long long, long long> x, pair<long long, long long> y,
pair<long long, long long> &v1,
pair<long long, long long> &v2) {
if (x == y)
v1 = v2 = pair<long long, long long>(1, 0);
else {
if (x.first == y.first) GG();
long long T = (x.second - y.second) / (y.first - x.first);
if (x.first * T + x.second != y.first * T + y.second || T < 0) GG();
v1 = v2 = pair<long long, long long>(0, T);
}
}
void merge(pair<long long, long long> &v1, pair<long long, long long> &v2,
pair<long long, long long> l1, pair<long long, long long> l2) {
if (v1.first == -1) {
v1 = l1;
v2 = l2;
return;
}
if (l1.first == -1) return;
pair<long long, long long> i1, i2;
equation(v1, l1, i1, i2);
if (i1.first != -1) v1 = v1 * i1, l1 = l1 * i2, v2 = v2 * i1, l2 = l2 * i2;
equationeq(v2, l2, i1, i2);
v1 = v1 * i1;
l1 = l1 * i2;
v2 = v2 * i1;
l2 = l2 * i2;
}
map<int, pair<long long, long long> > tmp, ans;
void input(map<int, pair<long long, long long> > &mp) {
int x;
mp.clear();
scanf("%d", &x);
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int cnt = 0;
for (; x % i == 0; x /= i, ++cnt)
;
mp[i].second = cnt;
}
if (x != 1) mp[x].second++;
scanf("%d", &x);
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int cnt = 0;
for (; x % i == 0; x /= i, ++cnt)
;
mp[i].first = cnt;
}
if (x != 1) mp[x].first++;
}
map<int, pair<long long, long long> > merge(
map<int, pair<long long, long long> > x,
map<int, pair<long long, long long> > y) {
for (auto i : y) x[i.first].first += 0;
pair<long long, long long> lim1(-1, 0), lim2(-1, 0);
for (auto i : x) {
pair<long long, long long> v1 = i.second, v2 = y[i.first], l1, l2;
equation(v1, v2, l1, l2);
merge(lim1, lim2, l1, l2);
}
if (lim1 != pair<long long, long long>(-1, 0)) {
for (auto &i : x) i.second = i.second * lim1;
}
return x;
}
const int mo = 1000000007;
int power(int x, long long y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
int main() {
int n;
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n); i++) {
input(tmp);
if (i != 1)
ans = merge(ans, tmp);
else
ans = tmp;
}
int res = 1;
for (auto i : ans) res = 1ll * res * power(i.first, i.second.second) % mo;
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mdl = 1000000007LL;
void ext(long long a) {
cout << a << endl;
exit(0);
}
void fil() { ext(-1); }
long long ab(long long a) { return a < 0 ? -a : a; }
long long gcd(long long a, long long b) {
if (b == 0) return ab(a);
return gcd(b, a % b);
}
void adr(long long& rs1, long long& rp1, long long s2, long long p2) {
long long s1 = rs1;
long long p1 = rp1;
long long g = gcd(p1, p2);
if ((s2 - s1) % g) fil();
long long np = p1 / g * p2;
swap(p1, p2);
swap(s1, s2);
if (s2 < s1) {
s2 += p2 * ((s1 - s2 + p2 - 1) / p2);
}
long long gm = (s1 - s2) % p1;
if (gm < 0) gm += p1;
long long k;
for (k = 0; k < p1; k++) {
if (p2 % p1 * k % p1 == gm) {
break;
}
}
assert(k < p1);
rs1 = s2 + k * p2;
rp1 = np;
}
long long pw(long long a, long long b) {
long long r = 1;
for (long long i = 62; i >= 0; i--) {
r = r * r % mdl;
if (b & (1LL << i)) r = r * a % mdl;
}
return r;
}
void fl(long long a, map<long long, long long>& tp) {
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0) {
long long cc = 0;
while (a % i == 0) {
a /= i;
cc++;
}
tp[i] = cc;
}
}
if (a != 1) tp[a] = 1;
}
long long n;
vector<long long> a, b;
vector<map<long long, long long> > apw, bpw;
void rcb(long long id, map<long long, long long> npw) {
long long crc = bpw[id].begin()->first;
long long crp = bpw[id].begin()->second;
assert(crp);
long long st = apw[id][crc];
long long gl = npw[crc];
if (gl < st) fil();
if ((gl - st) % crp) fil();
long long cf = (gl - st) / crp;
for (auto i = (bpw[id]).begin(); i != (bpw[id]).end(); ++i) apw[id][i->first];
for (auto i = (npw).begin(); i != (npw).end(); ++i) apw[id][i->first];
for (auto i = (apw[id]).begin(); i != (apw[id]).end(); ++i)
if (i->second + cf * bpw[id][i->first] != npw[i->first]) fil();
}
void mksol(long long id, long long cb) {
map<long long, long long> npw;
for (auto i = (apw[id]).begin(); i != (apw[id]).end(); ++i)
npw[i->first] += i->second;
if (cb != 0) {
for (auto i = (bpw[id]).begin(); i != (bpw[id]).end(); ++i)
npw[i->first] += cb * i->second;
}
for (long long j = 0; j < (n); ++j) {
rcb(j, npw);
}
long long r = 1;
for (auto i = (npw).begin(); i != (npw).end(); ++i) {
r *= pw(i->first, i->second);
r %= mdl;
}
ext(r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
a.resize(n);
b.resize(n);
for (long long i = 0; i < (n); ++i) cin >> a[i] >> b[i];
if (n == 1) ext(a[0]);
for (long long i = 0; i < (n); ++i) {
if (b[i] == 1) {
for (long long j = 0; j < (n); ++j) {
long long cc = a[i];
if (cc % a[j]) fil();
cc /= a[j];
if (b[j] == 1 && cc != 1) fil();
while (cc != 1) {
if (cc % b[j]) fil();
cc /= b[j];
}
}
ext(a[i]);
}
}
apw.resize(n);
bpw.resize(n);
for (long long i = 0; i < (n); ++i) {
fl(a[i], apw[i]);
fl(b[i], bpw[i]);
}
for (long long i = 0; i < (n); ++i) {
for (long long j = 0; j < (n); ++j) {
if (j == i) continue;
long long fs = -1, sc, ca;
for (auto it = (bpw[i]).begin(); it != (bpw[i]).end(); ++it) {
if (!bpw[j].count(it->first)) {
long long iapw = 0;
if (apw[i].count(it->first)) iapw = apw[i][it->first];
long long japw = 0;
if (apw[j].count(it->first)) japw = apw[j][it->first];
long long ibpw = it->second;
if (japw < iapw) fil();
if ((japw - iapw) % ibpw) fil();
mksol(i, (japw - iapw) / ibpw);
}
long long cfs = it->second;
long long csc = bpw[j][it->first];
long long cca = 0;
if (apw[i].count(it->first)) cca = apw[i][it->first];
if (apw[j].count(it->first)) cca -= apw[j][it->first];
long long g = gcd(cfs, csc);
g = gcd(g, cca);
cfs /= g;
csc /= g;
cca /= g;
cca = -cca;
if (fs == -1) {
fs = cfs;
sc = csc;
ca = cca;
} else {
if (fs != cfs || sc != csc || ca != cca) {
long long upr = cca * fs - ca * cfs;
long long lwr = sc * cfs - csc * fs;
long long x2 = 0;
if (upr != 0) {
if (lwr == 0) fil();
if (upr % lwr) fil();
x2 = upr / lwr;
}
upr = ca + sc * x2;
lwr = fs;
long long x1 = 0;
if (upr != 0) {
if (lwr == 0) fil();
if (upr % lwr) fil();
x1 = upr / lwr;
}
mksol(i, x1);
}
}
}
}
}
long long fpw = bpw[0].begin()->first;
long long fsol = apw[0][fpw];
long long per = bpw[0][fpw];
for (long long i = 1; i < n; i++) {
adr(fsol, per, apw[i][fpw], bpw[i][fpw]);
}
mksol(0, (fsol - apw[0][fpw]) / bpw[0][fpw]);
return 0;
}
|
#include <bits/stdc++.h>
int MOD = int(1e9) + 7, INF = MOD;
inline int add(int a, int b) {
return (a + b >= MOD) ? (a + b - MOD) : (a + b);
}
inline void inc(int &a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return (a - b < 0) ? (a - b + MOD) : (a - b); }
inline void dec(int &a, int b) { a = sub(a, b); }
inline int mul(int a, int b) { return (a * 1ll * b) % MOD; }
using namespace std;
const int mod = 1000000007;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y), t = x;
x = y, y = t - a / b * y;
return g;
}
long long mypow(long long a, long long n) {
long long ans = 1;
a %= mod;
for (long long i = n; i; i >>= 1, a = a * a % mod)
if (i & 1) ans = ans * a % mod;
return ans;
}
const int maxn = 110, maxp = 2010;
int p[maxp], pn;
int a[maxn][maxp], b[maxn][maxp], n;
bool init() {
static int u[maxn], v[maxn];
scanf("%d", &n), pn = 0;
for (int i = 1, x, y; i <= n; ++i) {
scanf("%d%d", u + i, v + i);
for (x = u[i], y = 2; y <= x / y; ++y)
if (x % y == 0)
for (p[++pn] = y; x % y == 0; x /= y)
;
if (x != 1) p[++pn] = x;
for (x = v[i], y = 2; y <= x / y; ++y)
if (x % y == 0)
for (p[++pn] = y; x % y == 0; x /= y)
;
if (x != 1) p[++pn] = x;
}
if (n == 1) {
printf("%d\n", u[1]);
return true;
}
sort(p + 1, p + pn + 1), pn = unique(p + 1, p + pn + 1) - p - 1;
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= pn; ++j)
while (u[i] % p[j] == 0) ++b[i][j], u[i] /= p[j];
for (int j = 1; j <= pn; ++j)
while (v[i] % p[j] == 0) ++a[i][j], v[i] /= p[j];
}
return false;
}
struct equation {
long long A, B, C;
equation() : A(0), B(0), C(0) {}
equation(long long newA, long long newB, long long newC)
: A(newA), B(newB), C(newC) {}
};
bool empty(equation &t) {
if (!t.A && !t.B) return t.C;
long long g = gcd(abs(t.A), abs(t.B));
if (t.C % g) return true;
t.A /= g, t.B /= g, t.C /= g;
return false;
}
int merge(equation p, equation q, long long &x, long long &y) {
long long D = p.A * q.B - p.B * q.A;
x = p.C * q.B - q.C * p.B, y = p.A * q.C - p.C * q.A;
if (D) {
if (x % D || y % D) {
x = -1, y = -1;
return -1;
}
x /= D, y /= D;
return +1;
}
if (x || y) {
x = -1, y = -1;
return -1;
}
return 0;
}
long long check(long long x) {
if (x < 0) return -1;
for (int i = 2; i <= n; ++i) {
vector<long long> s;
s.clear();
for (int u = 1; u <= pn; ++u) {
long long z = a[1][u] * x + b[1][u] - b[i][u];
if (a[i][u]) {
if (z % a[i][u]) return -1;
s.push_back(z / a[i][u]);
} else if (z)
return -1;
}
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
if (s.size() > 1 || (s.size() == 1 && s.front() < 0)) return -1;
}
long long ans = 1;
for (int i = 1; i <= pn; ++i)
ans = ans * mypow(p[i], a[1][i] * x + b[1][i]) % mod;
return ans;
}
void solve() {
long long x = 0, y = 0;
bool find = false;
for (int i = 2; !find && i <= n; ++i)
for (int u = 1; !find && u <= pn; ++u) {
equation p(a[1][u], -a[i][u], b[i][u] - b[1][u]);
if (empty(p)) {
puts("-1");
return;
}
if (!p.B && p.A) {
x = p.C / p.A, find = true;
break;
}
for (int v = u + 1; v <= pn; ++v) {
equation q(a[1][v], -a[i][v], b[i][v] - b[1][v]);
int t = merge(p, q, x, y);
if (t == +1) {
find = true;
break;
}
if (t == -1) {
puts("-1");
return;
}
}
}
if (find) {
printf("%I64d\n", check(x));
return;
}
static long long c[maxn], d[maxn];
int m = 0;
long long minx = 0;
for (int i = 2; i <= n; ++i) {
for (int u = 1; u <= pn; ++u)
if (a[1][u]) {
long long A = a[1][u], B = a[i][u], C = b[i][u] - b[1][u];
long long g = exgcd(A, B, x, y);
++m;
minx = max(minx, (long long)ceil(1.0 * C / A));
c[m] = (C / g) * x % B, d[m] = B / g;
break;
}
}
for (int i = 2; i <= m; ++i) {
long long A = d[1], B = d[i], C = c[i] - c[1];
long long g = exgcd(A, B, x, y);
if (C % g) {
puts("-1");
return;
}
x = x * (C / g) % B;
c[1] = c[1] + x * A, d[1] = A / g * B;
c[1] %= d[1];
if (c[1] < 0) c[1] += d[1];
}
c[1] += ceil(1.0 * (minx - c[1]) / d[1]);
printf("%I64d\n", check(c[1]));
}
int main() {
if (!init()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2007;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
long long Pow(long long x, long long y) {
long long ans = 1, now = x;
while (y) {
if (y & 1) ans = ans * now % mod;
now = now * now % mod;
y >>= 1;
}
return ans;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
map<long long, long long> mp;
void fw(long long x) {
for (long long i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
while (x % i == 0) x /= i;
mp[i] = 1;
}
}
if (x > 1) mp[x] = 1;
}
long long a[N], b[N], t1[N], t2[N], vm[N], s1[N], s2[N], as[N], mt[N], dm[N],
dc[N], yc[N];
long long e[10] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}, qm[10], qc[10];
long long n, cnt = 0;
void ft(long long *gg, long long x) {
long long nw = x;
for (long long i = 1; i <= cnt; i++) {
gg[i] = 0;
while (nw % vm[i] == 0) {
nw /= vm[i];
gg[i]++;
}
}
}
bool check(long long *gg) {
for (long long i = 1; i <= n; i++) {
long long v = 0;
ft(t1, a[i]);
ft(t2, b[i]);
for (long long j = 1; j <= cnt; j++) {
if (gg[j] - t1[j]) {
if (!t2[j]) return 0;
if ((gg[j] - t1[j]) % t2[j] != 0) return 0;
v = (gg[j] - t1[j]) / t2[j];
break;
}
}
for (long long j = 1; j <= cnt; j++)
if (gg[j] != t1[j] + t2[j] * v) return 0;
}
return 1;
}
long long calc(long long *gg) {
long long ans = 1;
for (long long i = 1; i <= cnt; i++) ans = ans * Pow(vm[i], gg[i]) % mod;
return ans;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
fw(a[i]);
fw(b[i]);
}
if (n == 1) {
printf("%lld\n", a[1]);
return 0;
}
for (map<long long, long long>::iterator s = mp.begin(); s != mp.end(); s++) {
vm[++cnt] = s->first;
mp[s->first] = cnt;
}
for (long long i = 1; i <= n; i++) {
if (b[i] == 1) {
ft(as, a[i]);
if (check(as))
printf("%lld\n", a[i]);
else
puts("-1");
return 0;
}
}
for (long long i = 1; i <= n - 1; i++) {
ft(t1, b[i]);
ft(t2, b[i + 1]);
bool fl = 0;
long long ux, uy, d;
for (long long j = 1; j <= cnt; j++)
if (t1[j]) ux = t1[j], uy = t2[j], d = j;
for (long long j = 1; j <= cnt; j++) {
if (t1[j] * uy != t2[j] * ux) {
ft(s1, a[i]);
ft(s2, a[i + 1]);
long long bb =
(s2[d] * t1[j] - s2[j] * t1[d] + t1[d] * s1[j] - t1[j] * s1[d]);
long long cc = t1[d] * t2[j] - t1[j] * t2[d];
if (!cc) {
puts("-1");
return 0;
}
if (cc < 0) bb = -bb, cc = -cc;
if (bb % cc != 0) {
puts("-1");
return 0;
}
long long y = bb / cc;
if (y < 0) {
puts("-1");
return 0;
}
int ub = s2[d] - s1[d] + t2[d] * y;
if (ub % t1[d] != 0) {
puts("-1");
return 0;
}
if (ub < 0) {
puts("-1");
return 0;
}
for (long long k = 1; k <= cnt; k++) as[k] = s2[k] + t2[k] * y;
if (check(as))
printf("%lld\n", calc(as));
else
puts("-1");
return 0;
}
}
}
long long mi = INF, hd;
for (long long i = 1; i <= n; i++) mi = min(mi, a[i]);
ft(t1, b[1]);
for (long long i = 1; i <= cnt; i++) mt[i] = t1[i];
for (long long i = 1; i <= cnt; i++)
if (mt[i]) {
hd = i;
break;
}
dm[1] = t1[hd];
for (long long i = 2; i <= n; i++) {
ft(t1, b[i]);
dm[i] = t1[hd];
for (long long j = 1; j <= cnt; j++) mt[j] = gcd(mt[j], t1[j]);
}
ft(t1, mi);
for (long long i = 1; i <= n; i++) {
ft(t2, a[i]);
dc[i] = t2[hd];
long long ls = -1;
for (long long j = 1; j <= cnt; j++) {
if (!mt[j]) continue;
if ((t2[j] - t1[j]) % mt[j] != 0) {
puts("-1");
return 0;
}
if (ls < 0)
ls = (t2[j] - t1[j]) / mt[j];
else if (t2[j] != t1[j] + mt[j] * ls) {
puts("-1");
return 0;
}
}
}
for (long long i = 0; i <= 10 - 1; i++) qm[i] = 1, qc[i] = 0;
for (long long i = 1; i <= n; i++) {
yc[i] = dc[i];
dc[i] %= dm[i];
for (long long j = 0; j <= 10 - 1; j++) {
long long gg = 1, nw = dm[i];
while (nw % e[j] == 0) gg *= e[j], nw /= e[j];
long long ng = dc[i] % gg;
if (gg >= qm[j]) {
if (ng % qm[j] != qc[j]) {
puts("-1");
return 0;
}
qm[j] = gg;
qc[j] = ng;
} else {
if (qc[j] % gg != ng) {
puts("-1");
return 0;
}
}
}
}
long long S = 0, mm = 1;
for (long long i = 0; i <= 10 - 1; i++) {
if (qm[i] == 1) continue;
long long sc = 1;
for (long long j = 0; j <= 10 - 1; j++)
if (i != j) sc *= qm[j];
long long mc = sc % qm[i], iv;
for (long long j = 0; j <= qm[i] - 1; j++)
if (j * mc % qm[i] == 1) {
iv = j;
break;
}
iv = iv * qc[i] % qm[i];
S += sc * iv;
mm *= qm[i];
}
S %= mm;
for (long long i = 1; i <= n; i++)
while (S < yc[i]) S += mm;
ft(t1, a[1]);
ft(t2, b[1]);
for (long long i = 1; i <= cnt; i++)
as[i] = t2[i] * ((S - dc[1]) / dm[1]) + t1[i];
printf("%lld\n", calc(as));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
int n;
map<int, int> mp;
int cnt = 0;
int A[105], B[105];
int Ans = 1;
inline int Fast_Pow(int a, long long b) {
b %= (Mod - 1);
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % Mod;
a = 1ll * a * a % Mod;
b >>= 1;
}
return res;
}
int num[105];
struct Data {
int p;
int a[105], b[105];
bool vis;
int Judge() {
bool flag = false;
int at;
for (int i = 1; i <= n; ++i)
if (!b[i]) {
flag = true;
at = i;
break;
}
if (!flag) return -1;
for (int i = 1; i <= n; ++i)
if (at != i) {
if (b[i]) {
if (a[i] > a[at]) {
num[i] = 0;
return i;
} else if ((a[at] - a[i]) % b[i] != 0) {
num[i] = 0;
return i;
} else {
num[i] = (a[at] - a[i]) / b[i];
return i;
}
} else if (a[i] != a[at]) {
num[i] = 0;
return i;
}
}
vis = true;
return -1;
}
} data[2005], seq[2005];
int len;
void calc(int x) {
for (int i = 1; i <= cnt; ++i)
seq[i].a[x] = seq[i].a[x] + num[x] * seq[i].b[x];
for (int i = 1; i <= n; ++i)
if (i != x) {
int z = -1;
for (int j = 1; j <= cnt; ++j)
if (seq[j].b[i] == 0) {
if (seq[j].a[i] != seq[j].a[x]) {
puts("-1");
exit(0);
}
} else {
if (seq[j].a[i] > seq[j].a[x]) {
puts("-1");
exit(0);
}
if ((seq[j].a[x] - seq[j].a[i]) % seq[j].b[i] != 0) {
puts("-1");
exit(0);
}
int t = (seq[j].a[x] - seq[j].a[i]) / seq[j].b[i];
if (z != -1 && z != t) {
puts("-1");
exit(0);
}
z = t;
}
}
Ans = 1ll * A[x] * Fast_Pow(B[x], num[x]) % Mod;
printf("%d\n", Ans);
exit(0);
}
int P() {
for (int i = 2; i <= n; ++i)
for (int j = 2; j <= cnt; ++j) {
if (seq[j].b[i] * seq[1].b[i - 1] != seq[1].b[i] * seq[j].b[i - 1]) {
for (int Y = 0; Y <= 1000; ++Y) {
int t1 = seq[1].a[i] - seq[1].a[i - 1] + Y * seq[1].b[i],
t2 = seq[j].a[i] - seq[j].a[i - 1] + Y * seq[j].b[i];
if (t1 % seq[1].b[i - 1] != 0 || t2 % seq[j].b[i - 1] != 0 ||
t1 < 0 || t2 < 0)
continue;
t1 /= seq[1].b[i - 1];
t2 /= seq[j].b[i - 1];
if (t1 != t2) continue;
num[i - 1] = t1;
return i - 1;
}
puts("-1");
exit(0);
} else if ((seq[1].a[i] - seq[1].a[i - 1]) * seq[j].b[i - 1] !=
(seq[j].a[i] - seq[j].a[i - 1]) * seq[1].b[i - 1]) {
puts("-1");
exit(0);
}
}
return -1;
}
long long gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
long long inv(long long a, long long b) {
long long x, y;
exgcd(a, b, x, y);
return (x % b + b) % b;
}
void solve() {
long long s = seq[1].a[1] % seq[1].b[1], w = seq[1].b[1];
for (int i = 2; i <= n; ++i) {
long long u = seq[1].a[i] % seq[1].b[i], v = seq[1].b[i];
long long d = gcd(w, v);
if ((u - s) % d != 0) {
puts("-1");
exit(0);
}
long long ww = w / d, vv = v / d, cc = (u - s) / d;
long long z = inv(ww, vv);
long long x = (z * cc % vv + vv) % vv;
s = w * x + s;
w = ww * vv * d;
}
for (int i = 1; i <= n; ++i)
while (s < seq[1].a[i]) s += w;
Ans = 1ll * A[1] * Fast_Pow(B[1], (s - seq[1].a[1]) / seq[1].b[1]) % Mod;
printf("%d\n", Ans);
}
void getphi(int x, int id, int ty) {
int tmp = x;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
int ad = 0;
while (tmp % i == 0) {
ad++;
tmp /= i;
}
if (!mp[i]) {
mp[i] = ++cnt;
data[cnt].p = i;
}
if (ty == 1)
data[mp[i]].a[id] = ad;
else
data[mp[i]].b[id] = ad;
}
if (tmp > 1) {
if (!mp[tmp]) {
mp[tmp] = ++cnt;
data[cnt].p = tmp;
}
if (ty == 1)
data[mp[tmp]].a[id] = 1;
else
data[mp[tmp]].b[id] = 1;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &A[i], &B[i]);
getphi(A[i], i, 1);
getphi(B[i], i, 2);
}
int t = -1;
for (int i = 1; i <= cnt; ++i) {
int z = data[i].Judge();
if (!data[i].vis) {
len++;
for (int j = 1; j <= n; ++j) {
seq[len].a[j] = data[i].a[j];
seq[len].b[j] = data[i].b[j];
}
}
if (z != -1) t = z;
}
cnt = len;
if (t != -1) {
calc(t);
return 0;
}
int p = P();
if (p != -1) {
calc(p);
return 0;
}
if (cnt == 0) {
printf("%d\n", A[1]);
return 0;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
const int mod = 1e9 + 7;
int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
void ade(int& x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int qpow(int x, long long k) {
int r = 1;
while (k) {
if (k & 1) r = 1ll * r * x % mod;
k >>= 1;
x = 1ll * x * x % mod;
}
return r;
}
int n;
int pri[100100], m;
int a_[110], b_[110];
void pia(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
while (x % i == 0) x /= i;
pri[++m] = i;
}
if (x != 1) pri[++m] = x;
}
int c[110][2020], d[110][2020];
void build(int id, int a, int b) {
int p;
for (int i = 1; i <= m; ++i) {
p = pri[i];
while (a % p == 0) a /= p, c[id][i]++;
while (b % p == 0) b /= p, d[id][i]++;
}
}
bool ign[2020];
long long pro = 1;
long long ans[2020];
void CheckAns() {
for (int j = 1; j <= m; ++j)
for (int i = 1; i <= n; ++i) {
if (ign[j]) continue;
if (!d[i][j]) {
if (ans[j] - c[i][j]) puts("-1"), exit(0);
} else if (ans[j] < c[i][j] || (ans[j] - c[i][j]) % d[i][j])
puts("-1"), exit(0);
}
int out = pro;
for (int i = 1; i <= m; ++i)
if (!ign[i]) out = 1ll * out * qpow(pri[i], ans[i]) % mod;
printf("%d\n", out);
}
void Equa(int a1, int b1, int c1, int a2, int b2, int c2) {
int lc = lcm(a1, a2), p1 = lc / a1, p2 = lc / a2;
a1 = a2 = lc;
b1 *= p1, c1 *= p1;
b2 *= p2, c2 *= p2;
int b, nc;
int x, y;
b = b2 - b1, nc = c2 - c1;
if (nc % b) puts("-1"), exit(0);
y = nc / b;
c1 -= b1 * y;
if (c1 % a1) puts("-1"), exit(0);
x = c1 / a1;
if (x < 0 || y < 0) puts("-1"), exit(0);
for (int i = 1; i <= m; ++i) ans[i] = c[1][i] + x * d[1][i];
CheckAns();
}
void exgcd(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a_[i], &b_[i]);
pia(a_[i]);
pia(b_[i]);
}
sort(pri + 1, pri + m + 1);
m = unique(pri + 1, pri + m + 1) - pri - 1;
for (int i = 1; i <= n; ++i) build(i, a_[i], b_[i]);
for (int j = 1; j <= m; ++j) {
int fl1 = 0, fl2 = 0;
for (int u = 1; u <= n; ++u)
if (!d[u][j])
fl1 = u;
else
fl2 = u;
if (!fl1) continue;
if (!fl2) {
for (int i = 1; i <= n; ++i)
if (c[i][j] != c[1][j]) puts("-1"), exit(0);
(pro *= qpow(pri[j], c[1][j])) %= mod;
ign[j] = 1;
} else {
int k = c[fl1][j] - c[fl2][j];
if (k % d[fl2][j] || k < 0) puts("-1"), exit(0);
k /= d[fl2][j];
for (int i = 1; i <= m; ++i) ans[i] = k * d[fl2][i] + c[fl2][i];
CheckAns();
return 0;
}
}
int pos = 1;
while (ign[pos]) pos++;
if (pos > m) {
printf("%lld\n", pro);
return 0;
}
swap(pri[1], pri[pos]);
swap(ign[1], ign[pos]);
for (int i = 1; i <= n; ++i)
swap(c[i][1], c[i][pos]), swap(d[i][1], d[i][pos]);
for (int j = 2; j <= m; ++j) {
for (int i = 2; i <= n; ++i) {
if (d[1][1] * d[i][j] != d[1][j] * d[i][1]) {
Equa(d[1][1], -d[i][1], c[i][1] - c[1][1], d[1][j], -d[i][j],
c[i][j] - c[1][j]);
return 0;
} else if ((c[i][j] - c[1][j]) * d[1][1] != (c[i][1] - c[1][1]) * d[1][j])
puts("-1"), exit(0);
}
}
long long A = c[1][1], M = d[1][1];
long long a, g, x, y, t;
for (int i = 2; i <= n; ++i) {
a = c[i][1] - A;
g = gcd(M, d[i][1]);
if (a % g) puts("-1"), exit(0);
t = d[i][1] / g;
exgcd(M, d[i][1], x, y);
x = (x % t + t) % t;
x *= a / g;
x = (x % t + t) % t;
A += x * M;
M = lcm(M, d[i][1]);
A = (A % M + M) % M;
}
for (int i = 1; i <= n; ++i)
while (A < c[i][1]) A += M;
long long k;
if (!d[1][1])
k = 0;
else
k = (A - c[1][1]) / d[1][1];
for (int i = 1; i <= m; ++i) ans[i] = c[1][i] + k * d[1][i];
CheckAns();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const int mod = 1e9 + 7;
inline int Pow(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) res = (long long)res * x % mod;
return res;
}
inline void FUCK() { puts("-1"), exit(0); }
map<long long, pair<long long, long long> > wkr[N];
inline void test(int a, int b) {
long long cur = -1;
for (auto t : wkr[b])
if (!wkr[a].count(t.first)) FUCK();
for (auto t : wkr[a])
if (wkr[b].count(t.first)) {
auto A = t.second, B = wkr[b][t.first];
if (A.second != B.second) {
if (!B.first) FUCK();
if (A.second < B.second || (A.second - B.second) % B.first) FUCK();
}
long long hh = B.first ? (A.second - B.second) / B.first : -1;
if (cur == -1) cur = hh;
if (cur != hh) FUCK();
} else
FUCK();
}
int n, tot;
long long A, B, C;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long G[2][2];
inline long long Det() { return G[0][0] * G[1][1] - G[0][1] * G[1][0]; }
inline bool push(long long tA, long long tB, long long tC) {
long long g = gcd(tA, tB);
assert(g);
if (tC % g) FUCK();
tA /= g, tB /= g, tC /= g;
if (!A) return A = tA, B = tB, C = tC, false;
if (A == tA && B == tB) {
if (C != tC) FUCK();
return false;
}
G[0][0] = A, G[0][1] = B, G[1][0] = tA, G[1][1] = tB;
long long base = Det();
assert(base);
G[0][0] = C, G[0][1] = B, G[1][0] = tC, G[1][1] = tB;
long long t1 = Det();
if (t1 % base) FUCK();
G[0][0] = A, G[0][1] = C, G[1][0] = tA, G[1][1] = tC;
long long t2 = Det();
if (t2 % base) FUCK();
long long x = t1 / base, y = t2 / base;
if (x < 0 || y < 0) FUCK();
A = x, B = y;
return true;
}
long long x, y;
long long exgcd(long long a, long long b) {
if (!b) return x = 1, y = 0, a;
long long d = exgcd(b, a % b), t = x;
x = y, y = t - a / b * y;
return d;
}
inline void merge(int a, int b) {
A = B = C = 0, tot++;
bool flag = false;
for (auto t : wkr[a])
if (wkr[b].count(t.first)) {
auto A = t.second, B = wkr[b][t.first];
if (push(A.first, -B.first, B.second - A.second)) {
flag = true;
break;
}
} else
FUCK();
for (auto t : wkr[b])
if (!wkr[a].count(t.first)) FUCK();
if (flag) {
int ans = 1;
for (auto t : wkr[a]) {
long long tmp = t.second.first * A + t.second.second;
wkr[tot][t.first] = pair<long long, long long>(0, tmp);
ans = (long long)ans * Pow(t.first, tmp % (mod - 1)) % mod;
}
for (int i = 1; i <= n; i++) test(tot, i);
printf("%d\n", ans), exit(0);
}
if (!A) FUCK();
if (B < 0) A = -A, B = -B, C = -C;
long long g = exgcd(A, B);
x *= C / g, x = (x % B + B) % B;
for (auto t : wkr[a])
wkr[tot][t.first] = pair<long long, long long>(
B * t.second.first, t.second.second + t.second.first * x);
}
int fuck[N], zjk[N];
inline void test(int x) {
for (int i = 1; i <= n; i++) {
if (x % fuck[i]) return;
int tmp = x / fuck[i];
while (tmp > 1) {
if (tmp % zjk[i]) return;
tmp /= zjk[i];
}
if (tmp == 0) return;
}
printf("%d\n", x), exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b), fuck[i] = a, zjk[i] = b;
for (int j = 2; (j * j <= a) || (j * j <= b); j++)
if (a % j == 0 || b % j == 0) {
int ct = 0, ct1 = 0;
while (a % j == 0) ct++, a /= j;
while (b % j == 0) ct1++, b /= j;
wkr[i][j] = pair<long long, long long>(ct1, ct);
}
if (a != 1 || b != 1) {
if (a == b)
wkr[i][a] = pair<long long, long long>(1, 1);
else {
if (a != 1) wkr[i][a] = pair<long long, long long>(0, 1);
if (b != 1) wkr[i][b] = pair<long long, long long>(1, 0);
}
}
}
test(1);
for (int i = 1; i <= n; i++) test(fuck[i]);
tot = n, merge(1, 2);
for (int i = 3; i <= n; i++) merge(tot, i);
for (int i = 1; i <= n; i++) test(tot, i);
int ans = 1;
for (auto t : wkr[tot])
ans = (long long)ans * Pow(t.first, t.second.second % (mod - 1)) % mod;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
inline long long Abs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct item {
int p;
long long k;
item(int p = 0, long long k = 0) : p(p), k(k) {}
};
struct Num {
item p[810];
int num;
void init(int x) {
for (int i = 2; i * (long long)i <= x; ++i)
if (x % i == 0) {
int c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = item(i, c);
}
if (x > 1) p[num++] = item(x, 1);
}
item query(int x) {
for (int i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return item(x, 0);
}
} A[110], B[110];
int n;
void FAIL() {
puts("-1");
exit(0);
}
item A1[3210], B1[3210], A2[3210], B2[3210];
int pri[3210], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void Inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a), swap(B, b), swap(C, c);
}
if (c % b) FAIL();
x2 = -c / b;
if ((C + B * x2) % A) FAIL();
x1 = (-C - B * x2) / A;
}
void UN(Num &a1, Num &b1, Num &a2, Num &b2) {
num = 0;
for (int i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (int i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (int i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (int i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (int i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (int i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (int i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (int i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
int flg1 = 0;
long long x1, x2;
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) FAIL();
continue;
}
long long g = gcd(a, gcd(-b, Abs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) FAIL();
if (-c / a < 0) FAIL();
}
if (!a) {
if (c % b) FAIL();
if (-c / b < 0) FAIL();
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (a && C / A != c / a) FAIL();
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
FAIL();
}
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) FAIL();
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
return;
}
long long g = exgcd(A, B, x1, x2);
if (C % g) FAIL();
x1 *= -C / g, x2 *= -C / g;
long long tx = Abs(-B / g), ty = Abs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
}
const int mod = 1e9 + 7;
int Pow(int x, long long y) {
int res = 1;
for (y %= (mod - 1); y; x = x * (long long)x % mod, y >>= 1)
if (y & 1) res = res * (long long)x % mod;
return res;
}
int main() {
rd(n);
for (int i = 1, a, b; i <= n; ++i) rd(a), rd(b), A[i].init(a), B[i].init(b);
for (int i = 2; i <= n; ++i) UN(A[1], B[1], A[i], B[i]);
long long ans = 1;
for (int i = 0; i < A[1].num; ++i)
ans = ans * (long long)Pow(A[1].p[i].p, A[1].p[i].k) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long v, long long st, long long mod) {
long long res = 1;
while (st) {
if (st & 1) {
res = res * v;
if (res >= mod) {
res %= mod;
}
}
v = v * v;
if (v >= mod) {
v %= mod;
}
st = st / 2;
}
return res;
}
const int mod = 1000000007;
int n;
long long a[128], b[128];
long long l[128][128], t[128][128];
set<int> primes;
void push_primes(long long x) {
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
primes.insert(i);
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
primes.insert(x);
}
}
inline int maxpow(long long n, long long d) {
int res = 0;
while (n % d == 0) {
n /= d;
++res;
}
return res;
}
bool trySol(int i, long long k) {
long long sol[128];
memset(sol, -1, sizeof(sol));
for (set<int>::iterator it = primes.begin(); it != primes.end(); ++it) {
long long p = *it;
long long at, bt;
at = maxpow(a[i], p);
bt = maxpow(b[i], p);
long long tar = at + k * bt;
for (int j = 0; j < n; ++j) {
long long ap = maxpow(a[j], p);
long long bp = maxpow(b[j], p);
if (ap > tar) {
printf("-1\n");
return 0;
}
if (bp == 0) {
if (ap != tar) {
printf("-1\n");
return 0;
}
} else {
if (ap > tar || (tar - ap) % bp != 0) {
printf("-1\n");
return 0;
}
if (sol[j] == -1) {
sol[j] = (tar - ap) / bp;
}
if (sol[j] != (tar - ap) / bp) {
printf("-1\n");
return 0;
}
}
}
}
printf("%lld\n", (a[i] * qpow(b[i], k, mod)) % mod);
return 0;
}
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
bool getInv(long long a, long long m, long long *res) {
long long x, y;
long long g = gcdex(a, m, x, y);
if (g != 1) {
return 0;
} else {
x = (x % m + m) % m;
*res = x;
return 1;
}
}
long long r[128][128];
long long x[128];
bool CRT(int cnt, long long as[], long long bs[], long long *minval,
long long *period) {
map<long long, long long> mp;
for (int i = 0; i < cnt; ++i) {
long long v = bs[i];
for (long long j = 2; j * j <= v; ++j) {
if (v % j == 0) {
long long d = 1;
while (v % j == 0) {
d = d * j;
v = v / j;
}
vector<map<long long, long long>::iterator> torm;
bool strong = false;
for (map<long long, long long>::iterator it = mp.begin();
it != mp.end(); ++it) {
if (it->first % d == 0) {
strong = true;
if (as[i] % d != it->second % d) {
printf("-1\n");
return 0;
}
} else if (d % it->first == 0) {
torm.push_back(it);
if (as[i] % it->first != it->second % it->first) {
printf("-1\n");
return 0;
}
}
}
for (int j = 0; j < (int)torm.size(); ++j) {
mp.erase(torm[j]);
}
if (!strong) {
mp[d] = as[i] % d;
}
}
}
if (v != 1) {
long long d = v;
bool strong = false;
vector<map<long long, long long>::iterator> torm;
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
if (it->first % d == 0) {
strong = true;
if (as[i] % d != it->second % d) {
printf("-1\n");
return 0;
}
} else if (d % it->first == 0) {
torm.push_back(it);
if (as[i] % it->first != it->second % it->first) {
printf("-1\n");
return 0;
}
}
}
for (int j = 0; j < (int)torm.size(); ++j) {
mp.erase(torm[j]);
}
if (!strong) {
mp[d] = as[i] % d;
}
}
}
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
}
int i, j;
i = j = 0;
long long mx = 0;
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it, ++i) {
if (it->first > mx) {
mx = it->first;
}
j = 0;
for (map<long long, long long>::iterator jt = mp.begin(); jt != mp.end();
++jt, ++j) {
if (i != j) {
int res = getInv(it->first, jt->first, &r[i][j]);
if (!res) {
printf("-1\n");
return 0;
}
}
}
}
if (mx > 32) {
printf("WTF MAX %lld\n", mx);
}
i = 0;
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it, ++i) {
x[i] = it->second;
j = 0;
for (map<long long, long long>::iterator jt = mp.begin();
jt != mp.end() && j < i; ++jt, ++j) {
long long ss = x[i] - x[j];
x[i] = r[j][i] * ss;
x[i] = x[i] % it->first;
if (x[i] < 0) x[i] += it->first;
}
}
long long a;
long long pref = 1;
a = x[0];
i = 0;
for (map<long long, long long>::iterator it = mp.begin();
it != mp.end() && i + 1 < (int)mp.size(); ++it, ++i) {
pref = pref * it->first;
a = a + pref * x[i + 1];
}
long long lcm = 1;
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
lcm *= it->first;
}
for (int i = 0; i < cnt; ++i) {
while (a < as[i]) {
a += lcm;
}
}
*minval = a;
*period = lcm;
return 1;
}
bool solve_prime(int p, int id) {
long long apow[128], bpow[128];
int unmove = -1;
int move = -1;
int samea = -1;
for (int i = 0; i < n; ++i) {
apow[i] = maxpow(a[i], p);
bpow[i] = maxpow(b[i], p);
if (bpow[i] > 0) {
move = i;
}
if (bpow[i] == 0) {
unmove = i;
}
if (samea == -1) {
samea = apow[i];
}
if (apow[i] != samea) {
samea = -2;
}
}
if (unmove != -1) {
if (move == -1 && samea == -2) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; ++i) {
if (bpow[i] == 0 && apow[i] != apow[unmove]) {
printf("-1\n");
return 0;
}
if (bpow[i] != 0) {
long long k = apow[unmove] - apow[i];
if (k < 0 || k % bpow[i] != 0) {
printf("-1\n");
return 0;
}
k = k / bpow[i];
return trySol(i, k);
}
}
for (int i = 0; i < n; ++i) {
l[id][i] = 0;
t[id][i] = 1;
}
return 1;
}
long long minval, period;
int ret = CRT(n, apow, bpow, &minval, &period);
for (int i = 0; i < n; ++i) {
if ((minval - apow[i]) % bpow[i] != 0 || minval < apow[i]) {
if (ret) {
printf("ERROR DOING CRT %lld %lld %lld\n", minval, apow[i], bpow[i]);
}
}
l[id][i] = (minval - apow[i]) / bpow[i];
if (period % bpow[i] != 0) {
if (ret) {
printf("ERROR2 DOING CRT %lld %lld %lld\n", period, apow[i], bpow[i]);
}
}
t[id][i] = period / bpow[i];
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld %lld", &a[i], &b[i]);
push_primes(a[i]);
push_primes(b[i]);
}
int realp = 0;
int la = 0;
for (set<int>::iterator it = primes.begin(); it != primes.end(); ++it) {
if (!solve_prime(*it, la)) {
return 0;
}
bool fake = true;
for (int j = 0; j < n; ++j) {
if (l[la][j] != 0 || t[la][j] != 0) {
fake = false;
}
}
if (!fake) {
++realp;
}
++la;
}
if ((int)primes.size() == 1) {
printf("%lld\n", (a[0] * qpow(b[0], l[0][0], mod)) % mod);
return 0;
}
int numvars = n * realp;
if (numvars == 0) {
printf("%lld\n", a[0]);
return 0;
}
for (int p = 0; p < la; ++p) {
for (int q = p + 1; q < la; ++q) {
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
long long mb = t[q][i] * t[p][j] - t[q][j] * t[p][i];
long long eq =
(l[p][i] - l[q][i]) * t[p][j] - (l[p][j] - l[q][j]) * t[p][i];
if (mb == 0) {
if (eq != 0) {
printf("-1\n");
return 0;
}
} else {
if (eq % mb != 0) {
printf("-1\n");
return 0;
}
long long b = eq / mb;
trySol(i, l[q][i] + t[q][i] * b);
return 0;
}
}
}
}
}
for (int i = 0; i < n; ++i) {
bool good = false;
for (int p = 0; p < la; ++p) {
if (l[p][i] != 0 || t[p][i] != 0) {
good = true;
}
}
if (good) {
long long minval, period;
long long ap[32], bp[32];
int fi = 0;
for (int p = 0; p < la; ++p) {
ap[p] = l[p][i];
bp[p] = t[p][i];
}
int ret = CRT(la, ap, bp, &minval, &period);
trySol(i, minval);
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline long long kpow(long long a, long long b) {
a %= mod, b %= (mod - 1);
long long s = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) s = s * a % mod;
return s;
}
void no() {
printf("-1");
exit(0);
}
long long n, a[110], b[110], mib = 0x3f3f3f3f;
bool bj[100010];
long long su[100010], sunum;
void init() {
bj[1] = 1;
for (long long i = 2; i <= 100000; ++i) {
if (!bj[i]) su[++sunum] = i;
for (long long j = 1; j <= sunum && su[j] * i <= 100000; ++j) {
bj[su[j] * i] = 1;
if (i % su[j] == 0) break;
}
}
}
map<long long, long long> mp;
bool check(long long w) {
for (long long s = w, i = 1; s <= 1000000000; s *= w, ++i) mp[s] = i;
for (long long i = 1; i <= n; ++i)
if (!mp[b[i]]) return 0;
return 1;
}
map<long long, long long> da[110], db[110];
void divi(long long x, map<long long, long long> &mp) {
for (long long i = 1; su[i] * su[i] <= x; ++i)
if (x % su[i] == 0) {
long long cnt = 0;
while (x % su[i] == 0) ++cnt, x /= su[i];
mp[su[i]] = cnt;
}
if (x > 1) mp[x] = 1;
}
void work(long long w) {
for (long long i = 1; i <= n; ++i) {
long long c = a[i];
while (c < w) c *= b[i];
if (c != w) no();
}
printf("%lld", w);
exit(0);
}
void work1(long long A, long long B, long long N) {
if (N < 0) no();
map<long long, long long> dw, dA, dB, dC;
divi(A, dA), divi(B, dB);
dw = dA;
for (auto p : dB) dw[p.first] += N * p.second;
for (long long i = 1; i <= n; ++i) {
dC = da[i];
for (auto p : dw) dC[p.first];
for (auto p : dC)
if (p.second != dw[p.first]) {
if (!db[i][p.first]) no();
long long c = (dw[p.first] - p.second) / db[i][p.first];
if (c < 0) no();
for (auto q : db[i]) dC[q.first] += q.second * c;
break;
}
for (auto p : dC)
if (p.second != dw[p.first]) no();
}
long long ans = 1;
for (auto p : dw) ans = ans * kpow(p.first, p.second) % mod;
printf("%lld", ans);
exit(0);
}
long long gcd(long long a, long long b) {
if (!a || !b) return a + b;
return gcd(b, a % b);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
if (!a) {
x = 0, y = 1;
return b;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void solve1(long long s) {
long long sa = 0;
long long k[110], t[110];
for (long long i = 1; i <= n; ++i) {
long long x = a[i];
t[i] = 0;
k[i] = mp[b[i]];
while (x % s == 0) x /= s, ++t[i];
if (sa && sa != x) no();
sa = x;
}
long long nk = 1, nt = 0, x, y, mx = 0;
for (long long i = 1; i <= n; ++i) {
long long g = exgcd(nk, k[i], x, y);
y = -y;
if ((t[i] - nt) % g) {
no();
}
long long w = (t[i] - nt) / g;
if (w < 0) x = -x, y = -y, w = -w;
x = x % (k[i] / g) * (w % (k[i] / g)) % (k[i] / g);
if (x < 0) x += k[i] / g;
nt = x * nk + nt;
while (nt < t[i]) nt += nk;
nk = nk * k[i] / g;
mx = max(mx, nt);
}
work1(sa, s, nt);
}
void solve2() {
long long p;
for (long long i = 2; i <= n; ++i)
if (!mp[b[i]]) {
p = i;
break;
}
for (auto q : db[1])
if (!db[p].count(q.first))
work1(a[1], b[1], (da[p][q.first] - da[1][q.first]) / q.second);
for (auto q : db[p])
if (!db[1].count(q.first))
work1(a[p], b[p], (da[1][q.first] - da[p][q.first]) / q.second);
long long a1 = db[1].begin()->second, b1 = -db[p].begin()->second,
c1 = da[p][db[1].begin()->first] - da[1][db[1].begin()->first];
long long a2, b2, c2;
for (auto q : db[1]) {
a2 = q.second, b2 = -db[p][q.first], c2 = da[p][q.first] - da[1][q.first];
if (a1 * b2 != a2 * b1)
work1(a[1], b[1], (c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1));
}
}
int main() {
init();
scanf("%lld", &n);
for (long long i = 1; i <= n; ++i) {
scanf("%lld %lld", &a[i], &b[i]);
divi(a[i], da[i]);
divi(b[i], db[i]);
mib = min(mib, b[i]);
}
if (mib == 1) {
for (long long i = 1; i <= n; ++i)
if (b[i] == 1) {
work(a[i]);
break;
}
return 0;
}
long long g = 0;
for (auto p : db[1]) g = gcd(g, p.second);
long long s = 1;
for (auto p : db[1]) {
long long cnt = p.second / g;
while (cnt--) s *= p.first;
}
if (check(s))
solve1(s);
else
solve2();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int MM = 31625;
struct simpen {
long long a, b, c;
void print() { printf("%I64d %I64d %I64d\n", a, b, c); }
};
long long n, a[MM], b[MM], pr[MM], cpp = 0, cpr = 0, aa[MM], bb[MM], valen[MM],
momod[MM];
bool prpr[MM];
simpen p[MM];
long long dio(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = dio(b, a % b, y, x);
y = y - x * (a / b);
return d;
}
void start() {
for (int i = 2; i * i <= 1000000000; i++) {
bool test = 1;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
test = 0;
break;
}
}
if (test) pr[cpr++] = i;
}
}
long long get(long long x, const int &y) {
long long ret = 0;
while (!(x % pr[y])) x /= pr[y], ++ret;
return ret;
}
long long cc(long long a, long long b) {
if (b < 0) a *= -1, b *= -1;
if (a < 0) return a / b;
return (a + b - 1) / b;
}
long long floor(long long a, long long b) { return -cc(-a, -b); }
long long asdf(long long b, long long e, long long m) {
long long t = 0;
for (; e; e >>= 1, (b <<= 1) %= m)
if (e & 1) (t += b) %= m;
return t;
}
long long power(long long a, long long n, long long mod) {
return (n == 0
? 1
: (power(a * a % mod, n / 2, mod)) * (n % 2 == 1 ? a : 1) % mod);
}
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) scanf("%I64d %I64d", &b[i], &a[i]);
start();
for (int i = 0; i < cpr; i++)
aa[i] = get(a[n - 1], i), bb[i] = get(b[n - 1], i);
long long res = -1;
for (int i = 0; i < n - 1; i++) {
bool test = 0;
simpen cewe;
for (int j = 0; j < cpr; j++) {
long long a0 = aa[j], b0 = bb[j];
long long a1 = get(a[i], j), b1 = get(b[i], j);
if (a0 || a1 || b0 != b1) {
if (b0 != b1 && !a0 && !a1) {
printf("-1\n");
return 0;
}
if (a1 || a0) {
if (!test) {
cewe.a = a0;
cewe.b = -a1;
cewe.c = b0 - b1;
} else {
long long aaa = a0, bbb = -a1, ccc = b0 - b1;
long long gay = -(cewe.a * bbb - cewe.b * aaa);
long long x = cewe.c * bbb - cewe.b * ccc;
long long y = cewe.a * ccc - cewe.c * aaa;
if (!gay) {
if (x || y) {
printf("-1\n");
return 0;
}
} else {
if (x % gay || y % gay) {
printf("-1\n");
return 0;
} else {
if (x / gay < 0 || y / gay < 0) {
printf("-1\n");
return 0;
}
if (res != -1 && x / gay != res) {
printf("-1\n");
return 0;
}
res = x / gay;
}
}
}
test = true;
}
}
}
if (test) {
p[cpp] = cewe;
cpp++;
}
}
for (int i = 0; i < cpp; i++) {
if (!p[i].b) {
if (p[i].c % p[i].a) {
printf("-1\n");
return 0;
}
if (p[i].c * p[i].a > 0) {
printf("-1\n");
return 0;
}
if (res != -1 && (-p[i].c) / p[i].a != res) {
printf("-1\n");
return 0;
}
res = (-p[i].c) / p[i].a;
}
}
if (res != -1) {
for (int i = 0; i < cpp; i++) {
p[i].c += p[i].a * res;
if (p[i].b) {
if (p[i].c % p[i].b) {
printf("-1\n");
return 0;
}
if (p[i].c * p[i].b > 0) {
printf("-1\n");
return 0;
}
} else if (p[i].c) {
printf("-1\n");
return 0;
}
}
} else {
long long m = 0, mmin = 0, mmax = 9223372036854775807;
for (int i = 0; i < cpp; i++) {
if (!p[i].a) {
if (!p[i].c % p[i].b) {
printf("-1\n");
return 0;
}
if (!p[i].c * p[i].b > 0) {
printf("-1\n");
return 0;
}
} else {
long long x, y;
long long d = dio(p[i].a, p[i].b, x, y);
if (p[i].c % d) {
printf("-1\n");
return 0;
}
x *= (-p[i].c) / d;
momod[m] = abs(p[i].b / d);
valen[m] = x % momod[m];
m++;
if (p[i].b < 0)
mmin = max(mmin, cc(-p[i].c, p[i].a));
else
mmax = min(mmax, floor(-p[i].c, p[i].a));
}
}
if (mmin > mmax) {
printf("-1\n");
return 0;
}
long long A = 0, B = 1;
for (int i = 0; i < m; i++) {
long long x, y;
long long d = dio(B, momod[i], x, y);
long long ans = A % d;
if ((valen[i] - ans) % d) {
printf("-1\n");
return 0;
}
B /= d;
momod[i] /= d;
(A -= ans) /= d;
(valen[i] -= ans) /= d;
long long bbb = B * momod[i];
A = (A + B) % B;
valen[i] = (valen[i] + momod[i]) % momod[i];
A = (asdf(asdf(x, B, bbb), valen[i], bbb) +
asdf(asdf(y, momod[i], bbb), A, bbb)) %
bbb;
B = bbb * d;
A = (A * d + ans) % B;
}
(A += B) %= B;
res = cc(mmin - A, B) * B + A;
if (res > mmax) {
printf("-1\n");
return 0;
}
}
printf("%I64d\n", power(a[n - 1], res, mod) * b[n - 1] % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int maxm = 50005;
const int mod = 1e9 + 7;
int n, cnt;
long long anst, ansd;
int a[maxn], b[maxn], cur_a[maxn][maxm], cur_b[maxn][maxm], pri[maxm];
bool no[maxm];
vector<int> all;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b)
x = 1, y = 0;
else
exgcd(b, a % b, y, x), y -= (a / b) * x;
}
void upd(long long &b, long long &a, long long d, long long c) {
if (!c) {
if (a && d >= b && (d - b) % a == 0)
b = d, a = 0;
else if (!a && d == b)
b = d, a = 0;
else {
puts("-1");
exit(0);
}
return;
}
long long g = gcd(a, c);
if ((d - b) % g) {
puts("-1");
exit(0);
}
long long tmp_x, tmp_y;
exgcd(a, c, tmp_x, tmp_y);
tmp_x *= (d - b) / g;
tmp_y *= (b - d) / g;
if (tmp_x < 0 || tmp_y < 0) {
long long cnt =
max((-tmp_x + (c / g) - 1) / (c / g), (-tmp_y + (a / g) - 1) / (a / g));
tmp_x += cnt * (c / g);
tmp_y += cnt * (a / g);
}
long long cnt = min(tmp_x / (c / g), tmp_y / (a / g));
tmp_x -= cnt * (c / g);
tmp_y -= cnt * (a / g);
a = (a * c) / g;
b = tmp_y * c + d;
}
int power(int x, int pow) {
int res = 1;
for (; pow; pow >>= 1) {
if (pow & 1) res = 1LL * res * x % mod;
x = 1LL * x * x % mod;
}
return res;
}
void check(int i, long long t, long long d) {
int pos = -1;
for (int k = 0; k < (int(all.size())); k++) {
if (!cur_b[1][k] && cur_a[i][k] + t * cur_b[i][k] != cur_a[1][k]) {
puts("-1");
exit(0);
} else if (cur_b[1][k]) {
if (cur_a[i][k] + t * cur_b[i][k] < cur_a[1][k] ||
((cur_a[i][k] + t * cur_b[i][k] - cur_a[1][k]) % cur_b[1][k])) {
puts("-1");
exit(0);
}
long long cur =
(cur_a[i][k] + t * cur_b[i][k] - cur_a[1][k]) / cur_b[1][k];
if (pos >= 0 && cur != pos) {
puts("-1");
exit(0);
}
pos = cur;
}
}
upd(anst, ansd, pos, d);
}
int main() {
anst = 0;
ansd = 1;
no[1] = true;
for (int i = 2; i <= 50000; i++) {
if (!no[i]) pri[++cnt] = i;
for (int j = 1; j <= (cnt); j++) {
if (i * pri[j] > 50000) break;
no[i * pri[j]] = true;
if (i % pri[j] == 0) break;
}
}
scanf("%d", &n);
for (int i = 1; i <= (n); i++) {
scanf("%d%d", &a[i], &b[i]);
int tmp_a = a[i], tmp_b = b[i];
for (int j = 1; j <= (cnt); j++) {
if (pri[j] * pri[j] > tmp_a) break;
if (tmp_a % pri[j] == 0) all.push_back(pri[j]);
while (tmp_a % pri[j] == 0) tmp_a /= pri[j];
}
if (tmp_a > 1) all.push_back(tmp_a);
for (int j = 1; j <= (cnt); j++) {
if (pri[j] * pri[j] > tmp_b) break;
if (tmp_b % pri[j] == 0) all.push_back(pri[j]);
while (tmp_b % pri[j] == 0) tmp_b /= pri[j];
}
if (tmp_b > 1) all.push_back(tmp_b);
}
sort(all.begin(), all.end());
all.resize(unique(all.begin(), all.end()) - all.begin());
for (int i = 1; i <= (n); i++) {
for (int j = 0; j < (int(all.size())); j++) {
int p = all[j];
int tmp_a = a[i], tmp_b = b[i];
while (tmp_a % p == 0) cur_a[i][j]++, tmp_a /= p;
while (tmp_b % p == 0) cur_b[i][j]++, tmp_b /= p;
}
}
for (int i = 2; i <= n; i++) {
int j = 0;
while (j < int(all.size()) && !cur_b[i][j]) j++;
if (j == int(all.size()) || !cur_b[1][j])
check(i, 0, 0);
else {
int k = 0;
while (k < int(all.size()) &&
cur_b[1][k] * cur_b[i][j] == cur_b[i][k] * cur_b[1][j])
k++;
if (k == int(all.size())) {
long long g = gcd(cur_b[1][j], cur_b[i][j]);
if ((cur_a[1][j] - cur_a[i][j]) % g) {
puts("-1");
return 0;
}
long long tmp_x, tmp_y;
exgcd(cur_b[1][j], cur_b[i][j], tmp_x, tmp_y);
tmp_x *= (cur_a[i][j] - cur_a[1][j]) / g;
tmp_y *= (cur_a[1][j] - cur_a[i][j]) / g;
if (tmp_x < 0 || tmp_y < 0) {
long long cnt =
max((-tmp_x + (cur_b[i][j] / g) - 1) / (cur_b[i][j] / g),
(-tmp_y + (cur_b[1][j] / g) - 1) / (cur_b[1][j] / g));
tmp_x += cnt * (cur_b[i][j] / g);
tmp_y += cnt * (cur_b[1][j] / g);
}
long long cnt =
min(tmp_x / (cur_b[i][j] / g), tmp_y / (cur_b[1][j] / g));
tmp_x -= cnt * (cur_b[i][j] / g);
tmp_y -= cnt * (cur_b[1][j] / g);
check(i, tmp_y, cur_b[i][j] / g);
} else {
long long tmp_x1 =
1LL * cur_a[i][j] * cur_b[i][k] - 1LL * cur_a[1][j] * cur_b[i][k];
long long tmp_x2 =
1LL * cur_a[i][k] * cur_b[i][j] - 1LL * cur_a[1][k] * cur_b[i][j];
if ((tmp_x1 - tmp_x2) % (1LL * cur_b[1][j] * cur_b[i][k] -
1LL * cur_b[1][k] * cur_b[i][j])) {
puts("-1");
return 0;
}
long long tmp_x = (tmp_x1 - tmp_x2) / (1LL * cur_b[1][j] * cur_b[i][k] -
1LL * cur_b[1][k] * cur_b[i][j]);
long long tmp_y = tmp_x * cur_b[1][j] + cur_a[1][j] - cur_a[i][j];
if (tmp_y % cur_b[i][j]) {
puts("-1");
return 0;
}
tmp_y /= cur_b[i][j];
if (tmp_x < 0 || tmp_y < 0) {
puts("-1");
return 0;
}
check(i, tmp_y, 0);
}
}
}
printf("%d\n", 1LL * a[1] * power(b[1], int(anst % (mod - 1))) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
int mo = 1000000007;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
struct fen {
pair<int, int> p[66];
int tot;
void zuo(int a) {
tot = 0;
for (int i = 2; i * i <= a; i++)
if (a % i == 0) {
p[++tot] = make_pair(i, 0);
while (a % i == 0) {
p[tot].second++;
a /= i;
}
}
if (a > 1) {
p[++tot] = make_pair(a, 1);
}
}
void add(int x) {
for (int i = (1), _ed = (tot + 1); i < _ed; i++)
if (p[i].first == x) return;
p[++tot] = make_pair(x, 0);
sort(p + 1, p + 1 + tot);
}
};
bool pok(const fen &a, const fen &b) {
if (a.tot != b.tot) return 0;
for (int i = (1), _ed = (a.tot + 1); i < _ed; i++)
if (a.p[i].first != b.p[i].first) return 0;
return 1;
}
struct node {
int a, b;
bool in(int x) {
if (b == 1) {
return a == x;
}
long long u = a;
while (u <= x) {
if (u == x) return 1;
u *= b;
}
return 0;
}
fen pa, push_back;
void chuli() {
for (int i = (1), _ed = (push_back.tot + 1); i < _ed; i++)
pa.add(push_back.p[i].first);
for (int i = (1), _ed = (pa.tot + 1); i < _ed; i++)
push_back.add(pa.p[i].first);
}
} p[111];
int n;
int k;
struct ne {
long long a[33], d[33];
} a[111];
ne jiao(ne u, ne v, int &ver) {
ver = 1;
long long a = 0, b = 0, c = 0;
int bo = 0;
for (int i = (1), _ed = (k + 1); i < _ed; i++) {
long long C = v.a[i] - u.a[i];
long long A = u.d[i], B = -v.d[i];
if (A == 0 && B == 0) {
if (C != 0) {
ver = 0;
return u;
} else {
continue;
}
}
long long D = gcd(A, B);
if (C % D != 0) {
ver = 0;
return u;
}
A /= D, B /= D, C /= D;
if (A < 0) {
A *= -1, B *= -1, C *= -1;
}
if (A == 0 && B > 0) {
B *= -1, C *= -1;
}
if (!bo) {
a = A, b = B;
c = C;
bo = 1;
} else {
if (a == A && b == B) {
if (c != C) {
ver = 0;
return u;
} else {
continue;
}
} else {
long long det = a * B - b * A;
long long dx = c * B - b * C, dy = a * C - c * A;
if (dx % det != 0 || dy % det != 0) {
ver = 0;
return u;
}
long long x = dx / det, y = dy / det;
for (int j = (1), _ed = (k + 1); j < _ed; j++) {
if (u.a[j] + x * u.d[j] != v.a[j] + y * v.d[j]) {
ver = 0;
return u;
}
}
ne ans;
for (int j = (1), _ed = (k + 1); j < _ed; j++)
ans.a[j] = u.a[j] + x * u.d[j], ans.d[j] = 0;
return ans;
}
}
}
if (bo == 0) return u;
if (a == 0) {
long long y = c / b;
if (y < 0) {
ver = 0;
return u;
}
ne ans;
for (int j = (1), _ed = (k + 1); j < _ed; j++)
ans.a[j] = v.a[j] + y * v.d[j], ans.d[j] = 0;
return ans;
}
if (b == 0) {
long long x = c / a;
if (x < 0) {
ver = 0;
return u;
}
ne ans;
for (int j = (1), _ed = (k + 1); j < _ed; j++)
ans.a[j] = u.a[j] + x * u.d[j], ans.d[j] = 0;
return ans;
}
long long x, y;
for (x = 0;; x++) {
if ((c - a * x) % b == 0) {
y = (c - a * x) / b;
break;
}
}
if (y < 0) {
long long ned = cei(-y, a);
y += ned * a;
x -= ned * b;
}
ne ans;
for (int j = (1), _ed = (k + 1); j < _ed; j++)
ans.a[j] = u.a[j] + x * u.d[j], ans.d[j] = -b * u.d[j];
return ans;
}
int main() {
gn(n);
for (int i = (1), _ed = (n + 1); i < _ed; i++) gn(p[i].a), gn(p[i].b);
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (p[i].b == 1) {
int bo = 1;
for (int j = (1), _ed = (n + 1); j < _ed; j++) bo &= p[j].in(p[i].a);
if (bo)
printf("%d\n", p[i].a);
else
printf("-1\n");
return 0;
}
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
int bo = 1;
for (int j = (1), _ed = (n + 1); j < _ed; j++) bo &= p[j].in(p[i].a);
if (bo) {
printf("%d\n", p[i].a);
return 0;
}
}
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
p[i].pa.zuo(p[i].a);
p[i].push_back.zuo(p[i].b);
p[i].chuli();
}
int bo = 1;
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
if (!pok(p[i].pa, p[1].pa)) bo = 0;
}
if (!bo) {
printf("-1\n");
return 0;
}
::k = p[1].pa.tot;
for (int i = (1), _ed = (n + 1); i < _ed; i++) {
for (int j = (1), _ed = (k + 1); j < _ed; j++) {
a[i].a[j] = p[i].pa.p[j].second;
a[i].d[j] = p[i].push_back.p[j].second;
}
}
ne cur = a[1];
for (int i = (2), _ed = (n + 1); i < _ed; i++) {
int ver;
ne ne = jiao(cur, a[i], ver);
if (ver == 0) {
printf("-1\n");
return 0;
}
cur = ne;
}
int ans = 1;
for (int i = (1), _ed = (k + 1); i < _ed; i++)
ans = 1ll * ans * qp(p[1].pa.p[i].first, cur.a[i]) % mo;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n;
set<int> all;
struct d {
map<int, int> v;
int &operator[](int x) { return v[x]; }
void init(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int cnt = 0;
while (x % i == 0) cnt++, x /= i;
v[i] = cnt;
all.insert(i);
}
if (x > 1) {
v[x] = 1;
all.insert(x);
}
}
bool operator!=(d b) {
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (v[*it] != b[*it]) return 1;
return 0;
}
};
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
int trs(d &a) {
int g = 0;
for (map<int, int>::iterator it = a.v.begin(); it != a.v.end(); it++)
g = gcd(g, it->second);
if (g)
for (map<int, int>::iterator it = a.v.begin(); it != a.v.end(); it++)
it->second /= g;
return g;
}
d a[105], b[105];
inline int power(int x, long long y) {
int z = 1;
while (y) {
if (y & 1) z = 1ll * z * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return z;
}
namespace unsame {
void chk(d a0, d a1, d b0, d b1) {
int aa, bb, cc;
bool ok = 0;
int x, y;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
int ta = b0[*it];
int tb = -b1[*it];
int tc = a0[*it] - a1[*it];
if (ta || tb || tc) {
if (!ta || !tb) {
if (!ta && !tb) {
puts("-1");
return;
}
if (!ta) {
x = -tc / tb;
if (x < 0 || tc % tb) {
puts("-1");
return;
}
swap(a0, b0);
} else {
x = -tc / ta;
if (x < 0 || tc % ta) {
puts("-1");
return;
}
}
break;
}
int g = gcd(gcd(ta, tb), tc);
ta /= g;
tb /= g;
tc /= g;
if (ok && (ta != aa || tb != bb || tc != cc)) {
int t = ta * bb - tb * aa;
if (!t) {
puts("-1");
return;
}
int w = aa * tc - ta * cc;
y = w / t;
if (y < 0 || y * t != w) {
puts("-1");
return;
}
w = tb * cc - bb * tc;
x = w / t;
if (x < 0 || x * t != w) {
puts("-1");
return;
}
break;
} else {
aa = ta;
bb = tb;
cc = tc;
ok = 1;
}
}
}
d r;
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
r[*it] = a0[*it] + x * b0[*it];
for (int i = 1; i <= n; i++) {
int p = -1;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
if (b[i][*it]) {
int t = (r[*it] - a[i][*it]) / b[i][*it];
if (t * b[i][*it] + a[i][*it] != r[*it]) {
puts("-1");
return;
}
if (p == -1) p = t;
if (t != p) {
puts("-1");
return;
}
} else {
if (r[*it] != a[i][*it]) {
puts("-1");
return;
}
}
}
}
int res = 1;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
res = 1ll * res * power(*it, r[*it]) % mod;
}
printf("%d\n", res);
}
} // namespace unsame
namespace same {
int k[105], c[105];
int T(d &a, d &b) {
int mn = 1e9;
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (b[*it]) {
mn = min(mn, a[*it] / b[*it]);
}
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (b[*it]) {
a[*it] -= mn * b[*it];
}
return mn;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b)
return x = 1, y = 0, a;
else {
long long d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
}
inline long long mul(long long x, long long y, long long mod) {
long long z = 0;
while (y) {
if (y & 1) z = (z + x) % mod;
x = (x + x) % mod;
y >>= 1;
}
return z;
}
void work() {
for (int i = 1; i <= n; i++) c[i] = T(a[i], b[i]);
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) {
puts("-1");
exit(0);
}
long long tk = k[1], tc = c[1];
if (tk) {
for (int i = 2; i <= n; i++) {
long long C = k[i], D = c[i], v = ((tc - c[i]) % tk + tk) % tk, x, y, dd,
aa = tk, t2;
dd = exgcd(tk, C, x, y);
if (v % dd) {
puts("-1");
return;
}
v /= dd;
aa /= dd;
t2 = (mul(y, v, aa) + aa) % aa;
if (C * t2 + D < tc) t2 += (tc - D - C * t2 + C * aa - 1) / (C * aa) * aa;
tc = t2 * C + D;
tk = tk / dd * C;
}
}
int res = 1;
for (map<int, int>::iterator it = a[1].v.begin(); it != a[1].v.end(); it++)
if (it->second) {
res = 1ll * res * power(it->first, it->second) % mod;
}
for (map<int, int>::iterator it = b[1].v.begin(); it != b[1].v.end(); it++)
if (it->second) {
res = 1ll * res * power(it->first, it->second * tc) % mod;
}
printf("%d\n", res);
}
} // namespace same
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i].init(x);
b[i].init(y);
}
for (int i = 1; i <= n; i++) same::k[i] = trs(b[i]);
for (int i = 2; i <= n; i++) {
if (b[1] != b[i]) {
for (int i = 1; i <= n; i++)
for (map<int, int>::iterator it = b[i].v.begin(); it != b[i].v.end();
it++)
it->second *= same::k[i];
unsame::chk(a[1], a[i], b[1], b[i]);
return 0;
}
}
same::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1e9 + 7;
long long add(long long a, const long long b) {
a += b;
if (a >= Mod) a -= Mod;
return a;
}
long long mul(const long long a, const long long b) {
return (long long)a * b % Mod;
}
long long power(long long x, long long cs) {
long long ras = 1;
while (cs) {
if (cs & 1ll) ras = mul(ras, x);
x = mul(x, x);
cs >>= 1;
}
return ras;
}
const long long N = 110, M = 3050;
long long n, m = 0;
long long A[N], B[N], pl[M];
void insert(long long n) {
long long i;
for (i = 2; i * i <= n; i++) {
if (n % i != 0) continue;
pl[++m] = i;
while (n % i == 0) n /= i;
}
if (n > 1) pl[++m] = n;
}
struct Comb {
long long a[M], b[M];
Comb() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
} h[N];
Comb build(long long A, long long B) {
long long i;
Comb f;
for (i = 1; i <= m; i++) {
while (A % pl[i] == 0) f.a[i]++, A /= pl[i];
while (B % pl[i] == 0) f.b[i]++, B /= pl[i];
}
return f;
}
long long bx, by;
long long exgcd(long long a, long long b) {
if (b == 0) {
bx = 1;
by = 0;
return a;
}
long long nx, ny, tmp;
tmp = exgcd(b, a % b);
nx = by;
ny = bx - (a / b) * by;
bx = nx;
by = ny;
return tmp;
}
long long smul(long long a, long long b, long long Mod) {
return ((a * b - ((long long)((long double)a * b / Mod) * Mod)) % Mod + Mod) %
Mod;
}
Comb merge(Comb h1, Comb h2) {
long long i, j, k, cs, x, y, d, der, pd1, pd2, w, now, pd;
static long long a[M][4];
Comb f;
memset(a, 0, sizeof(a));
pd1 = pd2 = 0;
for (i = 1; i <= m; i++) {
a[i][1] = h1.b[i];
a[i][2] = -h2.b[i];
a[i][3] = h2.a[i] - h1.a[i];
if (a[i][1]) pd1 = 1;
if (a[i][2]) pd2 = 1;
}
if (pd1 == 0 && pd2 == 0) {
for (i = 1; i <= m; i++) {
if (a[i][3]) {
puts("-1");
exit(0);
}
}
for (i = 1; i <= m; i++) f.a[i] = h1.a[i], f.b[i] = 0;
return f;
}
if (pd1 == 0 || pd2 == 0) {
pd = 0;
for (i = 1; i <= m; i++) {
if (a[i][1] + a[i][2]) {
if (a[i][3] % (a[i][1] + a[i][2]) != 0) {
puts("-1");
exit(0);
}
now = a[i][3] / (a[i][1] + a[i][2]);
if (pd == 0)
w = now, pd = 1;
else if (now != w) {
puts("-1");
exit(0);
}
}
}
for (i = 1; i <= m; i++) f.a[i] = (pd2 ? h1.a[i] : h2.a[i]), f.b[i] = 0;
return f;
}
for (i = 1; i <= 2; i++) {
for (j = i + 1; j <= m; j++) {
if (a[j][i]) {
for (k = i; k <= 3; k++) swap(a[i][k], a[j][k]);
}
}
if (a[i][i] == 0) continue;
for (j = i + 1; j <= m; j++) {
if (i == j) continue;
while (a[i][i] && a[j][i]) {
cs = a[j][i] / a[i][i];
for (k = i; k <= 3; k++) a[j][k] -= cs * a[i][k];
for (k = i; k <= 3; k++) swap(a[i][k], a[j][k]);
}
if (a[i][i] == 0)
for (k = i; k <= 3; k++) swap(a[i][k], a[j][k]);
}
}
for (i = 1; i <= m; i++) {
if (a[i][1] == 0 && a[i][2] == 0 && a[i][3] > 0) {
puts("-1");
exit(0);
}
}
if (a[2][2] == 0) {
d = exgcd(a[1][1], a[1][2]);
if (a[1][3] % d != 0) {
puts("-1");
exit(0);
}
der = abs(a[1][2] / d);
bx = smul(bx % der, (a[1][3] / d) % der, der);
der = abs(a[1][1] / d);
by = smul(by % der, (a[1][3] / d) % der, der);
bx = max(bx, (a[1][3] - a[1][2] * by) / a[1][1]);
for (i = 1; i <= m; i++)
f.a[i] = h1.a[i] + bx * h1.b[i], f.b[i] = abs(a[1][1] / d * a[1][2]);
return f;
} else {
if (a[1][3] % a[1][1] != 0 || a[2][3] % a[2][2] != 0) {
puts("-1");
exit(0);
} else {
y = a[2][3] / a[2][2];
x = (a[1][3] - y * a[1][2]) / a[1][1];
if (x < 0 || y < 0) {
puts("-1");
exit(0);
}
for (i = 1; i <= m; i++) f.a[i] = h1.a[i] + x * h1.b[i], f.b[i] = 0;
return f;
}
}
}
long long qry(Comb a) {
long long ans = 1, i;
for (i = 1; i <= m; i++) {
ans = mul(ans, power(pl[i], a.a[i]));
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long i, j;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> A[i] >> B[i];
insert(A[i]);
insert(B[i]);
}
sort(pl + 1, pl + m + 1);
m = unique(pl + 1, pl + m + 1) - pl - 1;
for (i = 1; i <= n; i++) h[i] = build(A[i], B[i]);
for (i = n - 1; i >= 1; i--) {
h[i] = merge(h[i], h[i + 1]);
for (j = 1; j <= m; j++) {
if (h[i].a[j] < 0) {
puts("-1");
exit(0);
}
}
}
cout << qry(h[1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[110], b[110], c[110], d[110];
vector<int> stdprimes;
vector<int> sepra(int x) {
vector<int> res = vector<int>();
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
res.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x != 1) res.push_back(x);
return res;
}
struct record {
vector<int> stdpows;
vector<int> extrapr;
vector<int> extrapo;
record() {
stdpows.clear();
extrapr.clear();
extrapo.clear();
}
record(int x) {
for (int i = 0; i < stdprimes.size(); i++) {
stdpows.push_back(0);
while (x % stdprimes[i] == 0) {
x /= stdprimes[i];
stdpows.back()++;
}
}
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
extrapr.push_back(i);
extrapo.push_back(0);
while (x % i == 0) {
x /= i;
extrapo.back()++;
}
}
}
if (x != 1) {
extrapr.push_back(x);
extrapo.push_back(1);
}
}
};
inline long long quickpow(long long base, long long ind) {
long long ans = 1;
while (ind > 0) {
if (ind & 1) ans = ans * base % 1000000007;
ind >>= 1;
base = base * base % 1000000007;
}
return ans;
}
inline void mul(long long &a, long long b) { a = a * b % 1000000007; }
inline long long extgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = extgcd(b, a % b, y, x);
y = y - a / b * x;
return g;
}
void combine(long long &a1, long long &m1, int a2, int m2) {
long long c = a2 - a1;
long long a = m1, b = m2;
long long x, y, g;
g = extgcd(a, b, x, y);
if (c % g != 0) {
cout << -1;
exit(0);
}
long long b1 = b / g;
long long x1 = ((x + b1) * c / g);
x1 = (x1 % b1 + b1) % b1;
long long y1 = ((c - a * x1) / b);
a1 = a1 + m1 * x1;
m1 = m1 * m2 / g;
}
void trysingle(int id, int pos) {
stdprimes.clear();
record fst(a[id]);
stdprimes = fst.extrapr;
record ratio(b[id]);
for (int i = 0; i < ratio.extrapr.size(); i++)
stdprimes.push_back(ratio.extrapr[i]);
fst = record(a[id]);
ratio = record(b[id]);
vector<int> cnt;
for (int i = 0; i < fst.stdpows.size(); i++) {
cnt.push_back(fst.stdpows[i]);
cnt.back() += ratio.stdpows[i] * pos;
}
for (int i = 0; i < n; i++) {
record curfst(a[i]);
record currat(b[i]);
if (!curfst.extrapr.empty()) {
cout << -1;
exit(0);
}
int curneed = -1;
for (int j = 0; j < stdprimes.size(); j++) {
if (curfst.stdpows[j] > cnt[j]) {
cout << -1;
exit(0);
}
int need = cnt[j] - curfst.stdpows[j];
if (!currat.stdpows[j]) {
if (need) {
cout << -1;
exit(0);
}
continue;
} else if (need % currat.stdpows[j] != 0) {
cout << -1;
exit(0);
}
need /= currat.stdpows[j];
if (curneed == -1)
curneed = need;
else if (curneed != need) {
cout << -1;
exit(0);
}
}
if (curneed > 0 && !currat.extrapr.empty()) {
cout << -1;
exit(0);
}
}
long long ans = a[id];
mul(ans, quickpow(b[id], pos));
cout << ans;
exit(0);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
for (int i = 0; i < n; i++)
if (b[i] == 1) trysingle(i, 0);
if (n == 1) {
cout << a[0];
return 0;
}
stdprimes = sepra(b[0]);
record fst(a[0]);
record ratio(b[0]);
c[0] = fst.stdpows[0];
d[0] = ratio.stdpows[0];
for (int i = 1; i < n; i++) {
record curfst(a[i]);
record currat(b[i]);
if (!currat.extrapr.empty()) {
int needPow = 0, p = currat.extrapr[0], pw = currat.extrapo[0];
for (int j = 0; j < fst.extrapr.size(); j++) {
if (fst.extrapr[j] == p) {
needPow += fst.extrapo[j];
break;
}
}
for (int j = 0; j < curfst.extrapr.size(); j++) {
if (curfst.extrapr[j] == p) {
needPow -= curfst.extrapo[j];
break;
}
}
if (needPow < 0 || needPow % pw != 0) {
cout << -1;
return 0;
}
trysingle(i, needPow / pw);
}
c[i] = curfst.stdpows[0];
d[i] = currat.stdpows[0];
int fstpos = 0, errpos = -1;
while (fstpos < stdprimes.size() && currat.stdpows[fstpos] == 0) fstpos++;
int pow0 = ratio.stdpows[fstpos];
int powi = currat.stdpows[fstpos];
for (int j = 0; j < stdprimes.size(); j++) {
if (ratio.stdpows[j] * powi != currat.stdpows[j] * pow0) {
errpos = j;
break;
}
}
if (~errpos) {
int s1 = fst.stdpows[fstpos], s2 = fst.stdpows[errpos];
int t1 = curfst.stdpows[fstpos], t2 = curfst.stdpows[errpos];
int u1 = ratio.stdpows[fstpos], u2 = ratio.stdpows[errpos];
int v1 = currat.stdpows[fstpos], v2 = currat.stdpows[errpos];
int mulx = u1 * v2 - u2 * v1;
int eqa = t1 * v2 - t2 * v1 - s1 * v2 + s2 * v1;
if (mulx == 0 || (abs(eqa) % abs(mulx) != 0) || eqa / mulx < 0) {
cout << -1;
return 0;
}
trysingle(0, eqa / mulx);
}
if (fst.extrapr.size() != curfst.extrapr.size()) {
cout << -1;
return 0;
}
for (int j = 0; j < fst.extrapr.size(); j++)
if (fst.extrapr[j] != curfst.extrapr[j] ||
fst.extrapo[j] != curfst.extrapo[j]) {
cout << -1;
return 0;
}
int dif = curfst.stdpows[0] - fst.stdpows[0];
for (int j = 1; j < stdprimes.size(); j++) {
int curdif = curfst.stdpows[j] - fst.stdpows[j];
if (dif * ratio.stdpows[j] != curdif * ratio.stdpows[0]) {
cout << -1;
return 0;
}
}
}
long long ansC = c[0], ansD = d[0];
for (int i = 1; i < n; i++) {
combine(ansC, ansD, c[i], d[i]);
}
for (int i = 0; i < n; i++) {
if (ansC < c[i]) {
(ansC += ((c[i] - ansC + ansD - 1) / ansD) * ansD);
}
}
long long ans = a[0];
ansC /= ratio.stdpows[0];
mul(ans, quickpow(b[0], ansC));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void GG() { cout << -1 << endl, exit(0); }
const int N = 110, P = 1000000007;
long long mul(long long x, long long y) { return 1ll * x * y % P; }
void upd(long long &x, long long y) { x = mul(x, y); }
long long Pow(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1) upd(ret, x);
upd(x, x), y >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
struct Num {
vector<pair<int, long long>> p;
inline void read() {
int x;
cin >> x;
for (int i = 2; i * i <= x; i++)
if (!(x % i)) {
p.push_back(make_pair(i, 0ll));
while (!(x % i)) ++p.back().second, x /= i;
}
if (x != 1) p.push_back(make_pair(x, 1ll));
}
inline void out() {
long long ans = 1;
for (auto o : p)
if (o.second < 0) GG();
for (auto o : p) upd(ans, Pow(o.first, o.second));
cout << ans << endl;
}
inline friend bool operator==(Num x, Num y) {
if (x.p.size() != y.p.size()) return false;
for (int i = 0; i < x.p.size(); i++)
if (x.p[i].first != y.p[i].first || x.p[i].second != y.p[i].second)
return false;
return true;
}
inline friend Num operator*(Num x, Num y) {
Num z;
int i = 0, j = 0;
while (i < x.p.size() && j < y.p.size())
if (x.p[i].first == y.p[j].first)
z.p.push_back(make_pair(x.p[i].first, x.p[i].second + y.p[j].second)),
++i, ++j;
else if (x.p[i].first < y.p[j].first)
z.p.push_back(x.p[i++]);
else
z.p.push_back(y.p[j++]);
while (i < x.p.size()) z.p.push_back(x.p[i++]);
while (j < y.p.size()) z.p.push_back(y.p[j++]);
return z;
}
inline friend bool operator%(Num x, Num y) {
for (int i = 0, j = 0; j < y.p.size(); i++, j++) {
while (i < x.p.size() && x.p[i].first != y.p[j].first) ++i;
if (i == x.p.size() || x.p[i].second < y.p[j].second) return 1;
}
return 0;
}
inline friend Num operator/(Num x, Num y) {
Num z;
for (int i = 0, j = 0; i < x.p.size(); i++)
if (j < y.p.size() && x.p[i].first == y.p[j].first) {
z.p.push_back(make_pair(x.p[i].first, x.p[i].second - y.p[j++].second));
if (!z.p.back().second) z.p.pop_back();
} else
z.p.push_back(x.p[i]);
return z;
}
inline friend Num operator&(Num x, Num y) {
Num z;
for (int i = 0, j = 0; i < x.p.size(); i++)
if (j < y.p.size() && x.p[i].first == y.p[j].first)
z.p.push_back(make_pair(x.p[i].first, x.p[i].second - y.p[j++].second));
else
z.p.push_back(x.p[i]);
return z;
}
inline friend bool operator|(Num x, Num y) {
if (!x.p.size()) return 0;
long long k;
for (int i = 0, j = 0; i <= x.p.size(); i++, j++) {
while (j < y.p.size() && !y.p[j].second) ++j;
if (i == x.p.size()) {
if (j == y.p.size()) return 0;
return 1;
}
if (j == y.p.size()) return 1;
if (x.p[i].first != y.p[j].first || x.p[i].second % y.p[j].second)
return 1;
if (!i)
k = x.p[i].second / y.p[j].second;
else if ((x.p[i].second / y.p[j].second) != k)
return 1;
}
return 0;
}
inline friend Num operator^(Num x, long long y) {
for (auto &o : x.p) o.second *= y;
return x;
}
inline friend Num operator+(Num x, Num y) {
Num z;
for (int i = 0; i < x.p.size(); i++)
z.p.push_back(make_pair(
x.p[i].first,
x.p[i].second * y.p[i].second / gcd(x.p[i].second, y.p[i].second)));
return z;
}
} a[N], b[N], c[N], A, B;
int n;
bool check(Num x) {
for (int i = 1; i <= n; i++)
if ((x % a[i]) || ((x / a[i]) | b[i])) return false;
return true;
}
struct Pro {
long long k, b, p;
inline Pro(long long k = 0, long long b = 0, long long p = 0)
: k(k), b(b), p(p) {}
bool operator==(const Pro t) const {
return k == t.k && b == t.b && p == t.p;
}
};
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) return x = 1, y = 0, void();
exgcd(b, a % b, y, x);
return y -= a / b * x, void();
}
long long solve(Pro x, Pro y) {
long long a = x.b * y.p - y.b * x.p, b = x.k * y.p - y.k * x.p;
if (!b || a % b) GG();
return a / b;
}
bool merge(int o) {
vector<Pro> pro;
for (int i = 0; i < A.p.size(); i++) {
long long k1 = B.p[i].second, b1 = A.p[i].second;
long long k2 = b[o].p[i].second, b2 = a[o].p[i].second;
if (!k1 && !k2) {
if (b1 ^ b2) GG();
continue;
}
if (!k1) {
if (b1 < b2 || (b1 - b2) % k2) GG();
return A = a[o] * (b[o] ^ ((b1 - b2) / k2)), 0;
}
if (!k2) {
if (b2 < b1 || (b2 - b1) % k1) GG();
return A = A * (B ^ ((b2 - b1) / k1)), 0;
}
long long d = gcd(k1, k2), g = b2 - b1;
if (g % d) GG();
g /= d, k1 /= d, k2 /= d;
if (pro.size()) {
if (pro[0] == Pro(k1, g, k2)) continue;
return A = A * (B ^ solve(pro[0], Pro(k1, g, k2))), 0;
}
pro.push_back(Pro(k1, g, k2));
}
if (pro.size()) {
long long k1 = pro[0].k, p1 = pro[0].p, b1 = pro[0].b, x, y;
exgcd(k1, p1, x, y);
b1 = (b1 % p1 + p1) % p1;
x = (x % p1 * b1 % p1 + p1) % p1;
A = A * (B ^ x), B = B + b[o];
}
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) a[i].read(), b[i].read(), c[i] = a[i] * b[i];
int flag = 1;
for (int i = 2; i <= n; i++)
if (!(a[i] == a[1])) {
flag = false;
break;
}
if (flag == 1) return a[1].out(), 0;
for (int i = 1; i <= n; i++)
if (check(a[i])) return a[i].out(), 0;
for (int i = 1; i <= n; i++) {
if (c[i].p.size() != c[1].p.size()) GG();
for (int j = 0; j < c[1].p.size(); j++)
if (c[i].p[j].first ^ c[1].p[j].first) GG();
a[i] = c[i] & b[i], b[i] = c[i] & a[i];
}
A = a[1], B = b[1];
for (int i = 2; i <= n; i++) {
if (!merge(i)) {
if (check(A)) return A.out(), 0;
GG();
}
}
return A.out(), 0;
return 0;
}
|
#include <bits/stdc++.h>
const int Maxn = 100;
const int Mod = 1000000007;
const int Maxm = 6000;
int quick_power(int a, long long b) {
int ans = 1;
while (b) {
if (b & 1) {
ans = 1ll * ans * a % Mod;
}
b >>= 1;
a = 1ll * a * a % Mod;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int n;
int a[Maxn + 5], b[Maxn + 5];
struct Node {
long long k, b;
Node(long long _k = 0, long long _b = 0) {
k = _k;
b = _b;
}
};
int p[Maxm + 5];
int len;
Node f[Maxm + 5], g[Maxm + 5];
void get_p(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
p[++len] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
p[++len] = x;
}
}
struct Function {
long long a, b, c;
Function(long long _a = 0, long long _b = 0, long long _c = 0) {
a = _a;
b = _b;
c = _c;
}
};
bool vis;
int solve(int b, int k) {
for (int i = 1; i <= len; i++) {
g[i] = Node(0, 0);
}
for (int i = 1; i <= len; i++) {
while (k % p[i] == 0) {
k /= p[i];
g[i].k++;
}
while (b % p[i] == 0) {
b /= p[i];
g[i].b++;
}
}
if (!vis) {
for (int i = 1; i <= len; i++) {
f[i] = g[i];
}
vis = 1;
return 1;
}
for (int t = 0; t < 3; t++) {
for (int i = 1; i <= n; i++) {
long long f_b = f[i].b, f_k = f[i].k, g_b = g[i].b, g_k = g[i].k;
if (f_k == 0 && g_k == 0) {
if (f_b != g_b) {
return 0;
}
} else if (f_k == 0 || g_k == 0) {
bool flag = 0;
if (f_k == 0) {
std::swap(f_k, g_k);
std::swap(f_b, g_b);
flag = 1;
}
if (g_b < f_b || (g_b - f_b) % f_k) {
return 0;
}
long long k = (g_b - f_b) / f_k;
if (flag) {
for (int j = 1; j <= len; j++) {
g[j].b += g[j].k * k;
g[j].k = 0;
}
} else {
for (int j = 1; j <= len; j++) {
f[j].b += f[j].k * k;
f[j].k = 0;
}
}
}
}
}
Function F;
int flag = 0;
long long x = -1, y = -1;
for (int i = 1; i <= len; i++) {
long long f_b = f[i].b, f_k = f[i].k, g_b = g[i].b, g_k = g[i].k;
if (f_k && g_k) {
if (!flag) {
F = Function(f_k, -g_k, g_b - f_b);
flag = 1;
} else if (flag == 1) {
long long a = f_k, b = -g_k, c = g_b - f_b;
long long d = gcd(F.a, a);
long long m_1 = a / d, m_2 = F.a / d;
F.a *= m_1, F.b *= m_1, F.c *= m_1;
a *= m_2, b *= m_2, c *= m_2;
if (F.a == a && F.b == b) {
if (F.c != c) {
return 0;
} else {
long long d = gcd(gcd(F.a, std::abs(F.b)), std::abs(F.c));
F.a /= d, F.b /= d, F.c /= d;
continue;
}
} else {
c -= F.c, b -= F.b;
if (c < 0) {
c = -c;
b = -b;
}
if (b < 0 || c % b) {
return 0;
}
y = c / b, x = (F.c - F.b * y) / F.a;
if (x < 0 || (F.c - F.b * y) % F.a) {
return 0;
}
flag = 2;
}
} else if (flag == 2) {
long long a = f_k, b = -g_k, c = g_b - f_b;
if (a * x + b * y != c) {
return 0;
}
}
}
}
if (flag == 2) {
for (int i = 1; i <= n; i++) {
f[i].b += f[i].k * x;
f[i].k = 0;
}
}
if (flag == 1) {
long long x, y;
long long d = exgcd(F.a, -F.b, x, y);
y = -y;
if (F.c % d) {
return 0;
}
long long k_x = -F.b / d, k_y = F.a / d;
x *= F.c / d, y *= F.c / d;
long long t_x = 0, t_y = 0;
if (x < 0) {
t_x = -((-x + k_x - 1) / k_x);
} else {
t_x = x / k_x;
}
if (y < 0) {
t_y = -((-y + k_y - 1) / k_y);
} else {
t_y = y / k_y;
}
x -= k_x * std::min(t_x, t_y);
y -= k_y * std::min(t_x, t_y);
for (int i = 1; i <= n; i++) {
f[i].b += f[i].k * x;
f[i].k *= k_x;
}
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
get_p(a[i]);
get_p(b[i]);
}
std::sort(p + 1, p + 1 + len);
len = std::unique(p + 1, p + 1 + len) - p - 1;
for (int i = 1; i <= n; i++) {
if (!solve(a[i], b[i])) {
puts("-1");
return 0;
}
}
int ans = 1;
for (int i = 1; i <= len; i++) {
ans = 1ll * ans * quick_power(p[i], f[i].b) % Mod;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
template <typename T>
T &Read(T &first) {
static char c;
while (!isdigit(c = getchar()))
;
first = c - '0';
while (isdigit(c = getchar())) (first *= 10) += c - '0';
return first;
}
inline long long mul(long long b, long long e, const long long &m) {
long long t = 0;
for (; e; e >>= 1, (b <<= 1) %= m)
if (e & 1) (t += b) %= m;
return t;
}
const int max0 = 3500, max1 = 1000000000;
const int maxn = 100;
int pr[max0 + 5];
int pn = 0;
inline void prepare() {
for (int i = 2; i * i <= max1; ++i) {
bool flag = 1;
for (int j = 2; j * j <= i; ++j)
if (!(i % j)) {
flag = 0;
break;
}
if (flag) pr[pn++] = i;
}
}
int A[maxn + 5], B[maxn + 5];
int aa[max0 + 5], bb[max0 + 5];
template <typename T>
T ex_gcd(T a, T b, T &first, T &second) {
if (!b) {
first = 1, second = 0;
return a;
}
T d = ex_gcd(b, a % b, second, first);
second -= a / b * first;
return d;
}
struct data {
int a, b, c;
data() {}
data(const int &_a, const int &_b, const int &_c) : a(_a), b(_b), c(_c) {}
};
data a[maxn + 5];
int an = 0;
inline int get(int first, const int &second) {
int ret = 0;
while (!(first % pr[second])) first /= pr[second], ++ret;
return ret;
}
template <typename T>
inline T ceil(T a, T b) {
if (b < 0) a = -a, b = -b;
if (a < 0) return a / b;
return (a + b - 1) / b;
}
template <typename T>
inline T floor(T a, T b) {
return -ceil(-a, -b);
}
int main() {
prepare();
int n;
scanf("%d", &n);
for (int i = (0), _end_ = (n); i < _end_; ++i) scanf("%d%d", B + i, A + i);
for (int i = (0), _end_ = (pn); i < _end_; ++i)
aa[i] = get(A[n - 1], i), bb[i] = get(B[n - 1], i);
long long ans = -1;
for (int i = (0), _end_ = (n - 1); i < _end_; ++i) {
bool flag = 0;
data pre;
for (int j = (0), _end_ = (pn); j < _end_; ++j) {
int a0 = aa[j], b0 = bb[j];
int a1 = get(A[i], j), b1 = get(B[i], j);
if (a0 || a1 || b0 != b1) {
if (b0 != b1 && !a0 && !a1) printf("-1\n"), exit(0);
if (a0 || a1) {
if (!flag)
pre = data(a0, -a1, b0 - b1);
else {
int newa = a0, newb = -a1, newc = b0 - b1;
int D = -(pre.a * newb - pre.b * newa);
int X = pre.c * newb - pre.b * newc;
int Y = pre.a * newc - pre.c * newa;
if (!D) {
if (X || Y) printf("-1\n"), exit(0);
} else {
if (X % D || Y % D)
printf("-1\n"), exit(0);
else {
if (X / D < 0 || Y / D < 0) printf("-1\n"), exit(0);
if (ans != -1 && X / D != ans) printf("-1\n"), exit(0);
ans = X / D;
}
}
}
flag = 1;
}
}
}
if (flag) a[an++] = pre;
}
for (int i = (0), _end_ = (an); i < _end_; ++i)
if (!a[i].b) {
if (a[i].c % a[i].a) printf("-1\n"), exit(0);
if (a[i].c * a[i].a > 0) printf("-1\n"), exit(0);
if (ans != -1 && (-a[i].c) / a[i].a != ans) printf("-1\n"), exit(0);
ans = (-a[i].c) / a[i].a;
}
if (ans != -1) {
for (int i = (0), _end_ = (an); i < _end_; ++i) {
a[i].c += a[i].a * ans;
if (a[i].b) {
if (a[i].c % a[i].b) printf("-1\n"), exit(0);
if (a[i].c * a[i].b > 0) printf("-1\n"), exit(0);
} else if (a[i].c)
printf("-1\n"), exit(0);
}
} else {
static int val[maxn + 5];
static int Mod[maxn + 5];
int m = 0;
long long Min = 0, Max = LLONG_MAX;
for (int i = (0), _end_ = (an); i < _end_; ++i)
if (!a[i].a) {
if (a[i].c % a[i].b) printf("-1\n"), exit(0);
if (a[i].c * a[i].b > 0) printf("-1\n"), exit(0);
} else {
static int first, second;
int d = ex_gcd(a[i].a, a[i].b, first, second);
if (a[i].c % d) printf("-1\n"), exit(0);
first *= (-a[i].c) / d;
Mod[m] = abs(a[i].b / d);
val[m] = first % Mod[m];
++m;
if (a[i].b < 0)
Min = max(Min, (long long)ceil(-a[i].c, a[i].a));
else
Max = min(Max, (long long)floor(-a[i].c, a[i].a));
}
if (Min > Max) printf("-1\n"), exit(0);
long long a = 0, b = 1;
for (int i = (0), _end_ = (m); i < _end_; ++i) {
static long long first, second;
long long d = ex_gcd(b, (long long)Mod[i], first, second);
long long res = a % d;
if ((val[i] - res) % d) printf("-1\n"), exit(0);
b /= d, Mod[i] /= d;
(a -= res) /= d;
(val[i] -= res) /= d;
long long newb = b * Mod[i];
(a += b) %= b;
(val[i] += Mod[i]) %= Mod[i];
a = (mul(mul(first, b, newb), val[i], newb) +
mul(mul(second, Mod[i], newb), a, newb)) %
newb;
b = newb * d;
((a *= d) += res) %= b;
}
(a += b) %= b;
ans = ceil(Min - a, b) * b + a;
if (ans > Max) printf("-1\n"), exit(0);
}
long long t = 1;
long long b = A[n - 1];
assert(ans >= 0);
for (; ans; ans >>= 1, (b *= b) %= Mod)
if (ans & 1) (t *= b) %= Mod;
(t *= B[n - 1]) %= Mod;
printf("%I64d\n", t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long mul(long long a, long long b, long long mod) {
long long res = 0;
for (; b; b >>= 1, a = (a + a) % mod)
if (b & 1) res = (res + a) % mod;
return res;
}
long long pow(long long b, long long e, long long mod) {
long long res = 1;
for (; e; e >>= 1, b = mul(b, b, mod))
if (e & 1) res = mul(res, b, mod);
return res;
}
long long gcd(long long a, long long b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
for (; b;) {
long long res = a % b;
a = b;
b = res;
}
return a;
}
long long phi(long long x) {
long long ans = x;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
for (; x % i == 0; x /= i)
;
ans -= ans / i;
}
}
if (x != 1) ans -= ans / x;
return ans;
}
void reject() {
printf("-1\n");
exit(0);
}
void read(map<int, pair<long long, long long> > &mp) {
int x, y;
scanf("%d %d", &x, &y);
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
int cnt = 0;
for (; x % i == 0; x /= i, cnt++)
;
mp[i].first += cnt;
}
}
if (x > 1) mp[x].first++;
for (int i = 2; i * i <= y; i++) {
if (y % i == 0) {
int cnt = 0;
for (; y % i == 0; y /= i, cnt++)
;
mp[i].second += cnt;
}
}
if (y > 1) mp[y].second++;
return;
}
long long solve(long long a, long long b, long long c) {
if (a == 0) return 0;
if (b == 0) return c / a;
long long ta = mul(pow(a, phi(-b) - 1, -b), (c % (-b) + (-b)) % (-b), -b);
long long tb = (c - ta * a) / b;
if (tb < 0) {
long long d = (-tb + a - 1) / a;
ta += -b * d;
tb += a * d;
}
return ta;
}
map<int, pair<long long, long long> > merge(
map<int, pair<long long, long long> > a,
map<int, pair<long long, long long> > b) {
long long la = 0, lb = 0, lc = 0, px = 0, py = 0, l = 0, p = 0;
for (auto it = b.begin(); it != b.end(); it++) a[it->first];
for (auto it = a.begin(); it != a.end(); it++) {
pair<long long, long long> &pa = it->second;
pair<long long, long long> &pb = b[it->first];
long long A = pa.second, B = -pb.second, C = pb.first - pa.first,
GCD = gcd(A, B);
if (A == 0 && B == 0) {
if (C) reject();
continue;
}
if (C % GCD) reject();
A /= GCD;
B /= GCD;
C /= GCD;
if (A < 0 || (A == 0 && B < 0)) {
A = -A;
B = -B;
C = -C;
}
if (p) {
if (px * A + py * B != C) reject();
} else if (l) {
if (la == A && lb == B) {
if (lc != C) reject();
} else {
long long x0 = A * lb - B * la, x1 = C * lb - B * lc;
long long y0 = B * la - A * lb, y1 = C * la - A * lc;
if (x1 % x0 || y1 % y0) reject();
l = 0;
p = 1;
px = x1 / x0;
py = y1 / y0;
if (px < 0 || py < 0) reject();
}
} else {
l = 1;
la = A;
lb = B;
lc = C;
}
}
if (l) {
map<int, pair<long long, long long> > ans;
for (auto it = a.begin(); it != a.end(); it++) {
ans[it->first] = {
it->second.first + it->second.second * solve(la, lb, lc),
it->second.second * (-lb)};
}
return ans;
} else if (p) {
map<int, pair<long long, long long> > ans;
for (auto it = a.begin(); it != a.end(); it++) {
ans[it->first] = {px * it->second.second + it->second.first, 0};
}
return ans;
}
return a;
}
map<int, pair<long long, long long> > a[105];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
read(a[i]);
if (i != 1) a[i] = merge(a[i], a[i - 1]);
}
long long ans = 1;
for (auto it = a[n].begin(); it != a[n].end(); it++)
ans = ans * 1ll * pow(it->first, it->second.first, mod) % mod;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const long long mod = (1e9) + 7;
const long long M = 998244353;
const double eps = 1e-6;
int n, cnt[110];
long long a[110], b[110], w[110], B[110], tmp;
void No() {
printf("-1\n");
exit(0);
}
int lg(long long x) { return (int)ceil(log(1.0 * x) / log(2.0)); }
long long ksm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
long long gcd(long long x, long long y) {
if (!x || !y) return x + y;
return gcd(y, x % y);
}
void solve1(int x) {
for (int i = 1; i <= n; i++) {
if (b[i] == 1 && a[i] != a[x]) No();
if (b[i] > 1) {
tmp = a[i];
while (1) {
if (tmp > a[x] / b[i]) No();
tmp *= b[i];
if (tmp == a[x]) break;
}
}
}
printf("%lld\n", a[x]);
exit(0);
}
void solve2(int x) {
long long t1 = a[1] % M, t2, t3;
int num = -1;
for (int i = 0; i < 400; i++) {
t2 = a[x] % M;
for (int j = 0; j < 400; j++) {
if (t1 == t2) {
t3 = t1, num = i;
break;
}
t2 = t2 * b[x] % M;
}
if (num != -1) break;
t1 = t1 * b[1] % M;
}
if (num == -1) No();
bool flag;
for (int i = 1; i <= n; i++) {
t1 = a[i] % M;
flag = 0;
for (int j = 0; j <= 100000; j++) {
if (t1 == t3) {
flag = 1;
break;
}
t1 = t1 * b[i] % M;
}
if (!flag) No();
}
tmp = a[1];
while (num--) tmp = tmp * b[1] % mod;
printf("%lld\n", tmp);
exit(0);
}
int main() {
srand(time(0));
read(n);
for (int i = 1; i <= n; i++) read(a[i]), read(b[i]);
for (int i = 1; i <= n; i++)
if (b[i] == 1) solve1(i);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= lg(b[i]); j++) {
tmp = (long long)floor(pow(b[i], 1.0 / j) + 0.5);
if (fabs(pow(tmp, j) - b[i]) < eps) B[i] = j, w[i] = tmp;
}
}
for (int i = 2; i <= n; i++)
if (w[i] != w[1]) solve2(i);
int mx = 0;
for (int i = 1; i <= n; i++) {
while (a[i] % w[i] == 0) a[i] /= w[i], cnt[i]++;
mx = max(mx, cnt[i]);
}
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) No();
long long Lcm = B[1], z, ans = cnt[1];
bool flag = 1;
for (int i = 2; i <= n; i++) {
flag = 0;
for (int j = 0; j < B[i]; j++)
if ((ans + Lcm * j) % B[i] == cnt[i] % B[i]) {
ans += Lcm * j;
flag = 1;
break;
}
if (!flag) No();
z = gcd(Lcm, B[i]);
Lcm = Lcm / z * B[i];
}
while (ans < mx) ans += Lcm;
printf("%lld\n", a[1] * ksm(w[1], ans) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, cnt;
int pm[10003], f[10003], g[10003];
long long a[10003], b[10003], c[10003], d[10003];
void ex_gcd(long long, long long, long long &, long long &);
int quick_pow(int, int);
bool merge();
void fac(int, long long *);
void prime(int);
long long gcd(long long, long long);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", f + i, g + i);
prime(f[i]);
prime(g[i]);
}
sort(pm + 1, pm + 1 + cnt);
cnt = unique(pm + 1, pm + 1 + cnt) - pm - 1;
fac(f[1], a);
fac(g[1], b);
for (int i = 2; i <= n; ++i) {
fac(f[i], c);
fac(g[i], d);
if (!merge()) return puts("-1"), 0;
}
int ans = 1;
for (int i = 1; i <= cnt; ++i)
ans = 1ll * ans * quick_pow(pm[i], a[i] % (mod - 1)) % mod;
cout << ans << endl;
return 0;
}
void prime(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
pm[++cnt] = i;
while (x % i == 0) x /= i;
}
if (x > 1) pm[++cnt] = x;
return;
}
void fac(int x, long long *p) {
for (int i = 1; i <= cnt; ++i) {
p[i] = 0;
while (x % pm[i] == 0) ++p[i], x /= pm[i];
}
return;
}
int quick_pow(int x, int y) {
int sum = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) sum = 1ll * sum * x % mod;
return sum;
}
void ex_gcd(long long x, long long y, long long &a, long long &b) {
if (!y) return a = 1, b = 0, void();
ex_gcd(y, x % y, a, b);
a -= x / y * b;
swap(a, b);
return;
}
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
bool merge() {
long long cb = 0, cd = 0;
for (int i = 1; i <= cnt; ++i) cb += b[i], cd += d[i];
if (!cb && !cd) {
for (int i = 1; i <= cnt; ++i)
if (a[i] != c[i]) return false;
return true;
}
if (!cb || !cd) {
if (!cb) swap(a, c), swap(b, d), swap(cb, cd);
long long k = 0;
for (int i = 1; i <= cnt; ++i)
if (b[i]) {
if (c[i] < a[i] || (c[i] - a[i]) % b[i]) return false;
k = (c[i] - a[i]) / b[i];
break;
} else if (a[i] != c[i])
return false;
for (int i = 1; i <= cnt; ++i) {
if (a[i] + k * b[i] != c[i]) return false;
a[i] += k * b[i];
b[i] = 0;
}
return true;
}
int p1 = 0, p2 = 0;
for (int i = 1; i <= cnt; ++i)
if (b[i] * cd != d[i] * cb) {
p1 = i;
break;
}
if (p1) {
for (int i = 1; i <= cnt; ++i)
if (b[i] * d[p1] != d[i] * b[p1]) {
p2 = i;
break;
}
long long x1 =
c[p1] * d[p2] - c[p2] * d[p1] - a[p1] * d[p2] + a[p2] * d[p1];
long long x2 =
a[p1] * b[p2] - a[p2] * b[p1] - c[p1] * b[p2] + c[p2] * b[p1];
long long y1 = b[p1] * d[p2] - b[p2] * d[p1];
long long y2 = d[p1] * b[p2] - d[p2] * b[p1];
if (x1 * y1 < 0 || x2 * y2 < 0 || abs(x1) % abs(y1) || abs(x2) % abs(y2))
return false;
x1 /= y1;
x2 /= y2;
for (int i = 1; i <= cnt; ++i) {
if (a[i] + b[i] * x1 != c[i] + d[i] * x2) return false;
a[i] += b[i] * x1;
b[i] = 0;
}
return true;
}
long long kb, kd, k;
for (int i = 1; i <= cnt; ++i)
if (b[i]) {
long long g = gcd(b[i], d[i]);
kb = b[i] / g;
kd = d[i] / g;
break;
}
for (int i = 1; i <= cnt; ++i)
if (b[i]) {
if ((a[i] - c[i]) % (b[i] / kb) == 0) {
k = (a[i] - c[i]) / (b[i] / kb);
break;
} else
return false;
}
for (int i = 1; i <= cnt; ++i)
if (c[i] + (b[i] / kb) * k != a[i]) return false;
if (k < 0) swap(a, c), swap(b, d), swap(kb, kd), k = -k;
long long x, y;
ex_gcd(kb, kd, x, y);
x = (-k * x % kd + kd) % kd;
for (int i = 1; i <= cnt; ++i) a[i] += b[i] * x, b[i] *= kd;
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long msk(long long a, long long b, long long k, int md) {
a %= md;
k %= md;
while (b) {
if (b & 1) k = k * a % md;
a = a * a % md;
b >>= 1;
}
return k;
}
pair<int, int> a[N];
map<int, int> mp;
int n;
long long t[N], s[N], r[N], p[N],
P[20]{0, 998244353, 1000000007, 19260817, 998244853, 1919810,
114514, 191981011451, 1145141919, 1919810, 5141919};
bool chk(int x) {
for (int i = (1); i <= (n); i++) {
if (x % a[i].first) return 0;
int y = x / a[i].first;
while (y != 1) {
if (y % a[i].second || a[i].second == 1) return 0;
y /= a[i].second;
}
}
return 1;
}
bool chk(int x, int i, int y) {
int u = (i * log(a[x].second) + log(1. * a[x].first / a[y].first)) /
log(a[y].second);
for (int k = (max(0, u - 10)); k <= (min(1919, u + 10)); k++) {
int ty = 1;
for (int l = (1); l <= (10); l++) {
int md = P[l];
if (msk(a[x].second, i, a[x].first, md) !=
msk(a[y].second, k, a[y].first, md)) {
ty = 0;
break;
}
}
if (ty) return 1;
}
return 0;
}
void sol(int x, int y) {
for (int i = (0); i <= (1919); i++) {
if (chk(x, i, y)) {
int ty = 1;
for (int j = (1); j <= (n); j++)
if (!chk(x, i, j)) {
ty = 0;
break;
}
if (ty) {
printf("%lld", msk(a[x].second, i, a[x].first, 1e9 + 7));
exit(0);
}
}
}
{
puts("-1");
exit(0);
};
}
void chai(int x) {
mp.clear();
for (int i = 2; i <= sqrt(x); ++i)
while (x % i == 0) x /= i, mp[i]++;
if (x > 1) mp[x]++;
}
int main() {
scanf("%d", &n);
srand(time(0));
for (int i = (1); i <= (n); i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + n + 1);
if (chk(a[n].first)) {
printf("%d", a[n].first);
return 0;
}
for (int i = (1); i <= (n); i++) {
chai(a[i].second);
s[i] = 1;
for (auto& j : mp) t[i] = gcd(t[i], j.second);
for (auto& j : mp) {
j.second /= t[i];
for (int k = (0); k <= (j.second - 1); k++) s[i] *= j.first;
}
if (s[i] != s[1]) sol(1, i);
}
long long md = 1, al = 0;
for (int i = (1); i <= (n); i++) {
r[i] = a[i].first;
while (!(r[i] % s[i])) r[i] /= s[i], p[i]++;
if (r[i] != r[1]) {
puts("-1");
exit(0);
};
long long x = gcd(t[i], md);
if (al % x != p[i] % x) {
puts("-1");
exit(0);
};
while (al % t[i] != p[i] % t[i]) al += md;
md = md / x * t[i];
al %= md;
}
for (int i = (1); i <= (n); i++)
while (al < p[i]) al += md;
printf("%lld\n", msk(s[1], al, r[1], 1e9 + 7));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const long long N = 5100, mod = 1e9 + 7;
long long n, cnt;
long long a[N], b[N], p[N << 1];
void getp(long long x) {
long long t = x;
for (long long i = 2; i * i <= x; i++) {
if (t % i == 0) {
p[++cnt] = i;
while (t % i == 0) t /= i;
}
}
if (t > 1) p[++cnt] = t;
}
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long ksm(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) res = res * x % mod;
return res;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
struct node {
long long k, b;
node() {}
node(long long k, long long b) : k(k), b(b) {}
} f[N << 1], g[N << 1];
struct Func {
long long a, b, c;
Func() {}
Func(long long a, long long b, long long c) : a(a), b(b), c(c){};
};
long long vis = 0;
long long solve(long long b, long long k) {
for (long long i = 1; i <= cnt; i++) g[i] = node{0, 0};
for (long long i = 1; i <= cnt; i++) {
while (k % p[i] == 0) k /= p[i], ++g[i].k;
while (b % p[i] == 0) b /= p[i], ++g[i].b;
}
if (!vis) {
for (long long i = 1; i <= cnt; i++) f[i] = g[i];
return vis = 1;
}
for (long long t = 1; t <= 3; t++) {
for (long long i = 1; i <= cnt; i++) {
long long fb = f[i].b, fk = f[i].k;
long long gb = g[i].b, gk = g[i].k;
if (!fk && !gk) {
if (fb != gb) return 0;
} else if (!fk || !gk) {
long long tag = 0;
if (!fk) swap(fk, gk), swap(fb, gb), tag = 1;
if (gb < fb || (gb - fb) % fk) return 0;
long long k = (gb - fb) / fk;
if (tag)
for (long long j = 1; j <= cnt; j++) g[j].b += g[j].k * k, g[j].k = 0;
else
for (long long j = 1; j <= cnt; j++) f[j].b += f[j].k * k, f[j].k = 0;
}
}
}
Func F;
long long flag = 0;
long long X = -1, Y = -1;
for (long long i = 1; i <= cnt; i++) {
long long fb = f[i].b, fk = f[i].k;
long long gb = g[i].b, gk = g[i].k;
if (fk && gk) {
if (!flag)
F = Func(fk, -gk, gb - fb), flag = 1;
else if (flag == 1) {
long long A = fk, B = -gk, C = gb - fb;
long long d = gcd(F.a, A);
long long m1 = A / d, m2 = F.a / d;
F.a *= m1, F.b *= m1, F.c *= m1;
A *= m2, B *= m2, C *= m2;
if (F.a == A && F.b == B) {
if (F.c != C)
return 0;
else {
long long d = gcd(gcd(F.a, abs(F.b)), abs(F.c));
F.a /= d, F.b /= d, F.c /= d;
continue;
}
} else {
C -= F.c, B -= F.b;
if (C < 0) C *= -1, B *= -1;
if (B < 0 || C % B) return 0;
Y = C / B;
X = (F.c - F.b * Y) / F.a;
if (X < 0 || (F.c - F.b * Y) % F.a) return 0;
flag = 2;
}
} else if (flag == 2) {
long long A = fk, B = -gk, C = gb - fb;
if (A * X + B * Y != C) return 0;
}
}
}
if (flag == 2) {
for (long long i = 1; i <= N; i++) f[i].b += f[i].k * X, f[i].k = 0;
}
if (flag == 1) {
long long x, y;
long long d = exgcd(F.a, -F.b, x, y);
y = -y;
if (F.c % d) return 0;
long long kx = -F.b / d, ky = F.a / d;
x *= F.c / d;
y *= F.c / d;
long long tx = 0, ty = 0;
if (x < 0)
tx = -((-x + kx - 1) / kx);
else
tx = x / kx;
if (y < 0)
ty = -((-y + ky - 1) / ky);
else
ty = y / ky;
x -= kx * min(tx, ty);
y -= ky * min(tx, ty);
for (long long i = 1; i <= N; i++) f[i].b += f[i].k * x, f[i].k *= kx;
}
return 1;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) {
getp(a[i] = read());
getp(b[i] = read());
}
sort(p + 1, p + 1 + cnt);
cnt = unique(p + 1, p + 1 + cnt) - p - 1;
for (long long i = 1; i <= n; i++)
if (!solve(a[i], b[i])) {
puts("-1");
return 0;
}
long long res = 1;
for (long long i = 1; i <= cnt; i++)
res = 1ll * res * ksm(p[i], f[i].b) % mod;
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prime;
int a[101], b[101];
struct line {
long long a, b, c;
};
vector<line> mat;
int power(int a, long long n) {
int ans = 1;
while (n) {
if (n & 1) ans = 1ll * ans * a % 1000000007;
a = 1ll * a * a % 1000000007;
n >>= 1;
}
return ans;
}
long long gcd(long long x, long long y) {
if (x < 0) x = -x;
if (y < 0) y = -y;
return y ? gcd(y, x % y) : x;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= x * (a / b);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
int x = a[i], y = b[i];
for (int j = 2; j * j <= 1000000000; j++)
if (x % j == 0 || y % j == 0) {
prime.push_back(j);
while (x % j == 0) x /= j;
while (y % j == 0) y /= j;
}
if (x > 1) prime.push_back(x);
if (y > 1) prime.push_back(y);
}
sort(prime.begin(), prime.end());
int l = unique(prime.begin(), prime.end()) - prime.begin();
vector<long long> a0, b0;
for (int i = 0; i < l; i++) {
int va = 0, vb = 0;
while (a[1] % prime[i] == 0) a[1] /= prime[i], ++va;
while (b[1] % prime[i] == 0) b[1] /= prime[i], ++vb;
a0.push_back(va), b0.push_back(vb);
}
for (int i = 2; i <= n; i++) {
mat.clear();
for (int j = 0; j < l; j++) {
int va = 0, vb = 0;
while (a[i] % prime[j] == 0) a[i] /= prime[j], ++va;
while (b[i] % prime[j] == 0) b[i] /= prime[j], ++vb;
line ins;
ins.a = b0[j], ins.b = -vb, ins.c = va - a0[j];
mat.push_back(ins);
}
int rnk = 0;
line base[2];
for (int j = 0; j < l; j++) {
if (!rnk && (mat[j].a || mat[j].b)) rnk = 1, base[0] = mat[j];
if (rnk == 1 && base[0].a * mat[j].b != base[0].b * mat[j].a)
rnk = 2, base[1] = mat[j];
}
if (rnk == 0) {
for (int j = 0; j < l; j++)
if (mat[j].c != 0) {
puts("-1");
return 0;
}
}
if (rnk == 1) {
long long x, y, tmp = gcd(base[0].a, base[0].b);
if (base[0].c % tmp != 0) {
puts("-1");
return 0;
}
if (base[0].c == 0)
x = y = 0;
else {
base[0].a /= tmp, base[0].b /= tmp, base[0].c /= tmp;
if (base[0].b == 0)
x = base[0].c, y = 0;
else {
exgcd(base[0].a, -base[0].b, x, y);
long long ch = llabs(base[0].b);
x *= base[0].c;
x = (x % ch + ch) % ch;
y = (base[0].c - base[0].a * x) / base[0].b;
if (y < 0) {
if (base[0].a == 0) {
puts("-1");
return 0;
}
ch = llabs(base[0].a);
y = (y % ch + ch) % ch;
x = (base[0].c - base[0].b * y) / base[0].a;
assert(x * base[0].a + base[0].b * y == base[0].c);
}
}
}
for (int j = 0; j < l; j++) {
long long ta = b0[j], tb = -mat[j].b;
if (x * mat[j].a + y * mat[j].b != mat[j].c) {
puts("-1");
return 0;
}
a0[j] += x * b0[j],
b0[j] = llabs(!ta || !tb ? 0 : (ta / gcd(ta, tb)) * tb);
}
}
if (rnk == 2) {
if (!base[0].b) swap(base[0], base[1]);
long long t1 = base[0].c * base[1].b - base[1].c * base[0].b,
t2 = base[0].a * base[1].b - base[1].a * base[0].b;
if (t1 % t2 != 0) {
puts("-1");
return 0;
}
long long x0 = t1 / t2;
if (x0 < 0) {
puts("-1");
return 0;
}
t1 = base[0].c - x0 * base[0].a, t2 = base[0].b;
if (t1 % t2 != 0) {
puts("-1");
return 0;
}
long long y0 = t1 / t2;
if (y0 < 0) {
puts("-1");
return 0;
}
for (int j = 0; j < l; j++) {
if (x0 * mat[j].a + y0 * mat[j].b != mat[j].c) {
puts("-1");
return 0;
}
a0[j] += x0 * b0[j], b0[j] = 1;
}
}
}
int ans = 1;
for (int i = 0; i < l; i++)
ans = 1ll * ans * power(prime[i], a0[i]) % 1000000007;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
static const long long int mod = 1000000007LL;
using vpair = std::vector<std::pair<int, int> >;
long long int gcd(long long int a, long long int b) {
while (b != 0) {
long long int c = a % b;
a = b, b = c;
}
return a;
}
vpair factor(int v) {
vpair res;
for (int i = 2; i * i <= v; ++i) {
if (v % i == 0) {
int cnt = 0;
while (v % i == 0) {
++cnt;
v /= i;
}
res.emplace_back(i, cnt);
}
}
if (v > 1) res.emplace_back(v, 1);
return res;
}
std::pair<int, int> simplify(int v) {
vpair k = factor(v);
int g = 0;
for (int i = 0; i < k.size(); ++i) {
g = gcd(g, k[i].second);
}
int a = 1;
for (int i = 0; i < k.size(); ++i) {
for (int j = 0; j < k[i].second / g; ++j) a *= k[i].first;
}
return std::make_pair(a, g);
}
long long int exgcd(long long int a, long long int b, long long int &c,
long long int &d) {
if (b == 0) {
c = 1, d = 0;
return a;
}
long long int v = exgcd(b, a % b, d, c);
d -= c * (a / b);
return v;
}
long long int mul2(long long int a, long long int b, long long int m) {
long long int val = 0;
for (int i = 63; i >= 0; --i) {
val += val;
if (((a >> i) & 1) == 1) val += b;
while (val >= m) val -= m;
}
return val;
}
long long int mul3(long long int a, long long int b, long long int c,
long long int m) {
long long int sign = 1;
if (a < 0) sign = -sign, a = -a;
if (b < 0) sign = -sign, b = -b;
if (c < 0) sign = -sign, c = -c;
return sign * mul2(mul2(a, b, m), c, m);
}
std::pair<long long int, long long int> crt(
std::pair<long long int, long long int> a,
std::pair<long long int, long long int> b) {
long long int p, q;
long long int v = exgcd(a.first, b.first, p, q);
if (a.second % v != b.second % v) {
return std::make_pair(0, 0);
} else {
long long int rem = a.second % v;
long long int k = a.first / v * b.first / v;
long long int s = mul3(a.second / v, b.first / v, q, k) +
mul3(b.second / v, a.first / v, p, k);
s %= k;
if (s < 0) s += k;
return std::make_pair(k * v, s * v + rem);
}
}
long long int qpow(long long int a, long long int b, long long int m) {
long long int val = 1;
for (int i = 60; i >= 0; --i) {
val = val * val % m;
if ((b & (1LL << i)) != 0) {
val = val * a % m;
}
}
return val;
}
typedef int ppair[2][2];
using map = std::map<int, ppair>;
void copy(ppair &a, ppair &b) { memmove(&a, &b, sizeof(ppair)); }
int n;
struct item {
int A, B;
int a, b;
int oa, ob;
} v[103];
int main() {
scanf("%d", &n);
long long int oneans = -1;
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d%d", &a, &b);
v[i].oa = a;
v[i].ob = b;
std::pair<int, int> p = simplify(b);
v[i].B = p.first;
v[i].b = p.second;
if (b != 1) {
while (a % p.first == 0) {
++v[i].a;
a /= p.first;
}
v[i].A = a;
} else {
oneans = a;
}
}
if (oneans != -1) {
for (int i = 0; i < n; ++i) {
long long int temp = oneans;
while (temp % v[i].ob == 0) {
if (temp == v[i].oa) break;
temp /= v[i].ob;
}
if (temp != v[i].oa) {
printf("-1\n");
return 0;
}
}
printf("%I64d\n", oneans);
return 0;
}
int j = 1;
while (j < n && v[j].B == v[0].B) ++j;
if (j == n) {
std::pair<long long int, long long int> cur(1, 0);
long long int min = 0;
for (int i = 0; i < n; ++i) {
if (v[i].A != v[0].A) {
printf("-1\n");
return 0;
}
cur = crt(cur, std::make_pair(v[i].b, v[i].a % v[i].b));
if (cur.first == 0) {
printf("-1\n");
return 0;
}
if (v[i].b > min) min = v[i].a;
}
cur.second += (min - cur.second + cur.first - 1) / cur.first * cur.first;
assert(cur.second >= min);
assert(cur.second - cur.first < min);
printf("%I64d\n", v[0].A * qpow(v[0].B, cur.second, mod) % mod);
} else {
map m;
std::vector<std::pair<int, int> > f1 = factor(v[0].A);
for (int i = 0; i < f1.size(); ++i) m[f1[i].first][0][0] = f1[i].second;
std::vector<std::pair<int, int> > f2 = factor(v[0].B);
for (int i = 0; i < f2.size(); ++i) m[f2[i].first][0][1] = f2[i].second;
std::vector<std::pair<int, int> > f3 = factor(v[j].A);
for (int i = 0; i < f3.size(); ++i) m[f3[i].first][1][0] = f3[i].second;
std::vector<std::pair<int, int> > f4 = factor(v[j].B);
for (int i = 0; i < f4.size(); ++i) m[f4[i].first][1][1] = f4[i].second;
ppair a, b;
int state = 0;
for (map::iterator it = m.begin(); it != m.end(); ++it) {
if (state == 0) {
if (it->second[0][1] != 0 || it->second[1][1] != 0) {
copy(a, it->second);
state = 1;
}
} else {
if ((long long int)a[0][1] * it->second[1][1] !=
(long long int)a[1][1] * it->second[0][1]) {
copy(b, it->second);
state = 2;
break;
}
}
}
assert(state == 2);
long long int xa = ((long long int)a[1][0] - a[0][0]) * b[1][1] -
((long long int)b[1][0] - b[0][0]) * a[1][1],
xb = (long long int)a[0][1] * b[1][1] -
(long long int)a[1][1] * b[0][1];
long long int ya = ((long long int)a[0][0] - a[1][0]) * b[0][1] -
((long long int)b[0][0] - b[1][0]) * a[0][1],
yb = -xb;
if (xa % xb != 0 || ya % yb != 0) {
printf("-1\n");
return 0;
}
long long int x = xa / xb, y = ya / yb;
std::map<int, int> res;
for (map::iterator it = m.begin(); it != m.end(); ++it) {
long long int v1 = it->second[0][0] + it->second[0][1] * x;
long long int v2 = it->second[1][0] + it->second[1][1] * y;
if (v1 != v2) {
printf("-1\n");
return 0;
}
res[it->first] = v1;
}
for (int i = 0; i < n; ++i) {
vpair v1 = factor(v[i].A), v2 = factor(v[i].B);
std::map<int, std::pair<int, int> > temp;
for (int k = 0; k < v1.size(); ++k) {
temp[v1[k].first].first = v1[k].second;
}
for (int k = 0; k < v2.size(); ++k) {
temp[v2[k].first].second = v2[k].second;
}
for (std::map<int, int>::iterator it = res.begin(); it != res.end();
++it) {
std::pair<int, int> p = temp[it->first];
if (p.second == 0) {
if (it->second == p.first) continue;
printf("-1\n");
return 0;
}
if ((it->second - p.first) % p.second != 0) {
printf("-1\n");
return 0;
}
int k = (it->second - p.first) / p.second;
if (k < v[i].a || (k - v[i].a) % v[i].b != 0) {
printf("-1\n");
return 0;
}
}
}
long long int ans = (long long int)v[0].A * qpow(v[0].B, x, mod) % mod;
long long int ans2 = (long long int)v[j].A * qpow(v[j].B, y, mod) % mod;
assert(ans == ans2);
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int read();
int fsp(long long bs, int p) {
int rt = 1;
while (p) {
if (p & 1) rt = bs * rt % 1000000007;
bs = bs * bs % 1000000007, p >>= 1;
}
return rt;
}
int p[10004], cnt;
int a[202], b[202];
struct Q {
long long x[1003], y[1003];
} q[202];
void solve1(int x) {
for (int t = 2; t * t <= x; ++t) {
if (x % t) continue;
for (p[++cnt] = t; x % t == 0;) x /= t;
}
if (x > 1) p[++cnt] = x;
}
void solve2(int x, long long* q) {
for (int t = 2; t * t <= x; ++t) {
if (x % t) continue;
int tp = lower_bound(p + 1, p + 1 + cnt, t) - p;
while (x % t == 0) x /= t, ++q[tp];
}
if (x > 1) ++q[lower_bound(p + 1, p + 1 + cnt, x) - p];
}
void fail() { puts("-1"), exit(0); }
void prt() {
int res = 1;
for (int j = 1; j <= cnt; ++j)
res = 1ll * res * fsp(p[j], q[1].x[j] % (1000000007 - 1)) % 1000000007;
printf("%d\n", res), exit(0);
}
void check(long long k, int st) {
for (int j = 1; j <= cnt; ++j) q[1].x[j] += q[1].y[j] * k;
for (int i = st; i <= n; ++i) {
long long tk = -1, ttk;
for (int j = 1; j <= cnt; ++j) {
long long A1 = q[1].x[j], A2 = q[i].x[j];
long long B2 = q[i].y[j];
if (B2 == 0 && A1 != A2) fail();
if (B2) {
if (A2 > A1 || (A1 - A2) % B2) fail();
ttk = (A1 - A2) / B2;
if (tk == -1) tk = ttk;
if (tk != ttk) fail();
}
}
}
prt();
}
long long gcd(long long a, long long b) {
while (b ^= a ^= b ^= a %= b) void();
return a;
}
struct T {
long long a, b, c;
bool operator==(T x) { return a == x.a && b == x.b && c == x.c; }
} t;
long long solve3(T s, T t) {
long long K = s.a * t.b - t.a * s.b, B = s.c * t.b - t.c * s.b;
if (!B) return 0;
if (!K || B % K || ((K > 0) ^ (B > 0))) fail();
return B / K;
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) return x = 1, y = 0, a;
long long d = exgcd(b, a % b, y, x);
return y -= a / b * x, d;
}
void solve4(long long B1, long long B2, long long A, long long& x,
long long& y) {
long long tx, ty, d = exgcd(B1, B2, tx, ty), t1 = B2 / d, t2 = B1 / d;
if (A % d) fail();
tx *= A / d, ty *= -A / d;
x = (tx < 0 ? -tx + t1 - 1 : -tx) / t1;
y = (ty < 0 ? -ty + t2 - 1 : -ty) / t2;
x = tx + max(x, y) * t1, y = t1;
}
void work() {
for (int i = 2; i <= n; ++i) {
int tc = 0;
for (int j = 1; j <= cnt; ++j) {
long long A1 = q[1].x[j], A2 = q[i].x[j];
long long B1 = q[1].y[j], B2 = q[i].y[j];
if (B1 == 0 && B2 == 0) {
if (A1 != A2) fail();
} else if (B1 == 0) {
if (A1 < A2 || (A1 - A2) % B2) fail();
check((A1 - A2) / B2, i);
} else if (B2 == 0) {
if (A2 < A1 || (A2 - A1) % B1) fail();
check((A2 - A1) / B1, i);
}
}
long long tK = -1, ttK;
for (int j = 1; j <= cnt; ++j) {
long long A1 = q[1].x[j], A2 = q[i].x[j];
long long B1 = q[1].y[j], B2 = q[i].y[j];
if (B1 == 0) continue;
long long d = gcd(B1, B2), C = A2 - A1;
if (C % d) fail();
B1 /= d, B2 /= d, C /= d;
if (tc) {
if (t == (T){B1, B2, C}) continue;
ttK = solve3(t, (T){B1, B2, C});
if (tK == -1) tK = ttK;
if (tK != ttK) fail();
} else {
t = (T){B1, B2, C}, tc = 1;
}
}
if (tK != -1) check(tK, i);
long long N, M;
solve4(t.a, t.b, t.c, N, M);
for (int j = 1; j <= cnt; ++j) {
if (q[1].y[j] == 0) continue;
q[1].x[j] += N * q[1].y[j], q[1].y[j] *= M;
}
}
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) solve1(a[i] = read()), solve1(b[i] = read());
sort(p + 1, p + 1 + cnt), cnt = unique(p + 1, p + 1 + cnt) - p - 1;
for (int i = 1; i <= n; ++i) solve2(a[i], q[i].x), solve2(b[i], q[i].y);
work(), prt();
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n;
vector<pair<int, long long> > fa[100], fb[100];
long long powmod(long long a, long long k) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * a % mod;
}
a = a * a % mod;
k >>= 1;
}
return ret;
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1;
y = 0;
return a;
}
long long d = exgcd(b, a % b, y, x);
y -= x * (a / b);
return d;
}
long long find(const vector<pair<int, long long> >& f, int p) {
int pos = lower_bound(f.begin(), f.end(), make_pair(p, -1ll)) - f.begin();
if (pos != f.size() && f[pos].first == p) {
return f[pos].second;
}
return 0;
}
vector<pair<int, long long> > factor(int x) {
vector<pair<int, long long> > ret;
for (int i = 2; i * i <= x; ++i) {
long long cnt = 0;
while (x % i == 0) {
cnt++;
x /= i;
}
if (cnt) {
ret.push_back(make_pair(i, cnt));
}
}
if (x > 1) {
ret.push_back(make_pair(x, 1));
}
return ret;
}
void addfirst(vector<int>& s, const vector<pair<int, long long> >& t) {
for (int i = 0; i < t.size(); ++i) {
s.push_back(t[i].first);
}
}
bool solve() {
while (n > 1) {
int cnt = 0;
for (int i = 0; i < n - 1; ++i) {
vector<int> v;
addfirst(v, fa[i]);
addfirst(v, fb[i]);
addfirst(v, fa[i + 1]);
addfirst(v, fb[i + 1]);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
long long px = -1, py, sx, sy;
for (int j = 0; j < v.size(); ++j) {
long long a1 = find(fa[i], v[j]), a2 = find(fa[i + 1], v[j]);
long long b1 = find(fb[i], v[j]), b2 = find(fb[i + 1], v[j]);
long long x, y, dx, dy;
long long d = exgcd(b1, -b2, x, y);
if (b1 == 0 && b2 == 0) {
if (a1 != a2) {
return false;
}
continue;
} else if (b1 == 0 && a1 >= a2 && (a1 - a2) % b2 == 0) {
x = 0;
y = (a1 - a2) / b2;
dx = 1;
dy = 0;
} else if (b2 == 0 && a2 >= a1 && (a2 - a1) % b1 == 0) {
x = (a2 - a1) / b1;
y = 0;
dx = 0;
dy = 1;
} else if (d == 0 || (a2 - a1) % d != 0) {
return false;
} else {
x *= (a2 - a1) / d;
y *= (a2 - a1) / d;
dx = b2 / abs(d);
dy = b1 / abs(d);
if (x > 0 && dx > 0) {
long long t = (x - 1) / dx + 1;
x -= t * dx;
y -= t * dy;
}
if (y > 0 && dy > 0) {
long long t = (y - 1) / dy + 1;
x -= t * dx;
y -= t * dy;
}
if (x < 0) {
if (dx == 0) {
return false;
}
long long t = (-x - 1) / dx + 1;
x += t * dx;
y += t * dy;
}
if (y < 0) {
if (dy == 0) {
return false;
}
long long t = (-y - 1) / dy + 1;
x += t * dx;
y += t * dy;
}
}
if (px == -1) {
px = x;
py = y;
sx = dx;
sy = dy;
} else {
if (sx != 0 || sy != 0) {
if (sx != dx || sy != dy) {
long long k1 =
((x - px) * dy - (y - py) * dx) / (sx * dy - sy * dx);
long long nx = px + sx * k1, ny = py + sy * k1;
if (nx < x || ny < y || (nx - x) * dy - dx * (ny - y) != 0) {
return false;
}
px = nx;
py = ny;
sx = sy = 0;
} else if ((px - x) * dy - dx * (py - y) != 0) {
return false;
}
} else if (px < x || py < y || (px - x) * dy - dx * (py - y) != 0) {
return false;
}
}
}
if (px != -1) {
vector<pair<int, long long> > nfa, nfb;
for (int j = 0; j < v.size(); ++j) {
long long a1 = find(fa[i], v[j]), b1 = find(fb[i], v[j]);
if (b1 * px + a1) {
nfa.push_back(make_pair(v[j], b1 * px + a1));
}
if (b1 * sx) {
nfb.push_back(make_pair(v[j], b1 * sx));
}
}
fa[cnt] = nfa;
fb[cnt++] = nfb;
}
}
n = cnt;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int a, b;
scanf("%d %d", &a, &b);
fa[i] = factor(a);
fb[i] = factor(b);
}
if (solve()) {
long long ans = 1;
for (int i = 0; i < fa[0].size(); ++i) {
ans = ans * powmod(fa[0][i].first, fa[0][i].second) % mod;
}
printf("%I64d\n", ans);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 514;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long msk(long long a, long long b, long long k, int md) {
a %= md;
k %= md;
while (b) {
if (b & 1) k = k * a % md;
a = a * a % md;
b >>= 1;
}
return k;
}
pair<int, int> a[N];
map<int, int> mp;
int n;
long long t[N], s[N], r[N], p[N];
bool chk(int x) {
for (int i = (1); i <= (n); i++) {
if (x % a[i].first) return 0;
int y = x / a[i].first;
while (y != 1) {
if (y % a[i].second || a[i].second == 1) return 0;
y /= a[i].second;
}
}
return 1;
}
bool chk(int x, int i, int y) {
int u = (i * log(a[x].second) + log(a[x].first) - log(a[y].first)) /
log(a[y].second) +
0.5;
for (int k = (max(0, u - 10)); k <= (min(1919, u + 10)); k++) {
int ty = 1;
for (int l = (0); l <= (49); l++) {
int md = rand() % 1919810 + 1e9;
if (msk(a[x].second, i, a[x].first, md) !=
msk(a[y].second, k, a[y].first, md)) {
ty = 0;
break;
}
}
if (ty) return 1;
}
return 0;
}
void sol(int x, int y) {
for (int i = (0); i <= (1919); i++) {
if (chk(x, i, y)) {
int ty = 1;
for (int j = (1); j <= (n); j++)
if (!chk(x, i, j)) {
ty = 0;
break;
}
if (ty) {
printf("%lld", msk(a[x].second, i, a[x].first, 1e9 + 7));
exit(0);
}
}
}
{
puts("-1");
exit(0);
};
}
void chai(int x) {
mp.clear();
for (int i = 2; i <= sqrt(x); ++i)
while (x % i == 0) x /= i, mp[i]++;
if (x > 1) mp[x]++;
}
int main() {
scanf("%d", &n);
srand(time(0));
for (int i = (1); i <= (n); i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + n + 1);
if (chk(a[n].first)) {
printf("%d", a[n].first);
return 0;
}
for (int i = (1); i <= (n); i++) {
chai(a[i].second);
s[i] = 1;
for (auto& j : mp) t[i] = gcd(t[i], j.second);
for (auto& j : mp) {
j.second /= t[i];
for (int k = (0); k <= (j.second - 1); k++) s[i] *= j.first;
}
if (s[i] != s[1]) sol(1, i);
}
long long md = 1, al = 0;
for (int i = (1); i <= (n); i++) {
r[i] = a[i].first;
while (!(r[i] % s[i])) r[i] /= s[i], p[i]++;
if (r[i] != r[1]) {
puts("-1");
exit(0);
};
long long x = gcd(t[i], md);
if (al % x != p[i] % x) {
puts("-1");
exit(0);
};
while (al % t[i] != p[i] % t[i]) al += md;
md = md / x * t[i];
al %= md;
}
for (int i = (1); i <= (n); i++)
while (al < p[i]) al += md;
printf("%lld\n", msk(s[1], al, r[1], 1e9 + 7));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, top;
long long maxn, a[110], b[110], sa[110][410], sb[110][410], q[410];
inline int mo(int x) {
if (x >= MOD) return x - MOD;
return x;
}
inline long long gcd(long long x, long long y) {
if (x < 0) return gcd(-x, y);
if (y < 0) return gcd(x, -y);
if (!y) return x;
return gcd(y, x % y);
}
inline void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= a / b * x;
}
inline int power(int x, long long y) {
int ans = 1, t = x;
while (y) {
if (y % 2) ans = 1ll * ans * t % MOD;
t = 1ll * t * t % MOD;
y /= 2;
}
return ans;
}
long long solve(long long a, long long b, long long c) {
if (!a) return 0;
if (!b) return c / a;
if (a < 0) a = -a;
if (b < 0) b = -b;
long long x, y;
exgcd(a, b, x, y);
x = x * c;
x = (x % b + b) % b;
y = (c - a * x) / (-b);
long long t = (y >= 0 ? 0 : (-y + a - 1) / a);
x += t * b;
return x;
}
inline int read() {
int ans = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
return ans;
}
void gofail() {
printf("-1\n");
exit(0);
}
int main() {
n = read();
for (int i = 1; i <= n; i++)
a[i] = read(), b[i] = read(), maxn = max(maxn, a[i]),
maxn = max(maxn, b[i]);
maxn = sqrt(maxn);
for (int i = 2; i <= maxn; i++)
if (a[1] % i == 0 || b[1] % i == 0) {
q[++top] = i;
while (a[1] % i == 0) sa[1][top]++, a[1] /= i;
while (b[1] % i == 0) sb[1][top]++, b[1] /= i;
}
if (a[1] != 1) {
q[++top] = a[1];
sa[1][top] = 1;
if (b[1] == a[1]) sb[1][top] = 1, b[1] = 1;
a[1] = 1;
}
if (b[1] != 1) {
q[++top] = b[1];
sb[1][top] = 1;
}
for (int j = 2; j <= n; j++) {
for (int i = 1; i <= top; i++) {
while (a[j] % q[i] == 0) a[j] /= q[i], sa[j][i]++;
while (b[j] % q[i] == 0) b[j] /= q[i], sb[j][i]++;
}
if (a[j] != 1) {
q[++top] = a[j], sa[j][top] = 1;
if (b[j] == a[j]) sb[j][top] = 1, b[j] = 1;
a[j] = 1;
}
if (b[j] != 1) q[++top] = b[j], sb[j][top] = 1;
}
if (!top) {
printf("1\n");
return 0;
}
for (int i = 2; i <= n; i++) {
long long l = 0, la = 0, lb = 0, lc = 0;
long long p = 0, px = 0, py = 0;
for (int j = 1; j <= top; j++) {
long long A = sb[1][j], B = -sb[i][j], C = sa[i][j] - sa[1][j],
G = gcd(A, B);
if (A == 0 && B == 0) {
if (C) gofail();
continue;
}
if (C % G) gofail();
A /= G;
B /= G;
C /= G;
if (A < 0 || (A == 0 && B < 0)) A = -A, B = -B, C = -C;
if (p) {
if (px * A + py * B != C) gofail();
} else if (l) {
if (la == A && lb == B) {
if (lc != C) gofail();
} else {
long long X0 = A * lb - B * la, X1 = C * lb - B * lc;
long long Y0 = B * la - A * lb, Y1 = C * la - A * lc;
if (X1 % X0 || Y1 % Y0) gofail();
l = 0;
p = 1;
px = X1 / X0;
py = Y1 / Y0;
if (px < 0 || py < 0) gofail();
}
} else
l = 1, la = A, lb = B, lc = C;
}
if (l) {
for (int j = 1; j <= top; j++)
sa[1][j] = sa[1][j] + sb[1][j] * solve(la, lb, lc), sb[1][j] *= (-lb);
} else if (p) {
for (int j = 1; j <= top; j++) sa[1][j] += sb[1][j] * px, sb[1][j] = 0;
}
}
int ans = 1;
for (int i = 1; i <= top; i++) ans = 1ll * ans * power(q[i], sa[1][i]) % MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n;
set<int> all;
struct d {
map<int, int> v;
int& operator[](int x) { return v[x]; }
void init(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int cnt = 0;
while (x % i == 0) cnt++, x /= i;
v[i] = cnt;
all.insert(i);
}
if (x > 1) {
v[x] = 1;
all.insert(x);
}
}
bool operator!=(d b) {
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (v[*it] != b[*it]) return 1;
return 0;
}
};
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
int trs(d& a) {
int g = 0;
for (map<int, int>::iterator it = a.v.begin(); it != a.v.end(); it++)
g = gcd(g, it->second);
if (g)
for (map<int, int>::iterator it = a.v.begin(); it != a.v.end(); it++)
it->second /= g;
return g;
}
d a[105], b[105];
inline int power(int x, long long y) {
int z = 1;
while (y) {
if (y & 1) z = 1ll * z * x % mod;
x = 1ll * x * x % mod;
y >>= 1;
}
return z;
}
namespace unsame {
void chk(d a0, d a1, d b0, d b1) {
int aa, bb, cc;
bool ok = 0;
int x, y;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
int ta = b0[*it];
int tb = -b1[*it];
int tc = a0[*it] - a1[*it];
if (ta || tb || tc) {
if (!ta || !tb) {
if (!ta && !tb) {
puts("-1");
return;
}
if (!ta) {
x = -tc / tb;
if (x < 0 || tc % tb) {
puts("-1");
return;
}
swap(a0, b0);
} else {
x = -tc / ta;
if (x < 0 || tc % ta) {
puts("-1");
return;
}
}
break;
}
int g = gcd(gcd(ta, tb), tc);
ta /= g;
tb /= g;
tc /= g;
if (ok && (ta != aa || tb != bb || tc != cc)) {
int t = ta * bb - tb * aa;
if (!t) {
puts("-1");
return;
}
int w = aa * tc - ta * cc;
y = w / t;
if (y < 0 || y * t != w) {
puts("-1");
return;
}
w = tb * cc - bb * tc;
x = w / t;
if (x < 0 || x * t != w) {
puts("-1");
return;
}
break;
} else {
aa = ta;
bb = tb;
cc = tc;
ok = 1;
}
}
}
d r;
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
r[*it] = a0[*it] + x * b0[*it];
for (int i = 1; i <= n; i++) {
int p = -1;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
if (b[i][*it]) {
int t = (r[*it] - a[i][*it]) / b[i][*it];
if (t * b[i][*it] + a[i][*it] != r[*it]) {
puts("-1");
return;
}
if (p == -1) p = t;
if (t != p) {
puts("-1");
return;
}
} else {
if (r[*it] != a[i][*it]) {
puts("-1");
return;
}
}
}
}
int res = 1;
for (set<int>::iterator it = all.begin(); it != all.end(); it++) {
res = 1ll * res * power(*it, r[*it]) % mod;
}
printf("%d\n", res);
}
} // namespace unsame
namespace same {
int k[105], c[105];
int T(d& a, d& b) {
int mn = 1e9;
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (b[*it]) {
mn = min(mn, a[*it] / b[*it]);
}
for (set<int>::iterator it = all.begin(); it != all.end(); it++)
if (b[*it]) {
a[*it] -= mn * b[*it];
}
return mn;
}
void exgcd(long long a, long long b, long long& x, long long& y, long long& c) {
if (!b) {
y = 0;
x = 1;
c = a;
return;
}
exgcd(b, a % b, y, x, c);
y -= a / b * x;
}
void work() {
for (int i = 1; i <= n; i++) c[i] = T(a[i], b[i]);
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) {
puts("-1");
exit(0);
}
long long tk = k[1], tc = c[1];
for (int i = 2; i <= n; i++) {
long long g, x, y;
exgcd(tk, -k[i], x, y, g);
if ((c[i] - tc) % g) {
puts("-1");
return;
}
x *= (c[i] - tc) / g;
y *= (c[i] - tc) / g;
g = abs(g);
k[i] /= g;
tk /= g;
long long t = max((-x + k[i] - 1) / k[i], (-y + tk - 1) / tk);
x += t * k[i], y += t * tk;
t = min(x / k[i], y / tk);
x -= t * k[i], y -= t * tk;
tc = tk * g * x + tc;
tk = tk * k[i] * g;
}
int res = 1;
for (map<int, int>::iterator it = a[1].v.begin(); it != a[1].v.end(); it++)
if (it->second) {
res = 1ll * res * power(it->first, it->second) % mod;
}
for (map<int, int>::iterator it = b[1].v.begin(); it != b[1].v.end(); it++)
if (it->second) {
res = 1ll * res * power(it->first, it->second * tc) % mod;
}
printf("%d\n", res);
}
} // namespace same
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[i].init(x);
b[i].init(y);
}
for (int i = 1; i <= n; i++) same::k[i] = trs(b[i]);
for (int i = 2; i <= n; i++) {
if (b[1] != b[i]) {
for (int i = 1; i <= n; i++)
for (map<int, int>::iterator it = b[i].v.begin(); it != b[i].v.end();
it++)
it->second *= same::k[i];
unsame::chk(a[1], a[i], b[1], b[i]);
return 0;
}
}
same::work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int MM = 31625;
struct simpen {
long long a, b, c;
void print() { printf("%I64d %I64d %I64d\n", a, b, c); }
};
long long n, a[MM], b[MM], pr[MM], cpp = 0, cpr = 0, aa[MM], bb[MM], valen[MM],
momod[MM];
bool prpr[MM];
simpen p[MM];
long long dio(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = dio(b, a % b, y, x);
y = y - x * (a / b);
return d;
}
void start() {
for (int i = 2; i * i <= 1000000000; i++) {
bool test = 1;
for (int j = 2; j * j <= i; j++) {
if (i % j == 0) {
test = 0;
break;
}
}
if (test) pr[cpr++] = i;
}
}
long long get(long long x, const int &y) {
long long ret = 0;
while (!(x % pr[y])) x /= pr[y], ++ret;
return ret;
}
long long cc(long long a, long long b) {
if (b < 0) a *= -1, b *= -1;
if (a < 0) return a / b;
return (a + b - 1) / b;
}
long long floor(long long a, long long b) { return -cc(-a, -b); }
long long asdf(long long b, long long e, long long m) {
long long t = 0;
for (; e; e >>= 1, (b <<= 1) %= m)
if (e & 1) (t += b) %= m;
return t;
}
long long power(long long a, long long n, long long mod) {
return (n == 0
? 1
: (power(a * a % mod, n / 2, mod)) * (n % 2 == 1 ? a : 1) % mod);
}
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) scanf("%I64d %I64d", &b[i], &a[i]);
start();
for (int i = 0; i < cpr; i++)
aa[i] = get(a[n - 1], i), bb[i] = get(b[n - 1], i);
long long res = -1;
for (int i = 0; i < n - 1; i++) {
bool test = 0;
simpen cewe;
for (int j = 0; j < cpr; j++) {
long long a0 = aa[j], b0 = bb[j];
long long a1 = get(a[i], j), b1 = get(b[i], j);
if (a0 || a1 || b0 != b1) {
if (b0 != b1 && !a0 && !a1) {
printf("-1\n");
return 0;
}
if (a1 || a0) {
if (!test) {
cewe.a = a0;
cewe.b = -a1;
cewe.c = b0 - b1;
} else {
long long aaa = a0, bbb = -a1, ccc = b0 - b1;
long long gay = -(cewe.a * bbb - cewe.b * aaa);
long long x = cewe.c * bbb - cewe.b * ccc;
long long y = cewe.a * ccc - cewe.c * aaa;
if (!gay) {
if (x || y) {
printf("-1\n");
return 0;
}
} else {
if (x % gay || y % gay) {
printf("-1\n");
return 0;
} else {
if (x / gay < 0 || y / gay < 0) {
printf("-1\n");
return 0;
}
if (res != -1 && x / gay != res) {
printf("-1\n");
return 0;
}
res = x / gay;
}
}
}
test = true;
}
}
}
if (test) {
p[cpp] = cewe;
cpp++;
}
}
for (int i = 0; i < cpp; i++) {
if (!p[i].b) {
if (p[i].c % p[i].a) {
printf("-1\n");
return 0;
}
if (p[i].c * p[i].a > 0) {
printf("-1\n");
return 0;
}
if (res != -1 && (-p[i].c) / p[i].a != res) {
printf("-1\n");
return 0;
}
res = (-p[i].c) / p[i].a;
}
}
if (res != -1) {
for (int i = 0; i < cpp; i++) {
p[i].c += p[i].a * res;
if (p[i].b) {
if (p[i].c % p[i].b) {
printf("-1\n");
return 0;
}
if (p[i].c * p[i].b > 0) {
printf("-1\n");
return 0;
}
} else if (p[i].c) {
printf("-1\n");
return 0;
}
}
} else {
long long m = 0, mmin = 0, mmax = 9223372036854775807;
for (int i = 0; i < cpp; i++) {
if (!p[i].a) {
if (!p[i].c % p[i].b) {
printf("-1\n");
return 0;
}
if (!p[i].c * p[i].b > 0) {
printf("-1\n");
return 0;
}
} else {
long long x, y;
long long d = dio(p[i].a, p[i].b, x, y);
if (p[i].c % d) {
printf("-1\n");
return 0;
}
x *= (-p[i].c) / d;
momod[m] = abs(p[i].b / d);
valen[m] = x % momod[m];
m++;
if (p[i].b < 0)
mmin = max(mmin, cc(-p[i].c, p[i].a));
else
mmax = min(mmax, floor(-p[i].c, p[i].a));
}
}
if (mmin > mmax) {
printf("-1\n");
return 0;
}
long long A = 0, B = 1;
for (int i = 0; i < m; i++) {
long long x, y;
long long d = dio(B, momod[i], x, y);
long long ans = A % d;
if ((valen[i] - ans) % d) {
printf("-1\n");
return 0;
}
B /= d;
momod[i] /= d;
(A -= ans) /= d;
(valen[i] -= ans) /= d;
long long bbb = B * momod[i];
A = (A + B) % B;
valen[i] = (valen[i] + momod[i]) % momod[i];
A = (asdf(asdf(x, B, bbb), valen[i], bbb) +
asdf(asdf(y, momod[i], bbb), A, bbb)) %
bbb;
B = bbb * d;
A = (A * d + ans) % B;
}
(A += B) %= B;
res = cc(mmin - A, B) * B + A;
if (res > mmax) {
printf("-1\n");
return 0;
}
}
printf("%I64d\n", power(a[n - 1], res, mod) * b[n - 1] % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> tp;
int n, a, b, s1[5002], ct, mx;
long long s[5002][2], t[5002][2], q[3][3];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - a / b * y;
return g;
}
int pw(int a, int p) {
int as = 1;
while (p) {
if (p & 1) as = 1ll * as * a % 1000000007;
a = 1ll * a * a % 1000000007;
p >>= 1;
}
return as;
}
bool pw2(int a, int p) {
int as = 1, vl = pw(a, p);
while (p) {
if (p & 1) as = 1ll * as * a;
a = 1ll * a * a;
p >>= 1;
}
return as != vl;
}
void merge() {
int c1 = 0;
for (int i = 1; i <= ct; i++) {
if (s[i][1] == 0 && t[i][1] == 0) {
if (s[i][0] != t[i][0]) {
printf("-1\n");
exit(0);
};
continue;
}
q[++c1][0] = s[i][1], q[c1][1] = -t[i][1], q[c1][2] = -t[i][0] + s[i][0];
long long g = gcd(q[c1][0], q[c1][1]);
if (q[c1][2] % g) {
printf("-1\n");
exit(0);
};
q[c1][0] /= g;
q[c1][1] /= g;
q[c1][2] /= g;
if (q[c1][0] < 0) q[c1][0] *= -1, q[c1][1] *= -1, q[c1][2] *= -1;
if (c1 == 2) {
if (q[1][1] == 0 && q[2][1] == 0) {
if ((q[1][2] % q[1][0]) || (q[2][2] % q[2][0]) ||
(q[1][2] / q[1][0] != q[2][2] / q[2][0])) {
printf("-1\n");
exit(0);
};
long long asx = q[1][2] / q[1][0];
q[1][0] = 1;
q[1][1] = 0;
q[1][2] = asx;
c1--;
continue;
}
if (q[1][0] == 0 && q[2][0] == 0) {
if ((q[1][2] % q[1][1]) || (q[2][2] % q[2][1]) ||
(q[1][2] / q[1][1] != q[2][2] / q[2][1])) {
printf("-1\n");
exit(0);
};
long long asx = q[1][2] / q[1][1];
q[1][0] = 0;
q[1][1] = 1;
q[1][2] = asx;
c1--;
continue;
}
if (q[1][0] == q[2][0] && q[1][1] == q[2][1]) {
if (q[1][2] != q[2][2]) {
printf("-1\n");
exit(0);
};
c1--;
continue;
}
long long g = gcd(q[1][1], q[2][1]), s1 = q[1][1] / g, s2 = q[2][1] / g;
long long asx, asy;
if (q[1][1] == 0) {
if (q[1][2] % q[1][0]) {
printf("-1\n");
exit(0);
};
asx = -q[1][2] / q[1][0];
if ((-q[2][2] - asx * q[2][0]) % q[2][1]) {
printf("-1\n");
exit(0);
};
asy = (-q[2][2] - asx * q[2][0]) / q[2][1];
} else if (q[2][1] == 0) {
if (q[2][2] % q[2][0]) {
printf("-1\n");
exit(0);
};
asx = -q[2][2] / q[2][0];
if ((-q[1][2] - asx * q[1][0]) % q[1][1]) {
printf("-1\n");
exit(0);
};
asy = (-q[1][2] - asx * q[1][0]) / q[1][1];
} else {
q[1][0] *= s2;
q[1][1] *= s2;
q[1][2] *= s2;
q[2][0] *= s1;
q[2][1] *= s1;
q[2][2] *= s1;
if (q[1][0] == q[2][0]) {
if ((q[2][2] - q[1][2]) % (q[1][1] - q[2][1])) {
printf("-1\n");
exit(0);
};
asy = (q[2][2] - q[1][2]) / (q[1][1] - q[2][1]);
if (q[1][0]) {
if ((q[1][2] - asy * q[1][1]) % q[1][0]) {
printf("-1\n");
exit(0);
};
asy = (q[1][2] - asy * q[1][1]) / q[1][0];
}
}
if ((q[2][2] - q[1][2]) % (q[1][0] - q[2][0])) {
printf("-1\n");
exit(0);
};
asx = (q[2][2] - q[1][2]) / (q[1][0] - q[2][0]);
if (q[1][1]) {
if ((-q[1][2] - asx * q[1][0]) % q[1][1]) {
printf("-1\n");
exit(0);
};
asy = (-q[1][2] - asx * q[1][0]) / q[1][1];
} else if (q[2][1]) {
if ((-q[2][2] - asx * q[2][0]) % q[2][1]) {
printf("-1\n");
exit(0);
};
asy = (-q[2][2] - asx * q[2][0]) / q[2][1];
}
}
if (asx < 0 || asy < 0) {
printf("-1\n");
exit(0);
};
for (int j = 1; j <= ct; j++) {
long long s1 = s[j][1] * asx + s[j][0], s2 = t[j][1] * asy + t[j][0];
if (s1 != s2) {
printf("-1\n");
exit(0);
};
s[j][0] = s1;
s[j][1] = 0;
}
return;
}
}
if (!c1) return;
long long x, y, s1;
long long g = exgcd(q[1][0], q[1][1], x, y);
long long f1 = q[1][0], f2 = q[1][1];
int fg1 = f1 > 0 ? 1 : -1, fg2 = f2 > 0 ? 1 : -1;
x *= -q[1][2] * g;
y *= -q[1][2] * g;
if (x < 0) s1 = -x / (f2 * fg2), x += f2 * fg2 * s1, y -= f1 * fg2 * s1;
while (x < 0) x += f2 * fg2, y -= f1 * fg2;
if (y < 0) s1 = -y / (f1 * fg1), y += f1 * fg1 * s1, x -= f2 * fg1 * s1;
while (y < 0) y += f1 * fg1, x -= f2 * fg1;
s1 = min(fg2 * f2 == 0 ? 0 : x / (fg2 * f2),
fg1 * f1 == 0 ? 0 : y / (fg1 * f1));
x -= fg2 * f2 * s1, y -= fg1 * f1 * s1;
while (x >= fg2 * f2 && y >= fg1 * f1) x -= fg2 * f2, y -= fg1 * f1;
if (x < 0) {
printf("-1\n");
exit(0);
};
for (int i = 1; i <= ct; i++)
if (s[i][1] || t[i][1]) {
if (s[i][1])
s[i][0] += s[i][1] * x, s[i][1] *= f2;
else
s[i][0] = t[i][0] + t[i][1] * y;
s[i][1] = t[i][1] * f1;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= ct; j++) t[j][0] = t[j][1] = 0;
scanf("%d%d", &a, &b);
mx = max(mx, a);
for (int j = 2; j <= 4e4; j++)
if (a % j == 0 || b % j == 0) {
if (!tp[j]) tp[j] = ++ct, s1[ct] = j;
int s11 = 0, s21 = 0;
while (a % j == 0) a /= j, s11++;
while (b % j == 0) b /= j, s21++;
t[tp[j]][0] = s11, t[tp[j]][1] = s21;
}
if (a > 1 && b > 1 && a == b) {
if (!tp[a]) tp[a] = ++ct, s1[ct] = a;
t[tp[a]][0] = 1, t[tp[a]][1] = 1;
} else if (a > 1) {
if (!tp[a]) tp[a] = ++ct, s1[ct] = a;
t[tp[a]][0] = 1, t[tp[a]][1] = 0;
} else if (b > 1) {
if (!tp[b]) tp[b] = ++ct, s1[ct] = b;
t[tp[b]][0] = 0, t[tp[b]][1] = 1;
}
if (i == 1)
swap(s, t);
else
merge();
}
int as = 1, fg = 0;
for (int i = 1; i <= ct; i++)
fg |= (1ll * as * pw(s1[i], s[i][0] % (1000000007 - 1)) % 1000000007 !=
1ll * as * pw(s1[i], s[i][0] % (1000000007 - 1))) |
(s[i][0] >= 1000000007) | pw2(s1[i], s[i][0] % (1000000007 - 1)),
as = 1ll * as * pw(s1[i], s[i][0] % (1000000007 - 1)) % 1000000007;
while (as < mx && !fg) {
for (int i = 1; i <= ct; i++)
fg |= (1ll * as * pw(s1[i], s[i][1] % (1000000007 - 1)) % 1000000007 !=
1ll * as * pw(s1[i], s[i][1] % (1000000007 - 1))),
as = 1ll * as * pw(s1[i], s[i][1] % (1000000007 - 1)) % 1000000007;
}
printf("%d\n", as);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 7, M = 1e3 + 7, p = 1e9 + 7;
bool tag, res;
int n, a[N], b[N], p1[N];
map<int, int> q;
long long x, y;
struct node {
long long g[M];
} f1[N], f2[N], ans1, ans2;
inline long long pows(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % p;
a = (a * a) % p, b = b >> 1;
}
return ans;
}
inline int read() {
int num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline void spilt(int u) {
for (int i = 2; i <= sqrt(u); i++) {
if (u % i == 0) {
if (!q[i]) q[i] = 1, p1[++p1[0]] = i;
while (u % i == 0) u /= i;
}
}
if (u > 1) {
if (!q[u]) q[u] = 1, p1[++p1[0]] = u;
}
}
inline node getans(int u) {
node w = f1[0];
for (int i = 1; i <= p1[0]; i++)
while (u % p1[i] == 0) w.g[i]++, u /= p1[i];
return w;
}
inline long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
inline void exgcd(long long a, long long b, long long c) {
if (b == 0) {
x = c / a, y = 0;
return;
}
exgcd(b, a % b, c);
long long f1 = -y, f2 = -x - (a / b) * y;
x = f1, y = f2;
}
inline void merge(node a, node b) {
long long f1 = -1, f2 = -1;
res = 0;
long long wn = -1;
for (int i = 1; i <= p1[0]; i++) {
if (!ans2.g[i] && !b.g[i]) {
if (ans1.g[i] != a.g[i]) {
tag = 1;
return;
}
continue;
}
if (!ans2.g[i]) {
if (ans1.g[i] - a.g[i] < 0) {
tag = 1;
return;
}
f2 = (ans1.g[i] - a.g[i]) / b.g[i];
}
if (!b.g[i]) {
if (a.g[i] - ans1.g[i] < 0) {
tag = 1;
return;
}
f1 = (a.g[i] - ans1.g[i]) / ans2.g[i];
}
}
if (f1 != -1 || f2 != -1) {
for (int i = 1; i <= p1[0]; i++) {
if (ans2.g[i] && f2 != -1) {
long long w = a.g[i] + f2 * b.g[i];
f1 = (w - ans1.g[i]) / ans2.g[i];
}
if (b.g[i] && f1 != -1) {
long long w = ans1.g[i] + f1 * ans2.g[i];
f2 = (w - a.g[i]) / b.g[i];
}
}
for (int i = 1; i <= p1[0]; i++)
if (ans1.g[i] + ans2.g[i] * f1 != a.g[i] + b.g[i] * f2) {
tag = 1;
return;
}
for (int i = 1; i <= p1[0]; i++)
ans1.g[i] = ans1.g[i] + f1 * ans2.g[i], ans2.g[i] = 0;
return;
}
long long k1 = -1, b1 = -1, k2 = -1, b2 = -1;
bool flg = 0;
for (int i = 1; i <= p1[0]; i++) {
if (!ans2.g[i] && !b.g[i]) continue;
long long fa, fb, fc, fd;
if (k1 == -1 && b1 == -1 && k2 == -1 && b2 == -1)
fa = ans2.g[i], fb = b.g[i], fc = a.g[i] - ans1.g[i], fd = gcd(fa, fb);
else
fa = k1 * ans2.g[i], fb = k2 * b.g[i],
fc = (b2 * b.g[i] + a.g[i]) - (b1 * ans2.g[i] + ans1.g[i]),
fd = gcd(fa, fb);
if (fc % fd) {
tag = 1;
return;
}
fa /= fd, fb /= fd, fc /= fd;
exgcd(fa, fb, fc);
if (x < 0 || y < 0) {
long long z = max(-x / fb, -y / fa);
x += fb * z, y += fa * z;
}
if (x >= fb && y >= fa) {
long long z = min((x - fb) / fb, (y - fa) / fa);
x -= fb * z, y -= fa * z;
}
while (x < 0 || y < 0) x += fb, y += fa;
while (x >= fb && y >= fa) x -= fb, y -= fa;
if (k1 == -1 && b1 == -1 && k2 == -1 && b2 == -1) {
b1 = x, k1 = fb, b2 = y, k2 = fa;
continue;
}
if (x != y || fa != fb) {
if (x == y) {
flg = 1, wn = b1 + k1 * x;
break;
}
if (fa == fb) {
tag = 1;
return;
}
if ((x - y) % (fa - fb) != 0) {
tag = 1;
return;
}
wn = (x - y) / (fa - fb);
if (wn < 0) {
tag = 1;
return;
}
wn = wn * fb + x, wn = wn * k1 + b1;
break;
}
b1 = b1 + k1 * x, k1 = k1 * fa;
b2 = b2 + k2 * x, k2 = k2 * fa;
}
if (wn >= 0) {
for (int i = 1; i <= p1[0]; i++) {
ans1.g[i] = ans1.g[i] + ans2.g[i] * wn, ans2.g[i] = 0;
}
return;
}
for (int i = 1; i <= p1[0]; i++) {
ans1.g[i] = ans1.g[i] + ans2.g[i] * b1;
ans2.g[i] = ans2.g[i] * k1;
}
}
int main() {
n = read(), tag = 0;
for (int i = 1; i <= n; i++)
a[i] = read(), b[i] = read(), spilt(a[i]), spilt(b[i]);
for (int i = 1; i <= n; i++) f1[i] = getans(a[i]), f2[i] = getans(b[i]);
ans1 = f1[1], ans2 = f2[1];
for (int i = 2; i <= n; i++) {
merge(f1[i], f2[i]);
if (tag) {
puts("-1");
return 0;
}
merge(f1[i], f2[i]);
}
int opt = 1;
for (int i = 1; i <= p1[0]; i++)
opt = opt * pows(p1[i], ans1.g[i] % (p - 1)) % p;
cout << opt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max_N(105);
int N, _A[Max_N], _B[Max_N];
map<int, long long int> A[Max_N], B[Max_N];
long long int limit;
long long int gcd(long long int a, long long int b) {
return b == 0LL ? a : gcd(b, a % b);
}
inline long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
void GG() {
printf("-1");
exit(0);
}
void calc(int n, map<int, long long int> &S) {
for (int p = 2, e; p * p <= n; ++p)
if (n % p == 0) {
e = 0;
while (n % p == 0) n /= p, ++e;
S[p] = e;
}
if (n > 1) S[n] = 1;
}
set<int> S;
void merge(int a, int b) {
S.clear();
for (map<int, long long int>::iterator it = A[a].begin(); it != A[a].end();
++it)
S.insert(it->first);
for (map<int, long long int>::iterator it = B[a].begin(); it != B[a].end();
++it)
S.insert(it->first);
for (map<int, long long int>::iterator it = A[b].begin(); it != A[b].end();
++it)
S.insert(it->first);
for (map<int, long long int>::iterator it = B[b].begin(); it != B[b].end();
++it)
S.insert(it->first);
}
namespace PrintAns {
const int MOD(1000000000 + 7);
constexpr int Mult(int a, int b) { return a * 1LL * b % MOD; }
int power(int a, long long int n) {
int Ret(1);
while (n) {
if (n & 1LL) Ret = Mult(Ret, a);
a = Mult(a, a), n >>= 1LL;
}
return Ret;
}
void printAns(long long int x) { printf("%d", Mult(_A[1], power(_B[1], x))); }
} // namespace PrintAns
void print(long long int x1) {
if (x1 < 0LL) GG();
for (int i = 2; i <= N; ++i) {
merge(1, i);
set<long long int> qwq;
for (set<int>::iterator it = S.begin(); it != S.end(); ++it) {
int p = *it;
long long int xi = B[1][p] * x1 + A[1][p] - A[i][p];
if (B[i][p] == 0LL)
if (xi == 0LL)
continue;
else
GG();
if (xi < 0LL) GG();
if (xi % B[i][p]) GG();
qwq.insert(xi / B[i][p]);
}
if (qwq.size() > 1) GG();
}
PrintAns::printAns(x1), exit(0);
}
constexpr long long int Abs(long long int x) { return x >= 0LL ? x : -x; }
pair<long long int, long long int> get(pair<long long int, long long int> a) {
if (a.second < 0LL) a.second = -a.second, a.first = -a.first;
if (a.first == 0LL)
a.second = 1LL;
else {
long long int d = gcd(Abs(a.first), Abs(a.second));
a.first /= d, a.second /= d;
}
return a;
}
inline pair<long long int, long long int> operator-(
const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
long long int l = lcm(a.second, b.second);
return get(make_pair(a.first * (l / a.second) - b.first * (l / b.second), l));
}
inline pair<long long int, long long int> operator/(
const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return get(make_pair(a.first * b.second, a.second * b.first));
}
void exgcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (b == 0LL)
x = 1LL, y = 0LL;
else
exgcd(b, a % b, y, x), y -= x * (a / b);
}
inline long long int inverse(long long int a, long long int MOD) {
long long int invx, invy;
exgcd(a, MOD, invx, invy);
return (invx % MOD + MOD) % MOD;
}
inline long long int Add(long long int a, long long int b, long long int MOD) {
return a + b >= MOD ? a + b - MOD : a + b;
}
inline long long int Mult(long long int a, long long int b, long long int MOD) {
return a * b % MOD;
}
long long int A1, MOD1;
inline void merge(long long int A2, long long int MOD2) {
long long int d = gcd(MOD1, MOD2), sub = (((A2 - A1) % MOD2 + MOD2) % MOD2);
if (sub % d) GG();
long long int k1, k2;
exgcd(MOD1, MOD2, k1, k2), k1 *= sub / d;
A1 = k1 * MOD1 + A1, MOD1 = lcm(MOD1, MOD2), A1 = (A1 % MOD1 + MOD1) % MOD1;
}
inline void insert(long long int k, long long int A2, long long int MOD2) {
k = (k % MOD2 + MOD2) % MOD2;
A2 = (A2 % MOD2 + MOD2) % MOD2;
if (k == 0LL)
if (A2 == 0LL)
return;
else
GG();
long long int d = gcd(k, MOD2);
if (A2 % d) GG();
k /= d, A2 /= d, MOD2 /= d;
A2 = Mult(A2, inverse(k, MOD2), MOD2);
merge(A2, MOD2);
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i)
scanf("%d%d", _A + i, _B + i), calc(_A[i], A[i]), calc(_B[i], B[i]);
A1 = 0LL, MOD1 = 1LL;
for (int i = 2; i <= N; ++i) {
merge(1, i);
map<pair<long long int, long long int>, pair<long long int, long long int> >
rec;
for (set<int>::iterator it = S.begin(); it != S.end(); ++it) {
int p = *it;
if (B[i][p] == 0LL)
if (B[1][p] == 0LL) {
if (A[1][p] != A[i][p]) GG();
} else
print((A[i][p] - A[1][p]) / B[1][p]);
else {
rec[get(make_pair(B[1][p], B[i][p]))] =
get(make_pair(A[1][p] - A[i][p], B[i][p]));
if (A[i][p] - A[1][p] > 0LL) {
if (B[1][p] == 0LL) GG();
limit = max(limit, (A[i][p] - A[1][p]) / B[1][p]);
while (B[1][p] * limit < A[i][p] - A[1][p]) ++limit;
}
insert(B[1][p], A[i][p] - A[1][p], B[i][p]);
}
}
if (rec.size() >= 2) {
pair<long long int, long long int> k1 = rec.begin()->first,
b1 = rec.begin()->second;
pair<long long int, long long int> k2 = rec.rbegin()->first,
b2 = rec.rbegin()->second;
pair<long long int, long long int> x = (b2 - b1) / (k1 - k2);
if (x.second != 1LL) GG();
print(x.first);
}
}
long long int k = (limit - A1) / MOD1;
k = max(k, 0LL);
while (k * MOD1 + A1 < limit) ++k;
print(k * MOD1 + A1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void O() {
puts("-1");
exit(0);
}
long long exgcd(long long a, long long b, long long& x, long long& y) {
if (!b)
return x = 1, y = 0, a;
else {
long long d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
}
struct seq {
long long a, b;
seq(long long _a = 1, long long _b = 0) : a(_a), b(_b) {}
inline seq operator&(const seq& rhs) {
if (!a && !rhs.a) {
if (b != rhs.b) O();
return seq(1, 0);
}
if (!a) {
if (b < rhs.b || (b - rhs.b) % rhs.a) O();
return seq(0, (b - rhs.b) / rhs.a);
}
if (!rhs.a) {
if (rhs.b < b || (rhs.b - b) % a) O();
return seq(1, 0);
}
long long c = rhs.a, d = rhs.b, v = ((b - d) % a + a) % a, x, y, dd, aa = a,
t2;
dd = exgcd(a, c, x, y);
if (v % dd) O();
c /= dd;
v /= dd;
aa /= dd;
t2 = (y * v % aa + aa) % aa;
if (c * t2 + d - b < 0) t2 += (b - d - c * t2 + c * aa - 1) / (c * aa) * aa;
return seq(aa, t2);
}
inline seq operator&&(const seq& rhs) {
long long c = rhs.a, d = rhs.b;
if (a != c) {
if ((d - b) % (a - c)) O();
return seq(0, (d - b) / (a - c) * a + b);
} else {
if (!a) {
if (b != d) O();
return rhs;
}
if ((b - d) % a) O();
return seq(a, max(b, d));
}
}
inline void operator*=(const seq& rhs) {
b += rhs.b * a;
a *= rhs.a;
}
};
const int M = 35e3, mo = 1e9 + 7;
inline int poww(int x, long long y) {
int ans = 1;
for (; y; y >>= 1, x = 1ll * x * x % mo)
if (y & 1) ans = 1ll * ans * x % mo;
return ans;
}
bool b[M];
int pr[M / 5], pcnt;
int n, i, j, ass = 1;
unordered_map<int, seq> ans;
inline unordered_map<int, seq> geth() {
int a, b;
scanf("%d%d", &b, &a);
unordered_map<int, seq> ret;
for (j = 1; j <= pcnt; ++j)
if (a % pr[j] == 0 || b % pr[j] == 0) {
int ca = 0, cb = 0;
for (; a % pr[j] == 0; a /= pr[j], ++ca)
;
for (; b % pr[j] == 0; b /= pr[j], ++cb)
;
ret[pr[j]] = seq(ca, cb);
}
if (a > 1 && b > 1) {
if (a == b)
ret[a] = seq(1, 1);
else
ret[a] = seq(1, 0), ret[b] = seq(0, 1);
}
if (a > 1 && b == 1) ret[a] = seq(1, 0);
if (a == 1 && b > 1) ret[b] = seq(0, 1);
return ret;
}
long long calc(seq a, seq b, seq c, seq d) {
long long A = (b.a * a.b - a.a * b.b) - (b.a * c.b - a.a * d.b),
B = (b.a * c.a - a.a * d.a), x2;
if (A && !B) O();
if (B && A % B) O();
if (!A && !B) return -1;
if (A / B < 0) O();
return A / B;
}
inline void work(seq a, seq b, seq c, seq d, seq& e, seq& f) {
long long x1 = calc(c, d, a, b), x2 = calc(a, b, c, d);
if (x1 == -1) return;
e = seq(0, c.a * x2 + c.b);
f = seq(0, d.a * x2 + d.b);
}
inline void jiao(unordered_map<int, seq>& a, unordered_map<int, seq> b) {
seq aa, bb, na, nb;
bool fl = 0;
for (auto u : b) {
if (!a.count(u.first)) a[u.first] = seq(0, 0);
na = a[u.first];
nb = u.second;
long long x1, x2;
if (!fl)
fl = 1, aa = nb & na, bb = na & nb;
else
work(aa, bb, nb & na, na & nb, aa, bb);
}
for (auto& u : a) u.second *= aa;
}
int main() {
for (i = 2; i < M; ++i)
if (!b[i])
for (pr[++pcnt] = j = i; j += i, j < M; b[j] = 1)
;
scanf("%d", &n);
ans = geth();
for (i = 2; i <= n; ++i) jiao(ans, geth());
for (auto u : ans) ass = 1ll * ass * poww(u.first, u.second.b) % mo;
printf("%d\n", ass);
return 0;
}
|
#include <bits/stdc++.h>
int read() {
int r = 0, t = 1, c = getchar();
while (c < '0' || c > '9') {
t = c == '-' ? -1 : 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
r = (r << 3) + (r << 1) + (c ^ 48);
c = getchar();
}
return r * t;
}
const long long mod = 1000000007, inf = 1ll << 60, N = 110;
long long power(long long a, long long b, long long p) {
long long r = 1;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) r = r * a % p;
return r;
}
long long calc(long long a, int b) {
long long s = (long long)(pow(a, 1. / b) + 0.5);
return power(s, b, inf) == a ? s : 0;
}
long long n, a[N], b[N], c[N], d[N];
long long v[N];
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long split(long long a, long long p) {
for (int i = (1), end_i = (p); i <= end_i; i++) {
long long g;
if (v[i] != 1 && (g = gcd(a, v[i])) != 1) {
v[i] /= g;
a /= g;
}
if (a == 1) return 1;
}
return 0;
}
long long checkv(long long p) {
for (int i = (1), end_i = (p); i <= end_i; i++)
if (v[i] != 1) return 0;
return 1;
}
long long check(long long a, long long b, long long p, long long A,
long long B) {
p++;
v[1] = a;
for (int i = (2), end_i = (p); i <= end_i; i++) v[i] = b;
if (!split(A, p)) return 0;
if (!checkv(p) && B == 1) return 0;
while (!checkv(p))
if (!split(B, p)) return 0;
return 1;
}
long long check(long long A, long long B, long long p) {
for (int i = (1), end_i = (n); i <= end_i; i++)
if (!check(A, B, p, a[i], b[i])) return 0;
return 1;
}
int main() {
n = read();
for (int i = (1), end_i = (n); i <= end_i; i++) {
a[i] = read();
b[i] = read();
}
int flag = 0;
for (int i = (1), end_i = (n); i <= end_i; i++)
if (b[i] == 1) flag = 1;
if (flag) {
for (int i = (1), end_i = (n); i <= end_i; i++)
if (b[i] == 1) {
if (check(a[i], b[i], 0))
printf("%I64d\n", a[i]);
else
printf("-1\n");
return 0;
}
}
for (int i = (1), end_i = (n); i <= end_i; i++) {
for (int j = (29), end_j = (0); j >= end_j; j--)
if (calc(b[i], j)) {
d[i] = j;
b[i] = calc(b[i], j);
break;
}
while (a[i] % b[i] == 0) {
a[i] /= b[i];
c[i]++;
}
}
for (int i = (2), end_i = (n); i <= end_i; i++)
if (b[i] != b[1]) {
for (int j = (1), end_j = (n); j <= end_j; j++) {
a[j] = a[j] * power(b[j], c[j], inf);
b[j] = power(b[j], d[j], inf);
}
for (int j = (0), end_j = (100); j <= end_j; j++)
if (check(a[1], b[1], j, a[i], b[i])) {
if (check(a[1], b[1], j))
printf("%I64d\n", power(b[1], j, mod) * a[1] % mod);
else
printf("-1\n");
return 0;
}
printf("-1\n");
return 0;
}
for (int i = (2), end_i = (n); i <= end_i; i++)
if (a[i] != a[1]) {
printf("-1\n");
return 0;
}
long long ans = c[1], Ans = d[1];
for (int i = (2), end_i = (n); i <= end_i; i++) {
int flag = 0;
for (int j = (0), end_j = (1000); j <= end_j; j++)
if (ans + Ans * j >= c[i] && (ans + Ans * j - c[i]) % d[i] == 0) {
ans += Ans * j;
flag = 1;
break;
}
if (!flag) {
printf("-1\n");
return 0;
}
Ans = Ans * d[i] / gcd(Ans, d[i]);
}
printf("%I64d\n", a[1] * power(b[1], ans, mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
inline long long Abs(long long x) { return x > 0 ? x : -x; }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
struct item {
int p;
long long k;
item(int p = 0, long long k = 0) : p(p), k(k) {}
};
struct Num {
item p[810];
int num;
void init(int x) {
for (int i = 2; i * (long long)i <= x; ++i)
if (x % i == 0) {
int c = 0;
while (x % i == 0) x /= i, c++;
p[num++] = item(i, c);
}
if (x > 1) p[num++] = item(x, 1);
}
item query(int x) {
for (int i = 0; i < num; ++i)
if (p[i].p == x) return p[i];
return item(x, 0);
}
} A[110], B[110];
int n;
void FAIL() {
puts("-1");
exit(0);
}
item A1[3210], B1[3210], A2[3210], B2[3210];
int pri[3210], num;
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long g = exgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
void Inter(long long A, long long B, long long C, long long a, long long b,
long long c, long long &x1, long long &x2) {
while (a) {
long long t = A / a;
A -= t * a, B -= t * b, C -= t * c;
swap(A, a), swap(B, b), swap(C, c);
}
if (c % b) FAIL();
x2 = -c / b;
if ((C + B * x2) % A) FAIL();
x1 = (-C - B * x2) / A;
}
void UN(Num &a1, Num &b1, Num &a2, Num &b2) {
num = 0;
for (int i = 0; i < a1.num; ++i) pri[num++] = a1.p[i].p;
for (int i = 0; i < a2.num; ++i) pri[num++] = a2.p[i].p;
for (int i = 0; i < b1.num; ++i) pri[num++] = b1.p[i].p;
for (int i = 0; i < b2.num; ++i) pri[num++] = b2.p[i].p;
sort(pri, pri + num);
num = unique(pri, pri + num) - pri;
for (int i = 0; i < num; ++i) A1[i] = a1.query(pri[i]);
for (int i = 0; i < num; ++i) A2[i] = a2.query(pri[i]);
for (int i = 0; i < num; ++i) B1[i] = b1.query(pri[i]);
for (int i = 0; i < num; ++i) B2[i] = b2.query(pri[i]);
long long A = 0, B = 0, C = 0;
int flg1 = 0;
long long x1, x2;
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a == 0 && b == 0) {
if (c) FAIL();
continue;
}
long long g = gcd(a, gcd(-b, Abs(c)));
a /= g, b /= g, c /= g;
if (!b) {
if (c % a) FAIL();
if (-c / a < 0) FAIL();
}
if (!A && !B) {
A = a, B = b, C = c;
continue;
}
if (!B) {
if (b) {
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (C / A != c / a) FAIL();
continue;
}
if (A * b == a * B) {
if (c * A == C * a) continue;
FAIL();
}
Inter(A, B, C, a, b, c, x1, x2), flg1 = 1;
break;
}
if (flg1) {
for (int i = 0; i < num; ++i) {
long long a = B1[i].k, b = -B2[i].k, c = A1[i].k - A2[i].k;
if (a * x1 + b * x2 + c) FAIL();
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = 0;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
return;
}
long long g = exgcd(A, B, x1, x2);
if (C % g) FAIL();
x1 *= -C / g, x2 *= -C / g;
long long tx = Abs(-B / g), ty = Abs(A / g);
if (C > 0 || !ty) {
x1 = (x1 % tx + tx) % tx;
if (B)
x2 = -(A * x1 + C) / B;
else
x2 = 0;
} else {
x2 = (x2 % ty + ty) % ty;
if (A)
x1 = (-B * x2 - C) / A;
else
x1 = 0;
}
for (int i = 0; i < num; ++i) {
A1[i].k = A1[i].k + B1[i].k * x1;
B1[i].k = tx * B1[i].k;
}
for (int i = 0; i < num; ++i) a1.p[i] = A1[i], b1.p[i] = B1[i];
a1.num = b1.num = num;
}
const int mod = 1e9 + 7;
int Pow(int x, long long y) {
int res = 1;
for (y %= (mod - 1); y; x = x * (long long)x % mod, y >>= 1)
if (y & 1) res = res * (long long)x % mod;
return res;
}
int main() {
rd(n);
for (int i = 1, a, b; i <= n; ++i) rd(a), rd(b), A[i].init(a), B[i].init(b);
for (int i = 2; i <= n; ++i) UN(A[1], B[1], A[i], B[i]);
long long ans = 1;
for (int i = 0; i < A[1].num; ++i)
ans = ans * (long long)Pow(A[1].p[i].p, A[1].p[i].k) % mod;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long Pow(long long a, long long k) {
long long ret = 1;
while (k) {
if (k & 1) ret = ret * a % 1000000007;
a = a * a % 1000000007;
k >>= 1;
}
return ret;
}
void Exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
Exgcd(b, a % b, y, x);
y -= (a / b) * x;
}
long long Inv(long long x, long long m) {
long long t1, t2;
Exgcd(x, m, t1, t2);
return (t1 % m + m) % m;
}
map<int, int> S;
int P[2005], cnt;
bool vis[2005];
int a[105][2005], b[105][2005];
bool Checkans(int n, int x, long long d) {
int ans = 1;
for (int i = 1; i <= cnt; i++) {
long long v = a[x][i] + b[x][i] * d;
for (int j = 1; j <= n; j++)
if (b[j][i]) {
if (v < a[j][i] || (v - a[j][i]) % b[j][i] != 0) return 0;
} else if (a[j][i] != v)
return 0;
ans = ans * Pow(P[i], v) % 1000000007;
}
printf("%d\n", ans);
return 1;
}
int Check(int n) {
for (int i = 1; i <= cnt; i++) {
int id = 0;
for (int j = 1; j <= n; j++)
if (!b[j][i]) id = j;
if (!id) continue;
vis[i] = 1;
for (int j = 1; j <= n; j++)
if (b[j][i]) {
int v = a[id][i] - a[j][i];
if (v % b[j][i] != 0) return 0;
v /= b[j][i];
if (v < 0) return 0;
if (Checkans(n, j, v)) return 2;
return 0;
} else if (a[j][i] != a[id][i])
return 0;
}
int id = 1;
while (id <= cnt && vis[id]) id++;
if (id > cnt)
if (Checkans(n, 1, 0)) return 2;
for (int i = id + 1; i <= cnt; i++)
if (!vis[i]) {
for (int j = 2; j <= n; j++) {
int u = a[j][id] - a[1][id], v = a[j][i] - a[1][i];
if (b[1][id] * b[j][i] != b[1][i] * b[j][id]) {
int t1 = b[1][id] * b[j][i] - b[1][i] * b[j][id];
int t2 = u * b[j][i] - v * b[j][id];
if (t2 % t1) return 0;
t2 /= t1;
if (t2 < 0) return 0;
if (Checkans(n, 1, t2)) return 2;
} else if (b[1][id] * v != b[1][i] * u)
return 0;
}
}
return 1;
}
bool Solve(int n) {
int id = 1;
while (id <= cnt && vis[id]) id++;
long long s = a[1][id] % b[1][id], w = b[1][id];
for (int i = 2; i <= n; i++) {
long long u = a[i][id] % b[i][id], v = b[i][id];
long long d = gcd(w, v);
if ((u - s) % d) return 0;
long long p = w / d, q = v / d, r = (u - s) / d;
long long x = (Inv(p, q) * r % q + q) % q;
s = w * x + s;
w = lcm(w, v);
}
for (int i = 1; i <= n; i++)
while (s < a[i][id]) s += w;
return Checkans(n, 1, (s - a[1][id]) / b[1][id]);
}
void Getfact(int x, int *A) {
int t = x;
for (int i = 2; i * i <= t; i++)
if (x % i == 0) {
if (!S.count(i)) {
S[i] = ++cnt;
P[cnt] = i;
}
int u = S[i];
while (x % i == 0) {
A[u]++;
x /= i;
}
}
if (x > 1) {
if (!S.count(x)) {
S[x] = ++cnt;
P[cnt] = x;
}
int u = S[x];
A[u] = 1;
}
}
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
Getfact(x, a[i]);
Getfact(y, b[i]);
}
int x = Check(n);
if (!x) {
puts("-1");
return 0;
}
if (x == 2) return 0;
if (!Solve(n)) {
puts("-1");
return 0;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.