text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
vector<int> sieve(int n) {
int *arr = new int[n + 1]();
vector<int> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact) {
long long val1 = fact[n];
long long val2 = mminvprime(fact[r], m);
long long val3 = mminvprime(fact[n - r], m);
return ((val1 * val2) % m * val3) % m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long x;
cin >> x;
long long val = x;
for (long long i = 2; i <= sqrt(x); i++)
if (x % i == 0)
if (x / gcd(i, x / i) == x) val = min(val, max(i, x / i));
cout << x / val << " " << val << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a % b == 0) return (b);
return (gcd(b, a % b));
}
int main() {
long long int x, a = 1, b = 1, n1, n2;
cin >> x;
for (int i = 1; i <= (int)floor(sqrt(x)); i++) {
if (x % i != 0) continue;
n1 = i, n2 = x / i;
if (((n1 * n2) / gcd(n2, n1)) == x) a = n1, b = n2;
}
cout << a << " " << b << endl;
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; }
int main() {
ios_base::sync_with_stdio(false);
long long x;
cin >> x;
vector<long long> v;
long long u = sqrt(x);
for (long long i = 1; i * i <= x; i++) {
if (x % i == 0) {
v.push_back(i);
long long y = x / i;
if (y > u) v.push_back(y);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
for (int j = i; j >= 0; j--) {
if (lcm(v[i], v[j]) == x) {
cout << v[i] << " " << v[j] << endl;
return 0;
}
}
}
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 * b / gcd(a, b); }
void solve() {
long long n, mn = (long long)1e7;
cin >> n;
for (long long i = 1; i < sqrt(n) + 1; ++i)
if (n % i == 0 && lcm(i, n / i) == n) mn = min(i, n / i);
cout << mn << " " << n / mn;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int check_mod(T a, T b) {
return (a % b) ? 1 : 0;
}
template <class T>
void maxi(T &a, T b) {
a = max(a, b);
return;
}
template <class T>
void mini(T &a, T b) {
a = min(a, b);
return;
}
bool is_prime(int a) {
if (a == 2) return true;
if (!(a & 1) || a == 1) return false;
for (int i = 3; i * i <= a; i += 2)
if (!(a % i)) return false;
return true;
}
bool is_prime(long long a) {
if (a == 2) return true;
if (!(a & 1) || a == 1) return false;
for (long long i = 3; i * i <= a; i += 2)
if (!(a % i)) return false;
return true;
}
bool is_palindrome(string s) {
int len = (int)s.length();
int mid = len >> 1;
for (int i = 0; i < mid; i++)
if (s[i] != s[len - i - 1]) return false;
return true;
}
int gcd(int a, int b) {
while (b) {
int mod = a % b;
a = b;
b = mod;
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int binpow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res *= a;
a *= a;
b >>= 1;
}
return res;
}
int binpow(int a, int b, int MODULO) {
int res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= MODULO;
}
a *= a;
a %= MODULO;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
long long mod = a % b;
a = b;
b = mod;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res *= a;
a *= a;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b, long long MODULO) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
res %= MODULO;
}
a *= a;
a %= MODULO;
b >>= 1;
}
return res;
}
string binary(int N) {
if (!N) return "0";
string bin = "";
while (N) {
bin += '0' + (N & 1);
N >>= 1;
}
reverse((bin).begin(), (bin).end());
return bin;
}
string binary(long long N) {
if (!N) return "0";
string bin = "";
while (N) {
bin += '0' + (N & 1);
N >>= 1;
}
reverse((bin).begin(), (bin).end());
return bin;
}
const int INF = 2147483547;
const int MODULO = 1000000007;
const int _MODULO = 998244353;
const long long INF64 = 9223372036854775707;
const long long MODULO64 = 1000000007;
const long long _MODULO64 = 998244353;
const double epsilon = 10e-6;
const double PI = acos(-1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x;
cin >> x;
pair<long long, long long> ans = {INF64, INF64};
for (long long a = 1; a * a <= x; ++a) {
long long b = x / a;
if (a * b != x) continue;
if (lcm(a, b) != x) continue;
if (b < ans.second) ans = make_pair(a, b);
}
cout << ans.first << ' ' << ans.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long x, b;
cin >> x;
long long t = sqrt(x);
for (long long a = t; a >= 1; a--) {
if (x % a) continue;
b = x / a;
if (gcd(a, b) == 1) {
cout << a << " " << b << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long t = gcd(a, b);
return (a * b) / t;
}
int main() {
long long x, ma = 0, t;
cin >> x;
long long a, b, temp;
for (long long i = 1; i * i <= x; i++) {
if (x % i == 0) {
a = i;
b = x / i;
temp = lcm(a, b);
if (temp == x) {
ma = max(a, ma);
}
}
}
printf("%lld %lld\n", ma, x / ma);
}
|
#include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
int main() {
long long n, a, b, c;
scanf("%lld", &n);
for (long long i = 1; i * i <= n; i++)
if (n % i == 0 && gcd(i, n / i) == 1) {
a = i;
b = n / i;
}
printf("%lld %lld\n", a, b);
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long int gcd(unsigned long long int a, unsigned long long int b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
unsigned long long int lcm(unsigned long long int a, unsigned long long int b) {
unsigned long long int x;
x = (a * b) / gcd(a, b);
return x;
}
int main() {
unsigned long long int n, x, y;
cin >> n;
unsigned long long int i, a = 9999999999999;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (max(i, n / i) <= a && lcm(i, n / i) == n) {
a = max(i, n / i);
x = min(i, n / i);
y = n / x;
}
}
}
cout << x << " " << y;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = 3.14159265358979323846;
using namespace std;
long long fastexp(long long a, long long b) {
long long answer = 1;
long long temp = a;
while (b > 0) {
if (b & 1) answer *= (temp);
temp *= temp;
b >>= 1;
}
return answer;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x;
cin >> x;
;
long long answer = x;
long long a = 1, b = x;
for (long long i = 2; i * i <= (x); i++) {
if (x % i == 0) {
long long q = (x / i);
if (gcd(q, i) == 1) {
answer = min(answer, max(q, i));
a = i;
b = q;
}
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 1) return 1;
if (a % b) return gcd(b, a % b);
return b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int x, a;
cin >> x;
for (a = sqrt(x); a > 0; --a) {
if (x % a) continue;
if (gcd(a, (x / a)) == 1) {
cout << a << " " << (x / a);
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
gcd(b, a % b);
}
int main() {
long long n;
read(n);
long long x = sqrt(n);
if (x * x == n) x -= 1;
for (long long i = x; i >= 1; i--) {
if (n % i == 0) {
if (gcd(n / i, i) == 1) {
printf("%lld %lld", i, n / i);
return 0;
}
}
}
printf("1 %lld", n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ini() {}
bool check(unsigned long long int n, unsigned long long int m,
unsigned long long int x) {
unsigned long long int res = n * m, temp;
while (m != 0) {
temp = m;
m = n % m;
n = temp;
}
if ((res / n) == x) {
return true;
} else {
return false;
}
}
int main() {
ini();
unsigned long long int x, d;
cin >> x;
d = sqrt(x);
unsigned long long int a = 2, temp, m = x;
while (a <= d) {
if (x % a == 0 && check(x / a, a, x)) {
temp = max(x / a, a);
m = min(m, temp);
}
a++;
}
cout << m << " " << x / m;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<bool> st(1000005);
vector<int> prm;
vector<long long> fct;
vector<pair<long long, long long> > ans;
void sieve() {
int i, j;
for (i = 3; i <= sqrt(1000005); i += 2) {
if (!st[i]) {
for (j = i * i; j <= 1000005; j += i) st[j] = true;
}
}
prm.push_back(2);
for (i = 3; i <= 1000005; i += 2) {
if (!st[i]) prm.push_back(i);
}
}
long long tot;
void solve(int pos, long long mlt) {
if (pos == fct.size() - 1) {
ans.push_back({mlt, tot / mlt});
mlt *= fct[pos];
ans.push_back({mlt, tot / mlt});
} else {
solve(pos + 1, mlt);
solve(pos + 1, mlt * fct[pos]);
}
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
long long p = a.first, q = a.second, r = b.first, s = b.second;
if (p < q) swap(p, q);
if (r < s) swap(r, s);
return p < r;
}
int main() {
long long x;
scanf("%lld", &x);
if (x == 1) {
cout << "1 1\n";
return 0;
}
tot = x;
sieve();
int i, j;
for (i = 0; i < prm.size() && prm[i] * prm[i] <= x; i++) {
if (x % prm[i] == 0) {
long long xx = 1;
while (x % prm[i] == 0) {
x /= prm[i];
xx *= prm[i];
}
fct.push_back(xx);
}
if (x == 1) break;
}
if (x != 1) fct.push_back(x);
solve(0, 1);
sort(ans.begin(), ans.end(), cmp);
cout << ans[0].first << " " << ans[0].second;
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long power(long long a, long long b, long long ret = 1LL) {
while (b--) ret = (ret * a);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, x;
cin >> x;
n = x;
long long ans = 1;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
if (lcm(i, x / i) == x) ans = i;
}
cout << ans << " " << x / ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
long long int x = LLONG_MAX, y = LLONG_MAX;
for (long long int i = 1; i * i <= n; i++) {
if (n % i == 0) {
long long int lcm = ((i) * (n / i)) / (gcd(i, n / i));
if (max(x, y) > max(n / i, i) && lcm == n) x = i, y = n / i;
}
}
cout << x << " " << y << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
cin >> x;
long long m = sqrt(x);
if (sqrt(x) == m && m != 1) --m;
for (long long i = m; i >= 1; --i) {
if (x % i == 0 && lcm(i, x / i) == x) {
cout << i << " " << x / i;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long x;
cin >> x;
long long i = sqrt(x);
if (i * i == x) i--;
if (x == 1)
cout << "1 1";
else
for (; i > 0; i--)
if (x % i == 0 && gcd(i, x / i) == 1) {
cout << i << " " << x / i;
break;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long a;
int gcd(long long a, long long b) {
if (b == 0LL) return a;
a %= b;
return gcd(b, a);
}
void solve(long long a) {
long long x, y, mx, mn;
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0LL) {
x = i;
y = a / i;
if (a == ((x * y) / gcd(x, y))) {
mx = i;
mn = a / i;
}
}
}
cout << mx << " " << mn << "\n";
}
int main() {
scanf("%lld", &a);
solve(a);
return 0;
}
|
#include <bits/stdc++.h>
int gcd(long long n, long long m) {
long long temp;
while (m && n) {
temp = n % m;
n = m;
m = temp;
}
if (n == 1)
return 1;
else
return 0;
}
int main() {
long long n, ans = 0, d, i;
int c = 0;
scanf("%lld", &n);
for (i = 2; 1LL * i * i <= n; i++) {
if (n % i == 0) {
d = n / i;
if (i > ans && i != d && gcd(i, d)) ans = i;
}
if (c >= 2) break;
}
if (ans == 0)
printf("1 %lld", n);
else
printf("%lld %lld", ans, n / ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int prime(long long x) {
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
int gcd(long long a, long long b) {
if (b > a) {
swap(a, b);
}
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test, l = 0, g = 0, a = 0, b = 0;
cin >> test;
long long mini = LONG_LONG_MAX;
if (prime(test)) {
cout << 1 << " " << test << endl;
} else {
for (long long i = 1; i * i <= test; i++) {
if (test % i == 0) {
if (gcd(i, test / i) == 1) {
g = max(i, test / i);
if (g <= mini) {
mini = g;
} else {
break;
}
}
}
}
cout << mini << " " << test / mini << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool RELAXED = false;
template <int, typename T>
struct MINMAX {
T val;
MINMAX(T val) : val(val) {}
};
template <typename T>
MINMAX<1, T> MAX(T val) {
return MINMAX<1, T>(val);
};
template <typename T>
MINMAX<2, T> MIN(T val) {
return MINMAX<2, T>(val);
};
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<1, U> rhs) {
return lhs = (rhs.val > lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T, typename U>
inline T& operator|=(T& lhs, MINMAX<2, U> rhs) {
return lhs = (rhs.val < lhs ? (RELAXED = true, rhs.val)
: (RELAXED = false, lhs));
}
template <typename T>
inline vector<T> readVector(int n) {
vector<T> vec(n);
for (int i = 0; i < int(n); i++) cin >> vec[i];
return vec;
}
template <typename T>
void EXIT(T answer) {
cout << answer << endl;
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
signed long long int x;
cin >> x;
vector<signed long long int> primes;
for (int p = int(2); p <= int(1e6 + 5); p++) {
if (x % p) continue;
signed long long int pp = p;
while (x % (pp * p) == 0) pp *= p;
x /= pp;
primes.push_back(pp);
}
if (x > 1) primes.push_back(x);
signed long long int best = 1e18;
pair<signed long long int, signed long long int> ans;
for (int i = 0; i < int(1 << 20); i++) {
signed long long int a = 1, b = 1;
for (int j = 0; j < int(primes.size()); j++)
if ((1 << j) & i)
a *= primes[j];
else
b *= primes[j];
best |= MIN(max(a, b));
if (RELAXED) ans = {a, b};
}
cout << ans.first << " " << ans.second << endl;
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); }
int main() {
long long x;
cin >> x;
long long ans = x;
for (long long i = 1; i <= sqrt(x); i++) {
if (x % i == 0 && gcd(i, x / i) == 1) {
ans = min(ans, max(i, x / i));
}
}
cout << x / ans << " " << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
const long long INF = 1e18;
long long x, m, n, i, j, k;
pair<long long, long long> a[N];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcd(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> x;
n = 1;
a[1] = make_pair(1, x);
for (i = 2; i * i <= x; i++) {
if (x % i == 0) {
long long j = x / i;
if (lcd(i, j) == x) {
n++;
a[n] = make_pair(i, j);
}
}
}
sort(a + 1, a + 1 + n);
cout << a[n].first << " " << a[n].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int vn;
vector<long long> vl;
void put(int ind, long long val) {
if (ind == vn) {
vl.push_back(val);
return;
}
put(ind + 1, val);
put(ind + 1, val * v[ind]);
}
int main(void) {
long long x;
scanf("%lld", &x);
if (x == 1) {
printf("1 1");
return 0;
}
for (long long i = 2; i * i <= x; i++) {
long long k = 1;
while (x % i == 0) {
k *= i;
x /= i;
}
if (k != 1) {
v.push_back(k);
}
}
if (x != 1) {
v.push_back(x);
}
vn = v.size();
put(0, 1);
int vln = vl.size();
sort(vl.begin(), vl.end());
printf("%lld %lld", vl[vln / 2 - 1], vl[vln / 2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v, vc;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
long long sm = n;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
long long c = 0, d = 1;
while (n % i == 0) {
n /= i;
c++;
d *= i;
}
v.push_back(d);
}
}
if (n > 1) {
v.push_back(n);
}
long long l = v.size();
long long m = (1LL << l);
for (long long i = 0; i < m; i++) {
long long p = 1;
for (long long j = 0; j < l; j++) {
if (i & (1LL << j)) {
p *= v[j];
}
}
vc.push_back(p);
}
long long x1, x2;
long long mx = 1e18;
for (long long u : vc) {
long long p = sm / u;
long long q = max(u, p);
if (mx > q) {
mx = q;
x1 = u, x2 = p;
}
}
if (x1 > x2) swap(x1, x2);
cout << x1 << " " << x2 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int maxn = 2010;
const int inf = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
long long x;
cin >> x;
for (long long i = sqrt(x); i >= 1; i--) {
if (x % i == 0) {
long long tem = x / i;
if (gcd(tem, i) == 1) {
cout << min(tem, i) << ' ' << max(tem, i) << endl;
break;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
constexpr auto INF = 9223372036854775807;
using namespace std;
inline int mex(unordered_set<int> st) {
int m = 0;
while (st.find(m) != st.end()) {
m += 1;
}
return m;
}
inline int calculateGrundy(int n) {
if (n == 1) return 0;
unordered_set<int> mexi;
for (int i = 1; i <= sqrt(n); i += 1) {
if (n % i == 0) {
if (n / i != n) mexi.insert(calculateGrundy(n / i));
mexi.insert(calculateGrundy(i));
}
}
return mex(mexi);
}
inline long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int power(long long int x, long long int y) {
long long int res = 1;
x = x % 1000000007;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
bool check(long long int a) {
long long int count = 0;
while (a % 2 == 0) {
a /= 2;
count += 1;
}
if (count > 1) return false;
bool flag = true;
for (long long int i = 3; i <= sqrt(a); i += 2) {
if (a % i == 0) {
flag = false;
break;
}
}
return flag;
}
long long int sum(long long int n) { return (n * (n + 1)) / 2; }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long int n;
cin >> n;
long long int mini = INF, f = 0, s = 0;
for (long long int i = 1; i <= sqrt(n); i += 1) {
if (n % i == 0) {
if (max(i, n / i) < mini && n == (i * (n / i)) / gcd(i, n / i)) {
mini = max(i, n / i);
f = i;
s = n / i;
}
}
}
cout << f << " " << s;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
const ll INF = 100000000000ll;
const int N = 200005;
const int prime = 31;
const ll mod = 1000000007;
const ld eps = 1e-5;
mt19937_64 strong_random(
chrono::system_clock::now().time_since_epoch().count());
ll n;
void input() { scanf("%lld", &n); }
void solve() {
vector<ll> divisors;
ll nval = n;
ll dv = 2;
while (dv * dv <= n) {
if (n % dv == 0) {
int cc = 0;
divisors.push_back(1);
while (n % dv == 0) {
n /= dv;
divisors.back() *= dv;
}
} else {
dv++;
}
}
if (n != 1) {
divisors.push_back(n);
}
int bitcnt = (int)(divisors).size();
pll ans = {nval, 1};
for (int i = 0; i < (1 << bitcnt); i++) {
ll a = 1, b = 1;
for (int j = 0; j < bitcnt; j++) {
if ((1 << j) & i) {
a *= divisors[j];
} else {
b *= divisors[j];
}
}
if (a < b) swap(a, b);
ans = min(ans, {a, b});
}
cout << ans.second << " " << ans.first << endl;
}
void precalc() {}
int main() {
precalc();
int testcases = 1;
for (int testId = 1; testId <= testcases; testId++) {
input();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long modl = 998244353;
const double pie = 3.1415926535;
unsigned long long power(unsigned long long x, unsigned long long y) {
if (y == 0)
return 1;
else {
if (y % 2 == 0)
return power(x * x, y / 2);
else
return x * power(x * x, (y - 1) / 2);
}
}
long long mod_power(long long x, long long y, long long m) {
long long r = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) r = (r * x) % m;
y = y / 2;
x = (x * x) % m;
}
return r;
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
long long x;
scanf("%lld", &x);
long long a = 0;
for (long long i = 1; i * i <= x; i++) {
if (x % i == 0 && gcd(i, x / i) == 1) {
a = i;
}
}
printf("%lld %lld", a, x / a);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const long long int MOD = 1e9 + 7, INF = 1e18;
long long int dx[8] = {0, -1, 1, 0, 1, -1, 1, -1},
dy[8] = {1, 0, 0, -1, -1, -1, 1, 1};
struct edge {
long long int cost;
long long int u, v;
};
vector<int64_t> divisor(int64_t n) {
vector<int64_t> ret;
for (int64_t i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int N;
int main() {
cin >> N;
auto vec = divisor(N);
pair<long long int, long long int> p = {N, 1};
for (long long int i = (((long long int)(vec).size())) - 1, i_begin_ = (0);
i >= i_begin_; i--) {
if (vec[i] < N / vec[i]) break;
if (gcd(vec[i], N / vec[i]) == 1) {
if (max(p.first, p.second) > vec[i]) {
p = {vec[i], N / vec[i]};
}
}
}
cout << p.first << " " << p.second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
long long t = 1;
while (n % i == 0) t *= i, n /= i;
a.push_back(t);
}
if (n > 1) a.push_back(n);
if (a.size() <= 1) a.push_back(1);
if (a.size() <= 1) a.push_back(1);
sort(a.begin(), a.end());
pair<long long, long long> ans =
pair<long long, long long>(LLONG_MAX, LLONG_MAX);
for (int c = 0; c < (1 << a.size()); c++) {
long long u = 1, v = 1;
for (int i = 0; i <= a.size() - 1; i++)
if ((c >> i) & 1)
u *= a[i];
else
v *= a[i];
if (max(ans.first, ans.second) > max(u, v))
ans = pair<long long, long long>(u, v);
}
cout << ans.first << ' ' << ans.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct primefactorisation {
long long count, pf;
};
void generate(long long curr_idx, long long curr_divisor,
vector<primefactorisation> &arr, vector<long long> &final) {
if (curr_idx == arr.size()) {
final.push_back(curr_divisor);
return;
}
for (long long i = 0; i <= arr[curr_idx].count; i++) {
generate(curr_idx + 1, curr_divisor, arr, final);
curr_divisor *= arr[curr_idx].pf;
}
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void fun(long long n) {
long long d = n;
vector<primefactorisation> arr;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
long long cnt = 0;
while ((n % i) == 0) {
n = n / i;
cnt++;
}
arr.push_back({cnt, i});
}
}
if (n > 1) {
arr.push_back({1, n});
}
long long curr_idx = 0, curr_divisor = 1;
vector<long long> final;
generate(curr_idx, curr_divisor, arr, final);
sort(final.begin(), final.end());
long long mini = LLONG_MAX, a = -1, b = -1;
for (int i = 0; i < final.size(); i++) {
long long x = final[i];
if (gcd(max(x, d / x), min(x, d / x)) == 1) {
if (max(x, d / x) < mini) {
a = min(x, d / x);
b = max(x, d / x);
mini = b;
}
}
}
cout << a << " " << b;
return;
}
int main() {
long long x;
cin >> x;
fun(x);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mxN = 1e12 + 1;
const long long int MOD = 1e9 + 7;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
void solve() {
set<pair<long long int, long long int>> s;
long long int n;
cin >> n;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (lcm(i, n / i) == n) s.insert(make_pair(i, n / i));
}
}
pair<long long int, long long int> mn(mxN, mxN);
for (auto a : s) {
long long int x = max(a.first, a.second);
long long int y = max(mn.first, mn.second);
if (x < y) {
mn = a;
}
}
cout << mn.first << " " << mn.second << "\n";
}
signed main() {
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD2 = 998244353;
const long long N = 1000 * 100 + 10;
const long long N2 = 70;
const long double PI = 3.141592653589793;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long power(long long x, long long y, long long p = LLONG_MAX) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
void solve() {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x;
cin >> x;
long long ans = 1;
for (long long i = 1; (i * i) <= x; i++) {
if (x % i == 0) {
if (lcm(i, x / i) == x) {
ans = i;
}
}
}
cout << ans << " " << (x / ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int prim[2000002], cnt;
bool isp[2000002];
int js, ps[2000002], ci[2000002];
long long pr[2000002];
int main() {
scanf("%lld", &n);
m = n;
if (n == 1) {
puts("1 1");
return 0;
}
for (int i = 2; i <= 2000000; i++) isp[i] = 1;
for (int i = 2; i <= 2000000; i++) {
if (isp[i]) prim[++cnt] = i;
for (int j = 1; j <= cnt && prim[j] * i <= 2000000; j++) {
isp[prim[j] * i] = 0;
if (i % prim[j] == 0) break;
}
}
for (int i = 1; i <= cnt && prim[i] <= n; i++) {
if (n % prim[i] == 0) {
ps[++js] = prim[i];
pr[js] = 1;
while (n % prim[i] == 0) {
ci[js]++;
n /= prim[i];
pr[js] *= prim[i];
}
}
}
if (n > 1) ps[++js] = n, ci[js] = 1, pr[js] = n;
long long mn = 1e18, as1, as2;
for (int i = 1; i < (1 << js); i++) {
long long tp = 1;
for (int j = 1; j <= js; j++) {
if (i & (1 << (j - 1))) tp *= pr[j];
}
long long ano = m / tp;
if (max(tp, ano) < mn) {
mn = max(tp, ano);
as1 = tp, as2 = ano;
}
}
printf("%I64d %I64d\n", as1, as2);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios::sync_with_stdio(false);
long long x;
cin >> x;
long long sq = sqrt(x);
long long sol = x;
long long a = 1;
long long b = x;
for (long long i = 1; i <= sq + 1; i++) {
if (x % i == 0) {
long long t = x / i;
if (gcd(t, i) == 1) {
if (sol > max(t, i)) {
sol = max(t, i);
a = t;
b = i;
}
}
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
void HIGH(string& a) {
transform((a).begin(), (a).end(), a.begin(), ::toupper);
}
void LOW(string& a) { transform((a).begin(), (a).end(), a.begin(), ::tolower); }
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
struct chash {
const uint64_t C = ll(2e18 * PI) + 71;
const int RANDOM = rng();
ll operator()(ll x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
const int MOD = 1e9 + 7;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void IOS(int n = 10, string s = "") {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(n);
cerr.precision(n);
cerr << fixed;
cout << fixed;
if (((int)(s).size())) {
setIn(s + ".in"), setOut(s + ".out");
}
}
const int mxN = 2e5;
void solve() {
ll x, a1, a2;
re(x);
for (ll i = 1; i * i <= x; ++i) {
if (x % i) continue;
ll b1 = i, b2 = x / i;
if (gcd(b1, b2) == 1) a1 = b1, a2 = b2;
}
ps(a1, a2);
}
int main() {
IOS();
int t = 1;
for (int i = (0); i < (t); ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long x, b;
cin >> x;
long long t = sqrt(x);
for (long long a = t; a >= 1; a--) {
if (x % a) continue;
b = x / a;
if (gcd(a, b) == 1) {
cout << a << " " << b << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a;
int gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
void solve(long long a) {
long long mn = 1e8;
long long mx = 0LL;
for (long long i = 1; i * i <= a; i++) {
if (a % i == 0) {
if (a == ((i * a / i) / (gcd(i, a / i)))) {
mx = i;
mn = a / i;
}
}
}
cout << mx << " " << mn << "\n";
}
int main() {
scanf("%lld", &a);
solve(a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long res, a, b;
void solve(vector<long long> v, long long i, long long x, long long cur) {
long long j, k, n = v.size();
if (i == n) {
long long x1 = max(cur, x / cur);
if (res > x1) {
res = x1;
a = cur;
b = x / cur;
}
return;
}
solve(v, i + 1, x, cur);
solve(v, i + 1, x, cur * v[i]);
}
int main() {
long long i, j, k, n;
cin >> n;
map<long long, long long> mp;
long long x = n;
while (x % 2 == 0) {
mp[2]++;
x /= 2;
}
for (i = 3; i * i <= x; i += 2) {
while (x % i == 0) {
mp[i]++;
x /= i;
}
}
if (x > 1) mp[x]++;
vector<long long> v;
for (auto it = mp.begin(); it != mp.end(); it++) {
v.push_back(it->first);
}
for (i = 0; i < v.size(); i++) {
v[i] = pow(v[i], mp[v[i]]);
}
res = n;
a = n;
b = 1;
solve(v, 0LL, n, 1LL);
cout << a << ' ' << b;
}
|
#include <bits/stdc++.h>
using namespace std;
const double E = 2.718281828459;
const double pi = acos(-1.0);
const double eps = 1e-9;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 10;
const int maxm = 1e2;
void debug() { cout << "_____five___\n"; }
long long a[1000], b[1000];
int tot;
void factor(long long n, long long a[1000], long long b[1000], int &tot) {
long long i, now;
long long temp;
temp = (long long)((double)sqrt(n) + 1);
tot = 0;
now = n;
for (i = 2; i <= temp; ++i)
if (now % i == 0) {
a[++tot] = i;
b[tot] = 0;
while (now % i == 0) {
++b[tot];
now /= i;
}
}
if (now != 1) {
a[++tot] = now;
b[tot] = 1;
}
}
long long pu(int x, int y) {
long long sum = 1;
for (int i = 1; i <= y; ++i) {
sum *= x;
}
return sum;
}
long long number[100], t;
bool cmp(long long x, long long y) { return x > y; }
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
long long putss;
int main(int argc, const char *argv[]) {
long long x;
putss = INF;
long long xx, yy;
cin >> x;
for (long long i = 1; i <= sqrt(x); ++i) {
long long j = x / i;
if (i * j == x && gcd(i, j) == 1) {
if (putss > max(i, j)) {
putss = max(i, j);
xx = i, yy = j;
}
}
}
cout << xx << " " << yy << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = acos(-1.0);
using namespace std;
inline long long MAX2(long long a, long long b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
int mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
unsigned long int setbits(long long n) {
unsigned long int count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int modInverse(int A, int M) { return powmod(A, M - 2); }
bool is_prime(long long n) {
if (n == 1) {
return false;
}
long long i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
if (is_prime(n)) {
cout << 1 << " " << n << '\n';
return 0;
}
int end = sqrt(n);
long long second = LLONG_MAX, en = LLONG_MAX;
for (int i = 1; i <= end; i++) {
if (n % i == 0) {
long long res1 = i;
long long res2 = n / i;
if (lcm(res1, res2) == n) {
second = res1;
en = res2;
}
}
}
cout << second << " " << en << '\n';
return 0;
}
|
#include <bits/stdc++.h>
long long max(long long a, long long b) { return (a < b) ? b : a; }
long long min(long long a, long long b) { return (a > b) ? b : a; }
using namespace std;
long long x[300], y[300];
long long ab(long long r) { return (r < 0) ? -r : r; }
int main() {
long long x, ans = LLONG_MAX / 2, bb, aa;
cin >> x;
map<long long, long long> pr;
while (x > 1) {
long long br = 1;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
pr[i]++;
x /= i;
br = 0;
break;
}
}
if (br) {
pr[x]++;
x = 1;
}
}
for (long long i = 0; i < 1 << pr.size(); i++) {
long long a = 1, b = 1;
long long te = i;
for (auto&& j : pr) {
if (te % 2 == 1) {
for (long long v = 0; v < j.second; v++) a *= j.first;
} else {
for (long long v = 0; v < j.second; v++) b *= j.first;
}
te /= 2;
}
if (ans > max(a, b)) ans = max(a, b), aa = a, bb = b;
}
cout << aa << " " << bb << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b) * b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
cin >> t;
long long int sum = 0;
if (t == 1)
cout << "1"
<< " "
<< "1" << '\n';
else {
for (long long int i = 1; i * i < t; ++i) {
if (t % i == 0 && lcm(i, t / i) == t) {
sum = i;
}
}
cout << sum << " " << t / sum << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int prime[1000003], tot;
bool vis[1000003];
void shai(long long X) {
tot = 0;
memset(vis, 0, sizeof(vis));
for (long long i = 2; i < X; i++) {
if (!vis[i]) {
prime[tot++] = i;
}
for (long long j = 0; j < tot && prime[j] * i < X; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) {
break;
}
}
}
}
int q[100003], t[100003], len;
bool can[10000003];
int main() {
long long n, m;
cin >> n;
if (n == 1) {
cout << "1 1";
return 0;
}
shai((int)(sqrt(n)) + 10);
int i = 0;
m = n, len = 0;
while (1) {
if (i >= tot) break;
if ((long long)prime[i] * (long long)prime[i] > n) break;
if (m % (long long)prime[i] == 0) {
m /= prime[i];
++len;
q[len] = i;
t[len] = 1;
while (m % prime[i] == 0) m /= prime[i], t[len]++;
}
if (m == 1) break;
++i;
}
int sqr = (int)sqrt(n) + 1;
memset(can, 0, sizeof(can));
can[1] = true;
for (register int i = 1; i <= len; i++) {
bool f = 0;
long long tmp = 1;
for (int j = 1; j <= t[i]; j++) {
tmp *= prime[q[i]];
if (tmp > sqr) {
f = 1;
break;
}
}
int lens = sqr / tmp;
if (f) continue;
for (register int j = lens; j >= 1; --j)
if (can[j]) can[j * tmp] = 1;
}
for (register int i = sqr - 1; i >= 1; i--) {
if (can[i]) {
printf("%d %I64d", i, n / i);
return 0;
}
}
return 1;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int x;
cin >> x;
vector<long long int> fac;
pair<long long int, long long int> ans;
for (long long int i = 1; i * i < x; ++i) {
if (x % i == 0) fac.push_back(i);
}
for (auto i = fac.rbegin(); i != fac.rend(); ++i) {
long long int y = *i;
if (lcm(y, x / y) == x) {
ans = {y, x / y};
break;
}
}
if (x == 1) ans = {1, 1};
cout << ans.first << " " << ans.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
if (n == 1) {
cout << "1 1"
<< "\n";
} else {
long long int minn = n;
vector<long long int> v;
vector<long long int> vv;
long long int a = 1, b = n;
for (long long int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
long long int x = n / i;
if (gcd(i, x) == 1) {
long long int k = max(i, x);
if (k < minn) {
a = min(i, x);
b = max(i, x);
minn = k;
}
}
}
}
cout << a << " " << b << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long ans = (a * b) / gcd(a, b);
return ans;
}
int main() {
long long x;
cin >> x;
vector<long long> v;
for (long long i = 1; i <= (long long)sqrt(x); i++) {
if (x % i == 0) {
v.push_back(i);
}
}
long long minv = x;
for (auto i = v.begin(); i != v.end(); i++) {
if (lcm(*i, x / (*i)) == x) {
long long temp = max(*i, x / (*i));
minv = min(temp, minv);
}
}
cout << minv << " " << x / minv << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) {
if (b)
while ((a %= b) && (b %= a))
;
return a + b;
}
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
int main() {
long long X;
cin >> X;
long long res = X;
long long r1 = 1, r2 = X;
for (long long i = 1; i * i <= X; i++) {
if (X % i == 0) {
long long j = X / i;
if (LCM(i, j) == X && res > max(i, j)) {
res = max(i, j);
r1 = i;
r2 = j;
}
}
}
cout << r1 << " " << r2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 6031)
#pragma warning(disable : 4101)
using namespace std;
const int INF = 1e9;
const long long LINF = 1e18;
const double PI = acos(-1);
long long x;
vector<long long> factors(long long n) {
vector<long long> fs;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
long long f = 1;
while (n % i == 0) {
f = f * i;
n = n / i;
}
fs.push_back(f);
}
}
if (n > 1) {
fs.push_back(n);
}
return fs;
}
pair<long long, long long> bruteforce(vector<long long> fs,
long long capacity) {
long long best = capacity;
pair<long long, long long> ans;
for (int i = 0; i < (1 << (((int)(fs).size()))); i++) {
long long cur_l = 1;
long long cur_r = 1;
for (int k = 0; k < ((int)(fs).size()); k++) {
if ((i >> k) & 1) {
cur_l *= fs[k];
} else {
cur_r *= fs[k];
}
}
if (max(cur_l, cur_r) <= best) {
best = max(cur_l, cur_r);
ans = {cur_l, cur_r};
}
}
return ans;
}
int main() {
scanf("%lld", &x);
pair<long long, long long> k = bruteforce(factors(x), x);
printf("%lld %lld\n", k.first, k.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
void prework() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct pair {
long long x, y;
} arr[maxn];
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; }
int main() {
prework();
long long x;
cin >> x;
long long len = 0;
for (long long i = 1; i <= sqrt(x) + 1; i++) {
if (x % i == 0) {
arr[len].x = i;
arr[len++].y = x / i;
}
}
long long x1 = arr[0].x, x2 = arr[0].y;
for (long long i = 1; i < len; i++) {
if (arr[i].x == arr[i].y) continue;
if (lcm(arr[i].x, arr[i].y) != x) continue;
long long cur1 = max(arr[i].x, arr[i].y);
long long cur2 = max(x1, x2);
if (cur2 > cur1) {
x1 = arr[i].x;
x2 = arr[i].y;
}
}
cout << x1 << " " << x2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t tp = clock();
const long long mod = 1e9 + 7;
long long int power(long long int a, long long int b) {
long long int ans = 1;
a = a;
while (b > 0) {
if (b & 1) ans = (ans * a);
b >>= 1;
a = (a * a);
}
return ans;
}
long long int power1(long long int a, long long int b, long long int m = mod) {
long long int ans = 1;
a %= m;
while (b > 0) {
if (b & 1) ans = (ans * a) % m;
b >>= 1;
a = (a * a) % m;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int ncr(long long int n, long long int r) {
if (n < r) return 0;
long long int p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
long long int g = gcd(p, k);
p /= g;
k /= g;
n--;
r--;
}
} else
p = 1;
return p % mod;
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b) * b);
}
bool compare_increasing(pair<long long int, long long int> l1,
pair<long long int, long long int> l2) {
if (l1.first != l2.first)
return (l1.first < l2.first);
else
return (l1.second < l2.second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
while (tt--) {
long long int n, x, y;
cin >> n;
for (long long int i = 1; i * i <= n; i++) {
if (n % i == 0 && gcd(min(i, n / i), max(i, n / i)) == 1)
x = i, y = n / i;
}
cout << x << ' ' << y << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int x;
cin >> x;
long long int a1 = 1, a2 = x;
for (long long int i = 2; i * i <= x; i++) {
if (x % i == 0) {
long long int d = x / i;
if (gcd(i, d) == 1) {
long long int k = max(i, d);
if (k < a2) {
a2 = max(i, d);
a1 = min(i, d);
}
}
}
}
cout << a1 << " " << a2;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
int main() {
long long X;
cin >> X;
long long a = 1, b = X;
long long m = X;
for (long long i = 2; i * i < X; i++) {
if (X % i == 0) {
long long ta = i;
long long tb = X / i;
if (X * gcd(ta, tb) == ta * tb) {
if (max(ta, tb) < m) {
m = max(ta, tb);
a = ta;
b = tb;
}
}
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
long long int n, x, ans, ans1, y;
cin >> y;
n = (long long int)sqrt((double)y);
for (long long int i = n; i > 0; i--) {
if (y % i == 0) {
x = y / i;
if (gcd(i, x) == 1) {
ans = i;
ans1 = x;
break;
}
}
}
if (y != 1)
cout << ans << ' ' << ans1 << endl;
else
cout << 1 << ' ' << 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
long long gcd(long long x, long long y) {
if (x < y) swap(x, y);
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 1; i <= sqrt(n); ++i) {
if (n % i != 0 || gcd(i, n / i) != 1) continue;
a = i;
b = n / i;
}
cout << a << ' ' << b;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fun(long long a, long long b) {
if (a == 0) return b;
return fun(b % a, a);
}
int main() {
long long x;
cin >> x;
long long ans = 1e18;
long long pa, pb;
for (long long i = 1; i * i <= x; i++) {
long long a = i;
long long b = x / i;
if ((a * b) == x) {
long long g = fun(a, b);
long long lcm = x / g;
if (lcm == x) {
if (ans > b) {
ans = b;
pa = a;
pb = b;
}
}
}
}
cout << pa << " " << pb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void jabru() {
long long n;
cin >> n;
long long ans = LLONG_MAX;
for (long long j = 1; j * j <= n; j++) {
if (n % j == 0) {
long long here = max(j, n / j);
if (gcd(j, n / j) == 1) ans = min(ans, here);
}
}
cout << ans << " " << n / ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
jabru();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 1e5 + 9;
ll gcd(ll a, ll b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios::sync_with_stdio(false);
ll a;
cin >> a;
ll b, c, x;
for (int i = 0; i < 5; i++) x = sqrt(a);
for (ll i = sqrt(a); i > 0; i--) {
for (int i = 0; i < 123; i++) a = a;
for (int i = 0; i < 123; i++) a = a;
for (int i = 0; i < 123; i++) a = a;
if (a % i == 0) {
if (a / gcd(i, a / i) == a) {
b = i;
c = a / i;
break;
}
if (i == 1) {
b = i;
c = a / i;
break;
}
}
}
cout << b << " " << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long int N = 2e5 + 5;
using namespace std;
bool isPrime(long long int n) {
if (n == 1) return false;
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
void CSK() {
long long int x;
cin >> x;
long long int as1 = 0, as2 = 0;
for (long long int i = 1; i * i <= x; i++) {
if (x % i == 0) {
if (lcm(i, x / i) == x) {
as1 = i;
as2 = x / i;
}
}
}
cout << as1 << " " << as2 << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
cout.precision(10);
long long int __TESTCASES = 1;
while (__TESTCASES--) {
CSK();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long x;
int main() {
cin >> x;
vector<long long> f;
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
long long cur = 1;
while (x % i == 0) {
x /= i;
cur *= i;
}
f.push_back(cur);
}
}
if (x > 1) f.push_back(x);
int n = f.size();
long long ansa = 1e18, ansb = 1e18;
for (int i = 0; i < (1 << n); ++i) {
long long a = 1, b = 1;
for (int j = 0; j < n; ++j) {
if ((i >> j) & 1)
a *= f[j];
else
b *= f[j];
}
if (max(a, b) < max(ansa, ansb)) {
ansa = a;
ansb = b;
}
}
cout << ansa << " " << ansb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> factors(long long int number) {
vector<long long int> result;
for (long long int f = 2; f * f <= number; f++) {
if (number % f != 0) continue;
long long int factor = 1;
while (number % f == 0) {
factor *= f;
number /= f;
}
result.push_back(factor);
}
if (number != 1) result.push_back(number);
return result;
}
int main() {
long long int X;
cin >> X;
vector<long long int> facts = factors(X);
int n = facts.size();
long long int minmax = X + 1;
long long int bestProduct = -1;
long long int bestNotProduct = -1;
for (int bitset = 0; bitset < (1 << n); bitset++) {
long long int product = 1;
long long int notProduct = 1;
for (int i = 0; i < n; i++) {
if (bitset & (1 << i)) {
product *= facts[i];
} else
notProduct *= facts[i];
}
if (minmax > max(product, notProduct)) {
minmax = max(product, notProduct);
bestProduct = product;
bestNotProduct = notProduct;
}
}
cout << bestProduct << " " << bestNotProduct << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long gcd(long long a, long long b) {
if (a < b)
return gcd(b, a);
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long isPrime(long long n) {
long long p = (long long)sqrt(n);
for (long long i = 2; 2 < p + 1 ? i < p + 1 : i > p + 1;
2 < p + 1 ? i += 1 : i -= 1)
if (n % i == 0) return 0;
return 1;
}
long long pow(long long b, long long e) {
if (e == 0)
return 1;
else if (e % 2 == 0) {
long long a = pow(b, e / 2);
return a * a;
} else {
long long a = pow(b, e / 2);
return b * a * a;
}
}
long long pow_m(long long x, long long y, long long m = 1000000007) {
x = x % m;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long modInverse(long long a, long long m) { return pow_m(a, m - 2, m); }
long long max(long long a, long long b) {
if (a >= b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a <= b)
return a;
else
return b;
}
long long sum(vector<long long> v) {
long long sm = 0;
for (long long i = 0; 0 < v.size() ? i < v.size() : i > v.size();
0 < v.size() ? i += 1 : i -= 1)
sm += v[i];
return sm;
}
long long bin_coff(long long n, long long k, long long m) {
vector<vector<long long> > ans(n + 1, vector<long long>(k, 0));
for (long long i = 0; 0 < n + 1 ? i < n + 1 : i > n + 1;
0 < n + 1 ? i += 1 : i -= 1) {
for (long long j = 0;
0 < min(i, k) + 1 ? j < min(i, k) + 1 : j > min(i, k) + 1;
0 < min(i, k) + 1 ? j += 1 : j -= 1) {
if (j == 0 || j == i)
ans[i][j] = 1;
else
ans[i][j] = ans[i - 1][j - 1] % m + ans[i - 1][j] % m;
}
}
return ans[n][k] % m;
}
long long inverse(long long i) {
if (i == 1) return 1;
return (1000000007 -
((1000000007 / i) * inverse(1000000007 % i)) % 1000000007 +
1000000007) %
1000000007;
}
long long maxProduct(vector<long long> arr, long long n, long long k) {
sort(arr.begin(), arr.end());
long long prod = 1;
if (arr[n - 1] == 0 && (k & 1)) return 0;
if (arr[n - 1] <= 0 && (k & 1)) {
for (long long i = n - 1; i >= n - k; i--) prod *= arr[i];
return prod;
}
long long i = 0, j = n - 1;
if (k & 1) {
prod *= arr[j];
j--;
k--;
}
k >>= 1;
for (long long itr = 0; itr < k; itr++) {
long long left_product = arr[i] * arr[i + 1];
long long right_product = arr[j] * arr[j - 1];
if (left_product > right_product) {
prod *= left_product;
i += 2;
} else {
prod *= right_product;
j -= 2;
}
}
return prod;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long x, ans;
cin >> x;
for (long long i = 1; 1 < sqrt(x) + 1 ? i < sqrt(x) + 1 : i > sqrt(x) + 1;
1 < sqrt(x) + 1 ? i += 1 : i -= 1) {
if (x % i == 0 && lcm(i, x / i) == x) ans = i;
}
cout << ans << " " << x / ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline long long add(long long a, long long b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
inline long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += mod;
return a;
}
inline long long mul(long long a, long long b) {
return (long long)((long long)a * b % mod);
}
vector<vector<long long> > adj, dp;
vector<long long> cnt, lvl;
void DFSUtil(long long u, long long p) {
if (u != 0) {
lvl[u] = lvl[p] + 1;
}
dp[u][0] = p;
for (long long i = (1); i <= (20); i++) {
dp[u][i] = dp[dp[u][i - 1]][i - 1];
}
for (auto it : adj[u])
if (it != p) DFSUtil(it, u);
}
void DFS() {
long long V = adj.size();
lvl.assign(V, 0);
DFSUtil(0, 0);
}
long long lca(long long x, long long y) {
if (x == y) return 0;
if (lvl[x] < lvl[y]) swap(x, y);
long long d = lvl[x] - lvl[y];
long long x1 = x;
for (long long i = (0); i <= (20); i++)
if ((1 << i) & d) x1 = dp[x1][i];
if (x1 == y) return d;
long long xx = x1, yy = y;
for (long long i = (20); i >= (0); i--)
if (dp[xx][i] != dp[yy][i]) {
d += 2 * (1 << i);
xx = dp[xx][i];
yy = dp[yy][i];
}
d += 2;
return d;
}
bool query() {
long long a, b, x, y, k;
cin >> a >> b >> x >> y >> k;
x--;
y--;
a--;
b--;
long long v1 = lca(x, y), v2 = lca(x, a), v3 = lca(x, b), v4 = lca(y, a),
v5 = lca(y, b);
if (v1 <= k && (k - v1) % 2 == 0) {
return true;
}
if ((v2 + v5 + 1) <= k && (k - (v2 + v5 + 1)) % 2 == 0) {
return true;
}
if ((v3 + v4 + 1) <= k && (k - (v3 + v4 + 1)) % 2 == 0) {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) {
long long n;
cin >> n;
adj.resize(n + 1);
for (long long i = (1); i <= (n - 1); i++) {
long long p, q;
cin >> p >> q;
p--;
q--;
adj[p].push_back(q);
adj[q].push_back(p);
}
dp.assign(n + 1, vector<long long>(21, 0));
DFS();
long long m;
cin >> m;
for (long long i = (1); i <= (m); i++) {
if (query())
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int logN = 17;
int n, q, h[N], par[logN][N];
vector<int> adj[N];
void Dfs(int u, int p) {
for (int i = 1; i <= logN - 1; i++) par[i][u] = par[i - 1][par[i - 1][u]];
for (int v : adj[u])
if (v != p) {
h[v] = h[u] + 1;
par[0][v] = u;
Dfs(v, u);
}
}
int LCA(int u, int v) {
if (h[u] > h[v]) swap(u, v);
for (int i = logN - 1; i >= 0; i--)
if (h[u] <= h[v] - (1 << i)) v = par[i][v];
if (v == u) return u;
for (int i = logN - 1; i >= 0; i--)
if (par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
return par[0][u];
}
int Dist(int u, int v) {
int lca = LCA(u, v);
return h[u] + h[v] - 2 * h[lca];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
Dfs(1, 1);
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int tmp = Dist(a, b);
if (k >= tmp && (k - tmp) % 2 == 0) {
printf("YES\n");
continue;
}
tmp = Dist(a, x) + 1 + Dist(y, b);
if (k >= tmp && (k - tmp) % 2 == 0) {
printf("YES\n");
continue;
}
tmp = Dist(a, y) + 1 + Dist(x, b);
if (k >= tmp && (k - tmp) % 2 == 0) {
printf("YES\n");
continue;
}
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> adj[100005];
long long int n;
long long int p[100005][35];
long long int parent[100005];
long long int level[100005];
void dfs(long long int v, long long int prev) {
for (auto i : adj[v]) {
if (i == prev) continue;
parent[i] = v;
level[i] = level[v] + 1;
dfs(i, v);
}
}
void preprocess() {
for (long long int i = 1; i < 100005; i++) {
for (long long int j = 0; j < 35; j++) {
p[i][j] = -1;
}
}
for (long long int i = 1; i < n + 1; i++) {
p[i][0] = parent[i];
}
for (long long int j = 1; j < int(log2(n)) + 1; j++) {
for (long long int i = 1; i < n + 1; i++) {
if (p[i][j - 1] != -1) p[i][j] = p[p[i][j - 1]][j - 1];
}
}
}
long long int findnparent(long long int u, long long int dist) {
while (dist > 0) {
int raise_by = log2(dist);
u = p[u][raise_by];
dist -= (1 << raise_by);
}
return u;
}
long long int LCA(long long int u, long long int v) {
if (level[u] < level[v]) swap(u, v);
int dist = level[u] - level[v];
u = findnparent(u, dist);
if (u == v) return u;
for (long long int j = 35 - 1; j > -1; j--) {
if (p[u][j] != -1 and (p[u][j] != p[v][j])) {
u = p[u][j];
v = p[v][j];
}
}
return parent[u];
}
long long dis(long long x, long long y) {
long long l1 = LCA(x, y);
return level[x] + level[y] - 2 * level[l1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
long long int e, f, q;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
cin >> e >> f;
adj[e].push_back(f);
adj[f].push_back(e);
}
level[1] = 0;
parent[1] = 1;
dfs(1, 0);
preprocess();
cin >> q;
while (q--) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long int lab = LCA(a, b);
long long int dab = level[a] + level[b] - 2 * level[lab];
long long int lax = LCA(a, x);
long long int dax = level[a] + level[x] - 2 * level[lax];
long long int lby = LCA(y, b);
long long int dby = level[b] + level[y] - 2 * level[lby];
long long int lay = LCA(a, y);
long long int day = level[a] + level[y] - 2 * level[lay];
long long int lbx = LCA(x, b);
long long int dbx = level[x] + level[b] - 2 * level[lbx];
if (k >= (1 + dax + dby) && (k - 1 - dax - dby) % 2 == 0)
cout << "YES\n";
else if (k >= (1 + day + dbx) && (k - 1 - day - dbx) % 2 == 0)
cout << "YES\n";
else if (k >= dab && (k - dab) % 2 == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
long long qpow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % m;
a = a * a % m, b >>= 1;
}
return ans;
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a, b >>= 1;
}
return ans;
}
long long qmul(long long a, long long b, long long m) {
long long res = 0;
while (b > 0) {
if (b & 1) res = (res + a) % m;
a = (a + a) % m;
b >>= 1;
}
return res;
}
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 inv(long long t, long long p) {
return t == 1 ? 1 : (p - p / t) * inv(p % t, p) % p;
}
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 r = exgcd(b, a % b, y, x);
y -= (a / b) * x;
return r;
}
long long inv1(long long a, long long p) {
long long d, x, y;
d = exgcd(a, p, x, y);
return d == 1 ? (x % p + p) % p : -1;
}
template <typename T, typename B>
T Add(T a, B b, long long m) {
return a + b >= m ? (a + b) % m : a + b;
}
template <typename T, typename B>
T Sub(T a, B b, long long m) {
return a - b < 0 ? (a - b + m) % m : a - b;
}
template <class T>
void _sf(T &x) {
cin >> x;
}
void _sf(int &x) { scanf("%d", &x); }
void _sf(long long &x) { scanf("%lld", &x); }
void _sf(double &x) { scanf("%lf", &x); }
void _sf(char &x) { scanf(" %c", &x); }
void _sf(char *x) { scanf("%s", x); }
void sf() {}
template <class T, class... U>
void sf(T &head, U &...tail) {
_sf(head);
sf(tail...);
}
template <class T>
void _pf(const T &x) {
cout << x;
}
void _pf(const int &x) { printf("%d", x); }
void _pf(const long long &x) { printf("%lld", x); }
void _pf(const double &x) { printf("%.16f", x); }
void _pf(const char &x) { putchar(x); }
void _pf(const char *x) { printf("%s", x); }
template <class T, class U>
void _pf(const pair<T, U> &x) {
pf(x.first);
putchar(' ');
pf(x.second);
}
template <class T>
void _pf(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _pf(*i++))
if (i != x.cbegin()) putchar(' ');
}
void pf() {}
template <class T, class... U>
void pf(const T &head, const U &...tail) {
_pf(head);
putchar(sizeof...(tail) ? ' ' : '\n');
pf(tail...);
}
template <typename T>
inline void read(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
const bool IOS = false;
const double PI = acos(-1);
const double eps = 1e-8;
const long long linf = 0x3f3f3f3f3f3f3f3f;
const long long INV2 = 500000004;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int maxn = 200000 + 10;
int n, m, s, num = 0, head[1000001], dep[1000001], f[1000001][23];
int a1, a2;
struct edg {
int next, to;
} edge[1000001];
void edge_add(int u, int v) {
num++;
edge[num].next = head[u];
edge[num].to = v;
head[u] = num;
edge[++num].next = head[v];
edge[num].to = u;
head[v] = num;
}
void dfs(int u, int father) {
dep[u] = dep[father] + 1;
for (int i = 1; (1 << i) <= dep[u]; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == father) continue;
f[v][0] = u;
dfs(v, u);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 20; i >= 0; i--) {
if (dep[f[x][i]] >= dep[y]) x = f[x][i];
if (x == y) return x;
}
for (int i = 20; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int dis[maxn];
void bfs(int s) {
queue<int> q;
q.push(s);
dis[s] = 1;
while (!q.empty()) {
int nx = q.front();
q.pop();
for (int i = head[nx]; i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v]) continue;
dis[v] = dis[nx] + 1;
q.push(v);
}
}
}
void Main();
int main() {
if (IOS) std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Main();
0;
return 0;
}
void Main() {
sf(n);
for (int i = 1; i <= n - 1; ++i) {
int u, v;
sf(u, v);
edge_add(u, v);
}
dfs(1, 0);
bfs(1);
sf(m);
while (m--) {
int a, b, x, y, k;
sf(x, y, a, b, k);
int f = lca(a, b);
int len = dis[a] + dis[b] - 2 * dis[f];
if (k >= len && (k - len) % 2 == 0) {
pf("Yes");
continue;
} else {
int f1 = lca(a, x), f2 = lca(b, y);
len = dis[a] + dis[x] - 2 * dis[f1] + dis[b] + dis[y] - 2 * dis[f2] + 1;
if (k >= len && (k - len) % 2 == 0) {
pf("Yes");
continue;
}
f1 = lca(a, y), f2 = lca(b, x);
len = dis[a] + dis[y] - 2 * dis[f1] + dis[b] + dis[x] - 2 * dis[f2] + 1;
if (k >= len && (k - len) % 2 == 0) {
pf("Yes");
continue;
}
}
pf("No");
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
const ll mod = 1000000007;
const ll INF = 1000000099;
const ll LINF = (ll)(1e18 + 99);
const vector<ll> dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};
template <typename T, typename U>
inline bool chmin(T& t, const U& u) {
if (t > u) {
t = u;
return 1;
}
return 0;
}
template <typename T, typename U>
inline bool chmax(T& t, const U& u) {
if (t < u) {
t = u;
return 1;
}
return 0;
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T, typename Y>
inline T mpow(T a, Y n) {
T res = 1;
for (; n; n >>= 1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
template <typename T>
struct LCA {
int root, lg;
vector<vector<T>> e;
vector<T> dps;
vector<vector<T>> anc;
LCA(int _root, vector<vector<T>>& _e)
: root(_root), lg(32 - __builtin_clz(_e.size())), e(_e), dps(_e.size()) {
int numV = _e.size();
anc.assign(lg, vector<T>(numV, -1));
dfs(root, -1, 0);
for (int i = 0; i < lg - 1; i++) {
for (int j = 0; j < numV; j++) {
if (anc[i][j] < 0)
anc[i + 1][j] = -1;
else
anc[i + 1][j] = anc[i][anc[i][j]];
}
}
}
void dfs(int now, int par, int d) {
anc[0][now] = par;
dps[now] = d;
for (int i = 0; i < (int)e[now].size(); i++) {
if (e[now][i] != par) dfs(e[now][i], now, d + 1);
}
}
int get_lca(int a, int b) {
if (dps[a] < dps[b]) swap(a, b);
int dif = dps[a] - dps[b];
for (int i = lg - 1; 0 <= i; i--) {
if (dif < (1 << i)) continue;
dif -= (1 << i);
a = anc[i][a];
}
if (a == b) return a;
for (int i = lg - 1; 0 <= i; i--) {
if (anc[i][a] != anc[i][b]) {
a = anc[i][a];
b = anc[i][b];
}
}
return anc[0][a];
}
};
V<int> dis;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n;
cin >> n;
VV<int> e(n, V<int>(0));
int x, y, a, b, k;
for (ll i = 0; i < (ll)(n - 1); ++i) {
cin >> a >> b;
a--;
b--;
e[a].push_back(b);
e[b].push_back(a);
}
dis.assign(n, INF);
queue<int> q;
q.push(0);
q.push(0);
dis[0] = 0;
while (q.size()) {
int now = q.front();
q.pop();
int d = q.front();
q.pop();
for (ll i = 0; i < (ll)((ll)(e[now]).size()); ++i) {
if (dis[e[now][i]] == INF) {
dis[e[now][i]] = d + 1;
q.push(e[now][i]);
q.push(d + 1);
}
}
}
LCA<int> lca(0, e);
int qq;
cin >> qq;
bool can = false;
ll da, db, loop;
while (qq--) {
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
can = false;
int l = lca.get_lca(a, b);
if ((dis[a] + dis[b] - 2 * dis[l]) % 2 == k % 2 &&
(dis[a] + dis[b] - 2 * dis[l]) <= k)
can = true;
da = dis[a] + dis[x] - 2 * dis[lca.get_lca(a, x)];
db = dis[y] + dis[b] - 2 * dis[lca.get_lca(y, b)];
if ((da + db + 1) % 2 == k % 2 && (da + db + 1) <= k) can = true;
da = dis[a] + dis[y] - 2 * dis[lca.get_lca(a, y)];
db = dis[x] + dis[b] - 2 * dis[lca.get_lca(x, b)];
if ((da + db + 1) % 2 == k % 2 && (da + db + 1) <= k) can = true;
if (can)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5;
vector<int> v[N + 5];
int vis[N + 5];
int d[N + 5], f[N + 5][50];
int n;
int t;
queue<int> q;
void bfs() {
q.push(1);
d[1] = 1;
while (q.size()) {
int x = q.front();
q.pop();
for (auto y : v[x]) {
if (d[y]) continue;
d[y] = d[x] + 1;
f[y][0] = x;
for (int j = 1; j <= t; j++) f[y][j] = f[f[y][j - 1]][j - 1];
q.push(y);
}
}
}
int lca(int x, int y) {
if (d[x] > d[y]) swap(x, y);
for (int i = t; i >= 0; i--)
if (d[f[y][i]] >= d[x]) y = f[y][i];
if (x == y) return x;
for (int i = t; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
}
}
return f[x][0];
}
int main() {
scanf("%d", &n);
t = (int)(log(n) / log(2.0)) + 1;
for (int i = 1; i < n; i++) {
int uu, vv;
scanf("%d%d", &uu, &vv);
v[uu].push_back(vv);
v[vv].push_back(uu);
}
bfs();
int q;
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int dis1 = d[a] + d[b] - 2 * d[lca(a, b)];
int dis2 =
d[a] + d[x] - 2 * d[lca(x, a)] + d[b] + d[y] - 2 * d[lca(y, b)] + 1;
int dis3 =
d[a] + d[y] - 2 * d[lca(y, a)] + d[b] + d[x] - 2 * d[lca(x, b)] + 1;
bool f = false;
if (k >= dis1) {
if ((k - dis1) % 2 == 0) f = true;
}
if (k >= dis2) {
if ((k - dis2) % 2 == 0) f = true;
}
if (k >= dis3) {
if ((k - dis3) % 2 == 0) f = true;
}
if (f)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int t, next;
} e[100010 * 2];
int fa[100010][30], head[100010], p, n, m, s = 1, depth[100010];
void add_edge(int s, int t) {
p++;
e[p].t = t;
e[p].next = head[s];
head[s] = p;
}
void dfs(int p, int fr) {
depth[p] = depth[fr] + 1;
fa[p][0] = fr;
for (int i = 1; (1 << i) <= depth[p]; i++) {
fa[p][i] = fa[fa[p][i - 1]][i - 1];
}
for (int i = head[p]; i; i = e[i].next) {
if (!depth[e[i].t]) {
dfs(e[i].t, p);
}
}
}
int LCA(int x, int y) {
if (depth[x] > depth[y]) swap(x, y);
for (int i = 20; i >= 0; i--) {
if (depth[x] <= depth[y] - (1 << i)) {
y = fa[y][i];
}
}
if (x == y) return x;
for (int i = 20; i >= 0; i--) {
if (fa[x][i] == fa[y][i]) continue;
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
dfs(s, 0);
scanf("%d", &m);
while (m--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int lca_ab = LCA(a, b);
int lca_ax = LCA(a, x);
int lca_ay = LCA(a, y);
int lca_bx = LCA(b, x);
int lca_by = LCA(b, y);
int lca_xy = LCA(x, y);
int dis1 = depth[a] + depth[b] - 2 * depth[lca_ab];
int dis2 = (depth[a] + depth[x] - 2 * depth[lca_ax]) + 1 +
(depth[y] + depth[b] - 2 * depth[lca_by]);
int dis3 = (depth[a] + depth[y] - 2 * depth[lca_ay]) + 1 +
(depth[x] + depth[b] - 2 * depth[lca_bx]);
int od = 0x7fffffff, ev = 0x7ffffffe;
if (dis1 & 1)
od = min(od, dis1);
else
ev = min(ev, dis1);
if (dis2 & 1)
od = min(od, dis2);
else
ev = min(ev, dis2);
if (dis3 & 1)
od = min(od, dis3);
else
ev = min(ev, dis3);
if (k & 1) {
if (k < od) {
puts("NO");
} else {
puts("YES");
}
} else {
if (k < ev) {
puts("NO");
} else {
puts("YES");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int fi[maxn], ne[maxn * 2], dui[maxn * 2], qc[maxn];
int cc[17];
int f[maxn][17];
int dep[maxn];
int i, j, k, l, m, n, x, y, a, b, now, tmp;
int q;
bool bz;
void add(int x, int y) {
if (fi[x] == 0)
fi[x] = ++now;
else
ne[qc[x]] = ++now;
dui[now] = y;
qc[x] = now;
}
void dfs(int x, int y) {
int i = fi[x];
f[x][0] = y;
dep[x] = dep[y] + 1;
while (i) {
if (dui[i] == y) {
i = ne[i];
continue;
}
dfs(dui[i], x);
i = ne[i];
}
}
int fd_dis(int x, int y) {
int i, z, ans = 0;
if (dep[x] < dep[y]) {
z = x;
x = y;
y = z;
}
for (i = 16; i >= 0; i--)
if (dep[x] - cc[i] >= dep[y]) {
ans = ans + cc[i];
x = f[x][i];
}
for (i = 16; i >= 0; i--)
if (f[x][i] != f[y][i]) {
ans = ans + cc[i] + cc[i];
x = f[x][i];
y = f[y][i];
}
if (x != y) ans = ans + 2;
return ans;
}
bool check(int x) {
if (x <= k && (k - x) % 2 == 0)
return true;
else
return false;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
cc[0] = 1;
for (i = 1; i <= 16; i++) cc[i] = cc[i - 1] * 2;
dfs(1, 0);
for (j = 1; j <= 16; j++)
for (i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
bz = false;
tmp = fd_dis(a, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, x) + fd_dis(y, b) + 1;
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, y) + fd_dis(x, b) + 1;
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, x) + 2 + fd_dis(x, y) + fd_dis(y, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, y) + 2 + fd_dis(x, y) + fd_dis(x, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, x) + 1 + fd_dis(x, y) + fd_dis(x, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, y) + 1 + fd_dis(x, y) + fd_dis(y, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, x) + 1 + fd_dis(x, y) + fd_dis(x, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
tmp = fd_dis(a, y) + 1 + fd_dis(x, y) + fd_dis(y, b);
if (check(tmp)) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, u, v, q, xx, yy, aa, bb, kk, pp, b[100005], c[100005][20], d[100005],
e[100005];
vector<int> a[100005];
void dfs(int x) {
d[x] = ++pp;
for (int i = 0; i < a[x].size(); ++i) {
if (b[a[x][i]] == -1) {
b[a[x][i]] = b[x] + 1;
c[a[x][i]][0] = x;
dfs(a[x][i]);
}
}
e[x] = ++pp;
}
int anc(int x, int y) {
if (d[x] <= d[y] && e[y] <= e[x])
return 1;
else
return 0;
}
int lca(int x, int y) {
if (anc(x, y)) return x;
if (anc(y, x)) return y;
for (int i = 17; i >= 0; --i) {
if (!anc(c[x][i], y)) x = c[x][i];
}
return c[x][0];
}
int dist(int x, int y) { return b[x] + b[y] - b[lca(x, y)] * 2; }
int check(int kk, int xx) { return kk >= xx && (kk - xx) % 2 == 0; }
int main() {
scanf("%d", &n);
memset(b, -1, sizeof(b));
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
a[u].push_back(v);
a[v].push_back(u);
}
b[1] = 0;
c[1][0] = 1;
dfs(1);
for (int i = 1; i <= 17; ++i) {
for (int j = 1; j <= n; ++j) c[j][i] = c[c[j][i - 1]][i - 1];
}
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d %d %d %d %d", &xx, &yy, &aa, &bb, &kk);
if (check(kk, dist(aa, bb)) || check(kk, dist(aa, xx) + dist(bb, yy) + 1) ||
check(kk, dist(aa, xx) + dist(bb, yy) + dist(xx, yy) + 2) ||
check(kk, dist(aa, yy) + dist(bb, xx) + 1) ||
check(kk, dist(aa, yy) + dist(bb, xx) + dist(xx, yy) + 2))
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T, typename U>
static inline void amin(T& x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T& x, U y) {
if (x < y) x = y;
}
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long min(long long a, long long b) { return (a < b) ? a : b; }
const long long N = 1e5 + 10;
long long n, l;
std::vector<vector<long long> > adj(N);
long long timer;
vector<long long> tin(10000), tout(10000);
vector<vector<long long> > up;
vector<long long> lvl(N, 0);
void dfs(long long v, long long p, long long level) {
tin[v] = ++timer;
lvl[v] = level;
up[v][0] = p;
for (long long i = 1; i < l + 1; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (auto i : adj[v])
if (i != p) dfs(i, v, level + 1);
tout[v] = ++timer;
}
bool is_ancestor(long long u, long long v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
long long lca(long long u, long long v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], v)) u = up[u][i];
}
return up[u][0];
}
void preprocess(long long root) {
tin.resize(n + 1);
tout.resize(n + 1);
timer = 0;
l = ceil(log2(n + 1));
up.assign(n + 100, vector<long long>(l + 1));
dfs(root, root, 1);
}
long long dist(long long x, long long y) {
long long a = lca(x, y);
return abs(lvl[a] - lvl[x]) + abs(lvl[a] - lvl[y]);
}
long long solve() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
preprocess(1);
long long a = lca(3, 5);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long p = dist(a, b);
if ((p - k) % 2 == 0 && p <= k) {
cout << "YES" << '\n';
continue;
}
p = dist(a, x) + dist(y, b) + 1;
if ((p - k) % 2 == 0 && p <= k) {
cout << "YES" << '\n';
continue;
}
p = dist(a, y) + dist(x, b) + 1;
if ((p - k) % 2 == 0 && p <= k) {
cout << "YES" << '\n';
continue;
}
cout << "NO" << '\n';
}
return 0;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
struct edge {
int next, v;
} e[MAXN << 1];
int n, q, root, cnt, head[MAXN], dep[MAXN], anc[MAXN][30];
void addEdge(int x, int y) {
e[++cnt].v = y;
e[cnt].next = head[x];
head[x] = cnt;
}
void dfs(int x) {
for (int i = head[x]; i != -1; i = e[i].next) {
int y = e[i].v;
if (y == anc[x][0]) continue;
dep[y] = dep[x] + 1;
anc[y][0] = x;
dfs(y);
}
}
void init() {
cnt = 0;
root = 1;
memset(head, -1, sizeof(head));
}
int lca(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
int h = dep[b] - dep[a];
for (int i = 0; (1 << i) <= h; i++)
if ((1 << i) & h) b = anc[b][i];
if (a != b) {
for (int i = (int)log2(dep[a]); i >= 0; i--) {
if (anc[a][i] != anc[b][i]) {
a = anc[a][i];
b = anc[b][i];
}
}
a = anc[a][0];
}
return a;
}
int dist(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int main() {
init();
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
addEdge(x, y);
addEdge(y, x);
}
dep[root] = 0;
dfs(root);
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i <= n; i++) {
anc[i][j] = anc[anc[i][j - 1]][j - 1];
}
}
scanf("%d", &q);
for (int kk = 1; kk < 10; kk++) int jj = kk + 1;
for (int i = 1; i <= q; i++) {
int x, y, a, b, k;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int temp1 = dist(a, b);
int temp2 = min(dist(a, x) + dist(y, b), dist(a, y) + dist(x, b)) + 1;
int ans = k + 1;
if (k % 2 == temp1 % 2) ans = min(ans, temp1);
if (k % 2 == temp2 % 2) ans = min(ans, temp2);
if (ans <= k)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 100007;
struct node {
int to, w;
node(int a = 0, int b = 0) {
to = a;
w = b;
}
};
vector<node> e[maxn];
int f[maxn], dis[maxn], deep[maxn], p[maxn][20], n;
void dfs(int u, int pre, int t) {
int i, num;
deep[u] = t;
f[u] = pre;
num = e[u].size();
for (i = 0; i < num; i++) {
int v = e[u][i].to;
if (v != pre) {
dis[v] = dis[u] + e[u][i].w;
dfs(v, u, t + 1);
}
}
}
void init() {
int i, j;
for (j = 1; (1 << j) <= n; j++)
for (i = 1; i <= n; i++) p[i][j] = -1;
for (i = 1; i <= n; i++) p[i][0] = f[i];
for (j = 1; (1 << j) <= n; j++) {
for (i = 1; i <= n; i++) {
if (p[i][j - 1] != -1) p[i][j] = p[p[i][j - 1]][j - 1];
}
}
}
int lca(int a, int b) {
int i, j;
if (deep[a] < deep[b]) swap(a, b);
for (i = 0; (1 << i) <= deep[a]; i++)
;
i--;
for (j = i; j >= 0; j--) {
if (deep[a] - (1 << j) >= deep[b]) {
a = p[a][j];
}
}
if (a == b) return a;
for (j = i; j >= 0; j--) {
if (p[a][j] != -1 && p[a][j] != p[b][j]) {
a = p[a][j];
b = p[b][j];
}
}
return f[a];
}
int flca(int x, int y) {
int l = lca(x, y);
if (l == x) {
return deep[y] - deep[l];
} else if (l == y) {
return deep[x] - deep[l];
}
return deep[x] + deep[y] - 2 * deep[l];
}
int main() {
int m, i, a, b, c, ans;
scanf("%d", &n);
for (i = 1; i <= n; i++) e[i].clear();
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
e[a].push_back(node(b, 1));
e[b].push_back(node(a, 1));
}
dis[1] = 0;
dfs(1, -1, 0);
init();
scanf("%d", &m);
for (i = 0; i < m; i++) {
int x, y, k;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int t1 = flca(a, b);
int t2 = flca(x, a) + flca(y, b) + 1;
int t3 = flca(x, b) + flca(y, a) + 1;
if ((t1 % 2 == k % 2 && t1 <= k) || (t2 % 2 == k % 2 && t2 <= k) ||
(t3 % 2 == k % 2 && t3 <= k)) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
const int N = 2e5 + 5;
const long long int mod = 1e9 + 7;
const long long int Mod = 998244353;
const long double Pi = acos(-1);
const long long int Inf = 4e18;
using namespace std;
struct LCA {
vector<int> euler, d, f, t, g[100001];
vector<bool> vis;
int n;
void Initialize(int s) {
n = s;
d.assign(n + 1, INT_MAX);
f.assign(n + 1, INT_MAX);
vis.assign(n + 1, false);
d[1] = 0;
t.assign(3 * N, 0);
}
void Dfs(int t) {
vis[t] = true;
euler.push_back(t);
for (auto u : g[t]) {
if (!vis[u]) {
d[u] = d[t] + 1;
Dfs(u);
euler.push_back(t);
}
}
}
void Update(int idx, int node, int v, int tl, int tr) {
if (tl == tr)
t[v] = node;
else {
int tm = (tl + tr) / 2;
if (idx <= tm)
Update(idx, node, 2 * v + 1, tl, tm);
else
Update(idx, node, 2 * v + 2, tm + 1, tr);
t[v] = (d[t[2 * v + 1]] > d[t[2 * v + 2]] ? t[2 * v + 2] : t[2 * v + 1]);
}
}
int Query(int l, int r, int v, int tl, int tr) {
if (tl == l && tr == r)
return t[v];
else {
int tm = (tl + tr) / 2;
if (r <= tm)
return Query(l, r, 2 * v + 1, tl, tm);
else if (l > tm)
return Query(l, r, 2 * v + 2, tm + 1, tr);
else {
int L = Query(l, tm, 2 * v + 1, tl, tm);
int R = Query(tm + 1, r, 2 * v + 2, tm + 1, tr);
if (d[L] < d[R])
return L;
else
return R;
}
}
}
int AncestOR(int x, int y, int k) {
x = f[x], y = f[y];
if (x <= y)
return Query(x, y, 0, 0, k - 1);
else
return Query(y, x, 0, 0, k - 1);
}
} lca;
int Dist(int x, int y, int k) {
return lca.d[x] + lca.d[y] - 2 * lca.d[lca.AncestOR(x, y, k)];
}
bool Check(int x, int y) { return (x <= y && (x % 2 == y % 2)); }
void TestCase() {
int n, q;
cin >> n;
lca.Initialize(n);
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
lca.g[u].push_back(v);
lca.g[v].push_back(u);
}
lca.Dfs(1);
for (int i = 0; i < (int)lca.euler.size(); i++)
lca.f[lca.euler[i]] = min(lca.f[lca.euler[i]], i);
int m = (int)lca.euler.size(), msb = -1;
for (int i = 31; i >= 0; i--) {
if (m & (1 << i)) msb = max(msb, i);
}
m = (1 << (msb + 1));
while ((int)lca.euler.size() < m) lca.euler.push_back(0);
for (int i = 0; i < (int)lca.euler.size(); i++)
lca.Update(i, lca.euler[i], 0, 0, m - 1);
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
bool ok = false;
int ab = Dist(a, b, m), ax = Dist(a, x, m), ay = Dist(a, y, m);
int xy = Dist(x, y, m), bx = Dist(b, x, m), by = Dist(b, y, m);
ok |= Check(ab, k);
ok |= Check(ax + xy + by, k);
ok |= Check(ax + 1 + by, k);
ok |= Check(ay + xy + bx, k);
ok |= Check(ay + 1 + bx, k);
ok |= Check(ax + (xy + 1) + xy + by, k);
ok |= Check(ax + (xy + 1) + 1 + by, k);
ok |= Check(ay + (xy + 1) + xy + bx, k);
ok |= Check(ay + (xy + 1) + 1 + bx, k);
ok ? cout << "YES\n" : cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int T = 1;
while (T--) {
TestCase();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
std::unordered_map<int, int> lookup;
struct Node {
int depth;
int id;
std::vector<Node*> parent;
Node* KStepParent(int k) {
if (k > depth) {
return nullptr;
}
if (k == 0) {
return this;
}
int lsb = k & (-k);
return this->parent[lookup[lsb]]->KStepParent(k - lsb);
}
};
Node* LCA(Node* lhs, Node* rhs) {
if (lhs->depth != rhs->depth) {
if (lhs->depth > rhs->depth) {
lhs = lhs->KStepParent(lhs->depth - rhs->depth);
} else {
rhs = rhs->KStepParent(rhs->depth - lhs->depth);
}
}
if (lhs->depth == 0 || lhs == rhs) {
return lhs;
}
int l = 1, r = lhs->depth;
while (l != r) {
int mid = (l + r) / 2;
if (lhs->KStepParent(mid) != rhs->KStepParent(mid)) {
l = mid + 1;
} else {
r = mid;
}
}
return lhs->KStepParent(l);
}
class LCAKaryTree {
public:
LCAKaryTree(vector<pair<int, int>>& edges) {
for (int i = 0; i < 30; ++i) {
lookup[1 << i] = i;
}
n = edges.size() + 1;
connect.resize(n);
for (auto& pa : edges) {
connect[pa.first - 1].push_back(pa.second - 1);
connect[pa.second - 1].push_back(pa.first - 1);
}
for (int i = 0; i < n; ++i) {
auto ptr = new Node();
ptr->id = i;
nodes[i] = ptr;
}
nodes[0]->depth = 0;
for (int nxt : connect[0]) {
dfs(nodes[nxt], nodes[0]);
}
}
~LCAKaryTree() {
for (auto& pa : nodes) {
delete pa.second;
}
}
int Distance(int x, int y) {
auto lhs = nodes[x];
auto rhs = nodes[y];
auto lca = LCA(lhs, rhs);
return lhs->depth + rhs->depth - 2 * lca->depth;
}
private:
void dfs(Node* cur, Node* par) {
cur->depth = par->depth + 1;
cur->parent.push_back(par);
int steplog = 0;
Node* trace = par;
while (trace->parent.size() > steplog) {
cur->parent.push_back(trace->parent[steplog]);
trace = trace->parent[steplog];
steplog++;
}
for (int nxt : connect[cur->id]) {
if (nxt == par->id) {
continue;
}
dfs(nodes[nxt], cur);
}
}
int n;
std::vector<std::vector<int>> connect;
std::map<int, Node*> nodes;
};
bool ok(int distance, int k) { return distance <= k && !((k - distance) & 1); }
class Solver {
public:
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
vector<pair<int, int>> edg;
cin >> n;
int l, r;
for (int i = 1; i < n; ++i) {
cin >> l >> r;
edg.emplace_back(l, r);
}
LCAKaryTree lca(edg);
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int d1 = lca.Distance(a, b);
int d2 = lca.Distance(x, a) + lca.Distance(y, b) + 1;
int d3 = lca.Distance(y, a) + lca.Distance(x, b) + 1;
if (ok(d1, k) || ok(d2, k) || ok(d3, k)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
};
int main() {
Solver sol;
sol.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const double EPS = 1e-6;
const int MAX_N = 3e5 + 5;
const int MAX_LOG = 25;
int N;
vector<int> adjList[MAX_N];
int depth[MAX_N], parent[MAX_N][MAX_LOG];
void DFS(int u, int p, int d) {
depth[u] = d;
parent[u][0] = p;
for (int v : adjList[u]) {
if (v != p) DFS(v, u, d + 1);
}
}
void LCA_precompute() {
DFS(1, 0, 0);
for (int k = 1; k < MAX_LOG; ++k) {
for (int i = 1; i <= N; ++i) {
parent[i][k] = parent[parent[i][k - 1]][k - 1];
}
}
}
int lift(int u, int h) {
for (int i = 0; (1 << i) <= h; ++i) {
if ((h & (1 << i)) != 0) {
u = parent[u][i];
}
}
return u;
}
int LCA(int a, int b) {
if (depth[a] < depth[b]) {
b = lift(b, depth[b] - depth[a]);
} else if (depth[b] < depth[a]) {
a = lift(a, depth[a] - depth[b]);
}
if (a == b) return a;
for (int k = MAX_LOG - 1; k >= 0; --k) {
if (parent[a][k] != parent[b][k]) {
a = parent[a][k], b = parent[b][k];
}
}
return parent[a][0];
}
int dist(int a, int b) {
int lca = LCA(a, b);
return depth[a] + depth[b] - 2 * depth[lca];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N - 1; ++i) {
int u, v;
cin >> u >> v;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
LCA_precompute();
int q;
cin >> q;
while (q-- > 0) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
bool ans = false;
if (dist(a, b) <= k && (k - dist(a, b)) % 2 == 0) ans = true;
int d = dist(a, x) + dist(b, y) + 1;
if (d <= k && (k - d) % 2 == 0) ans = true;
d = dist(b, x) + dist(a, y) + 1;
if (d <= k && (k - d) % 2 == 0) ans = true;
if (ans)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n, a, b, q, x, y, k, anc;
int std_dis, spc_dis, xy_dis, real_dis;
vector<int> V[101000];
vector<int> T[101000];
int LCAtab[101000][18];
void rearange(int node, int father, int depth) {
T[node].push_back(depth);
T[node].push_back(father);
for (int i = 0; i < V[node].size(); i++) {
if (V[node][i] != father) {
T[node].push_back(V[node][i]);
rearange(V[node][i], node, depth + 1);
}
}
}
void generateLCAtab() {
for (int i = 0; i < 18; i++) {
LCAtab[1][i] = 1;
}
for (int i = 2; i <= n; i++) {
LCAtab[i][0] = T[i][1];
}
for (int i = 1; i < 18; i++) {
for (int ii = 2; ii <= n; ii++) {
LCAtab[ii][i] = LCAtab[LCAtab[ii][i - 1]][i - 1];
}
}
}
int findLCA(int node1, int node2) {
if (node1 == node2) {
return node1;
}
if (T[node1][0] < T[node2][0]) {
swap(node1, node2);
}
while (T[node1][0] > T[node2][0]) {
int wsk = 0;
while (T[LCAtab[node1][wsk + 1]][0] > T[node2][0]) {
wsk++;
}
node1 = LCAtab[node1][wsk];
}
while (node1 != node2) {
int wsk = 0;
while (LCAtab[node1][wsk + 1] != LCAtab[node2][wsk + 1]) {
wsk++;
}
node1 = LCAtab[node1][wsk];
node2 = LCAtab[node2][wsk];
}
return node1;
}
int dis(int node1, int node2) {
anc = findLCA(node1, node2);
return (T[node1][0] + T[node2][0] - (2 * T[anc][0]));
}
void testCase() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
V[a].push_back(b);
V[b].push_back(a);
}
rearange(1, 1, 1);
generateLCAtab();
cin >> q;
for (int i = 0; i < q; i++) {
cin >> x >> y >> a >> b >> k;
std_dis = dis(a, b);
spc_dis = min(dis(a, x) + dis(b, y) + 1, dis(a, y) + dis(b, x) + 1);
real_dis = min(std_dis, spc_dis);
xy_dis = dis(x, y);
if (xy_dis % 2 == 1) {
if (k >= real_dis && k % 2 == real_dis % 2) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (k % 2 == std_dis % 2) {
if (k >= std_dis) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
if (k >= spc_dis) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
t = 1;
for (int i = 0; i < t; i++) {
testCase();
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
class segment_tree_max {
private:
vector<int> m;
vector<int> delta;
int n;
bool is_bulk;
int get_val(int i) {
if (!is_bulk) {
return m[i];
}
int ans = m[i] + delta[i];
i /= 2;
while (i >= 1) {
ans += delta[i];
i /= 2;
}
return ans;
}
void inc(int i, int val) {
delta[i] += val;
i /= 2;
while (i >= 1) {
m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
i /= 2;
}
}
public:
segment_tree_max() {}
segment_tree_max(int nn, int def, bool bulk = false) {
is_bulk = bulk;
n = 1;
while (n < nn) {
n *= 2;
}
m.assign(2 * n, def);
if (is_bulk) {
delta.assign(2 * n, 0);
}
}
segment_tree_max(const vector<int>& d, int def = 0, bool bulk = false,
int mult = 1) {
is_bulk = bulk;
n = 1;
while (n < d.size()) {
n *= 2;
}
m.assign(2 * n, def);
if (is_bulk) {
delta.assign(2 * n, 0);
}
for (int i = 0; i < d.size(); i++) {
m[i + n] = d[i] * mult;
}
for (int i = n - 1; i >= 1; i--) {
m[i] = max(m[2 * i], m[2 * i + 1]);
}
}
int get_max(int l, int r) {
if (l > r) {
swap(l, r);
}
l += n;
r += n;
int ans = -1e9;
while (l <= r) {
if (l % 2 == 1) {
ans = max(ans, get_val(l));
l++;
}
if (r % 2 == 0) {
ans = max(ans, get_val(r));
r--;
}
l /= 2;
r /= 2;
}
return ans;
}
void inc_bulk(int l, int r, int val) {
if (!is_bulk) {
cout << "cant inc_bulk in not bulk mode" << endl;
exit(1);
}
if (l > r) {
swap(l, r);
}
l += n;
r += n;
while (l <= r) {
if (l % 2 == 1) {
inc(l, val);
l++;
}
if (r % 2 == 0) {
inc(r, val);
r--;
}
l /= 2;
r /= 2;
}
}
void update(int i, int val) {
i += n;
m[i] = val;
i /= 2;
while (i >= 1) {
if (is_bulk) {
m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
} else {
m[i] = max(m[2 * i], m[2 * i + 1]);
}
i /= 2;
}
}
};
class segment_tree_min {
private:
segment_tree_max max_tree;
public:
segment_tree_min() {}
segment_tree_min(int nn, int def, bool bulk = false) {
max_tree = segment_tree_max(nn, def, bulk);
}
segment_tree_min(const vector<int>& d, int def = -1e9, bool bulk = false) {
max_tree = segment_tree_max(d, def, bulk, -1);
}
int get_min(int l, int r) { return -max_tree.get_max(l, r); }
void inc_bulk(int l, int r, int val) { max_tree.inc_bulk(l, r, -val); }
void update(int i, int val) { max_tree.update(i, -val); }
};
class lca {
private:
segment_tree_min min_tree;
vector<int> h;
vector<int> d;
vector<int> di;
int n;
void dfs(const vector<vector<int> >& g, int x, int l, int p) {
di[x] = d.size();
h[x] = l;
d.push_back(l);
for (int y : g[x]) {
if (y != p) {
dfs(g, y, l + 1, x);
d.push_back(l);
}
}
}
public:
lca(const vector<vector<int> >& g) {
int n = g.size();
h.assign(n, 0);
di.assign(n, 0);
dfs(g, 0, 0, -1);
min_tree = segment_tree_min(d);
}
int get_dist(int x, int y) {
int parent_h = min_tree.get_min(di[x], di[y]);
return h[x] - parent_h + h[y] - parent_h;
}
};
bool check(int l, int k) {
if (l <= k && ((k - l) % 2 == 0)) {
return true;
} else {
return false;
}
}
void solve() {
int n;
cin >> n;
vector<vector<int> > g(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x - 1].push_back(y - 1);
g[y - 1].push_back(x - 1);
}
lca r(g);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int ab = r.get_dist(a - 1, b - 1);
int ax = r.get_dist(a - 1, x - 1);
int ay = r.get_dist(a - 1, y - 1);
int bx = r.get_dist(b - 1, x - 1);
int by = r.get_dist(b - 1, y - 1);
int xy = 1;
if (check(ab, k) || check(ax + xy + by, k) || check(ay + xy + bx, k) ||
check(ax + xy + ay + ab, k)) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
solve();
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mo = 1e9 + 7;
const int inf = 1e9;
int f[18][N], h[N];
vector<int> p[N];
void dfs(int x) {
for (auto& i : p[x])
if (i != f[0][x]) {
f[0][i] = x;
h[i] = h[x] + 1;
dfs(i);
}
}
int lca(int x, int y) {
if (h[x] < h[y]) swap(x, y);
for (auto i = (17); i >= (0); --i)
if (((h[x] - h[y]) >> i) & 1) x = f[i][x];
if (x == y) return x;
for (auto i = (17); i >= (0); --i)
if (f[i][x] != f[i][y]) x = f[i][x], y = f[i][y];
return f[0][x];
}
int dis(int x, int y) { return h[x] + h[y] - h[lca(x, y)] * 2; }
bool ok(int x, int y) { return y >= x && x % 2 == y % 2; }
int main() {
int n, q;
scanf("%d", &n);
for (auto i = (2); i <= (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
p[x].push_back(y);
p[y].push_back(x);
}
dfs(1);
for (auto i = (1); i <= (17); ++i)
for (auto j = (1); j <= (n); ++j) f[i][j] = f[i - 1][f[i - 1][j]];
scanf("%d", &q);
for (auto i = (1); i <= (q); ++i) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
printf("%s\n", (ok(dis(a, b), k) || ok(dis(a, x) + dis(b, y) + 1, k) ||
ok(dis(a, y) + dis(b, x) + 1, k))
? "YES"
: "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct LCA {
vector<int> height, euler, first, segtree, parent;
vector<bool> visited;
int n;
LCA(vector<vector<int> > &adj, int root = 0) {
n = adj.size();
height.resize(n);
first.resize(n);
parent.resize(n);
euler.reserve(n * 2);
visited.assign(n, false);
parent[root] = -1;
dfs(adj, root);
int m = euler.size();
segtree.resize(m * 4);
build(1, 0, m - 1);
}
void dfs(vector<vector<int> > &adj, int node, int h = 0) {
visited[node] = true;
height[node] = h;
first[node] = euler.size();
euler.push_back(node);
for (auto to : adj[node]) {
if (!visited[to]) {
parent[to] = node;
dfs(adj, to, h + 1);
euler.push_back(node);
}
}
}
void build(int node, int b, int e) {
if (b == e) {
segtree[node] = euler[b];
} else {
int mid = (b + e) / 2;
build(node << 1, b, mid);
build(node << 1 | 1, mid + 1, e);
int l = segtree[node << 1], r = segtree[node << 1 | 1];
segtree[node] = (height[l] < height[r]) ? l : r;
}
}
int query(int node, int b, int e, int L, int R) {
if (b > R || e < L) return -1;
if (b >= L && e <= R) return segtree[node];
int mid = (b + e) >> 1;
int left = query(node << 1, b, mid, L, R);
int right = query(node << 1 | 1, mid + 1, e, L, R);
if (left == -1) return right;
if (right == -1) return left;
return height[left] < height[right] ? left : right;
}
int lca(int u, int v) {
int left = first[u], right = first[v];
if (left > right) swap(left, right);
return query(1, 0, euler.size() - 1, left, right);
}
};
void solve() {
int n;
cin >> n;
vector<vector<int> > adj(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
LCA Tree(adj, 0);
auto dis = [&](int u, int v) {
int lc = Tree.lca(u, v);
return Tree.height[u] + Tree.height[v] - 2 * Tree.height[lc];
};
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
bool ok = false;
vector<int> pos;
int ab = dis(a, b);
int ax = dis(a, x);
int ay = dis(a, y);
int bx = dis(b, x);
int by = dis(b, y);
pos.push_back(ab);
pos.push_back(ax + 1 + by);
pos.push_back(ax + 1 + ay + ab);
pos.push_back(ay + 1 + bx);
;
for (auto &d : pos) {
if (d <= k) {
ok |= ((d & 1) == (k & 1));
}
}
if (ok) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
int setBit(int n, int x) { return n | (1 << x); }
int clearBit(int n, int x) { return n & ~(1 << x); }
int toggleBit(int n, int x) { return n ^ (1 << x); }
bool checkBit(int n, int x) { return (bool)(n & (1 << x)); }
int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
int dx4[] = {1, 0, -1, 0};
int dy4[] = {0, 1, 0, -1};
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
template <typename T>
void amax(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void amin(T& t1, T t2) {
t1 = min(t1, t2);
}
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long binpow(long long a, long long b, long long m) {
long long ans = 1;
a %= m;
while (b) {
if (b & 1) ans = (ans * a);
b /= 2;
a = (a * a);
ans %= m;
a %= m;
}
return ans;
}
struct cmp {
bool operator()(pair<long long, long long> a, pair<long long, long long> b) {
return ((a.first - a.first / 2) * a.second) >
((b.first - b.first / 2) * b.second);
}
};
const int N = 1e5 + 5;
vector<int> g[N];
int up[N][24];
int lvl[N];
int n, q;
int T;
void fill_lvl(int src, int p) {
if (src != p) lvl[src] = lvl[p] + 1;
for (auto e : g[src]) {
if (e == p) continue;
fill_lvl(e, src);
}
return;
}
void binary_lifting(int src, int p) {
up[src][0] = p;
for (int i = 1; i < 20; i++) {
up[src][i] = -1;
if (up[src][i - 1] != -1) {
up[src][i] = up[up[src][i - 1]][i - 1];
}
}
for (auto e : g[src]) {
if (e == p) continue;
binary_lifting(e, src);
}
return;
}
int lift_node(int src, int jump) {
int node = src;
for (int i = 19; i >= 0; i--) {
int mask = (1 << i);
if (mask & jump) {
node = up[node][i];
}
if (node == -1) break;
}
return node;
}
int LCA(int u, int v) {
if (lvl[u] < lvl[v]) swap(u, v);
u = lift_node(u, lvl[u] - lvl[v]);
if (u == v) return u;
for (int i = 19; i >= 0; i--) {
if (up[u][i] != up[v][i]) {
u = up[u][i];
v = up[v][i];
}
}
return lift_node(u, 1);
}
int dist(int a, int b) {
int lca = LCA(a, b);
return lvl[a] + lvl[b] - 2 * lvl[lca];
}
void JAI_MAHAKAL() {
cin >> n;
int x, y, a, b, k;
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
cin >> q;
fill_lvl(1, 1);
binary_lifting(1, -1);
while (q--) {
cin >> x >> y >> a >> b >> k;
int op1 = dist(a, b);
int op2 = dist(a, x) + dist(y, b) + 1;
int op3 = dist(a, y) + dist(x, b) + 1;
int ok = 0;
if (op1 % 2 == k % 2 and op1 <= k) ok = 1;
if (op2 % 2 == k % 2 and op2 <= k) ok = 1;
if (op3 % 2 == k % 2 and op3 <= k) ok = 1;
if (ok)
yes();
else
no();
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) JAI_MAHAKAL();
cerr << "Time elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
std::unordered_map<int, int> lookup;
struct Node {
int depth;
int id;
std::vector<Node*> parent;
Node* KStepParent(int k) {
if (k > depth) {
return nullptr;
}
if (k == 0) {
return this;
}
int lsb = k & (-k);
return this->parent[lookup[lsb]]->KStepParent(k - lsb);
}
};
Node* LCA(Node* lhs, Node* rhs) {
if (lhs->depth != rhs->depth) {
if (lhs->depth > rhs->depth) {
lhs = lhs->KStepParent(lhs->depth - rhs->depth);
} else {
rhs = rhs->KStepParent(rhs->depth - lhs->depth);
}
}
if (lhs->depth == 0 || lhs == rhs) {
return lhs;
}
int l = 1, r = lhs->depth;
while (l != r) {
int mid = (l + r) / 2;
if (lhs->KStepParent(mid) != rhs->KStepParent(mid)) {
l = mid + 1;
} else {
r = mid;
}
}
return lhs->KStepParent(l);
}
class LCAKaryTree {
public:
LCAKaryTree(vector<pair<int, int>>& edges) {
for (int i = 0; i < 30; ++i) {
lookup[1 << i] = i;
}
n = edges.size() + 1;
connect.resize(n);
for (auto& pa : edges) {
connect[pa.first - 1].push_back(pa.second - 1);
connect[pa.second - 1].push_back(pa.first - 1);
}
for (int i = 0; i < n; ++i) {
auto ptr = new Node();
ptr->id = i;
nodes[i] = ptr;
}
nodes[0]->depth = 0;
for (int nxt : connect[0]) {
dfs(nodes[nxt], nodes[0]);
}
}
~LCAKaryTree() {
for (auto& pa : nodes) {
delete pa.second;
}
}
int Distance(int x, int y) {
long long res = x;
res *= n;
res += y;
auto iter = distance_cache_.find(res);
if (iter != distance_cache_.end()) {
return iter->second;
}
auto lhs = nodes[x];
auto rhs = nodes[y];
auto lca = LCA(lhs, rhs);
int dist = lhs->depth + rhs->depth - 2 * lca->depth;
distance_cache_[res] = dist;
return dist;
}
private:
void dfs(Node* cur, Node* par) {
cur->depth = par->depth + 1;
cur->parent.push_back(par);
int steplog = 0;
Node* trace = par;
while (trace->parent.size() > steplog) {
cur->parent.push_back(trace->parent[steplog]);
trace = trace->parent[steplog];
steplog++;
}
for (int nxt : connect[cur->id]) {
if (nxt == par->id) {
continue;
}
dfs(nodes[nxt], cur);
}
}
std::unordered_map<long long, int> distance_cache_;
int n;
std::vector<std::vector<int>> connect;
std::map<int, Node*> nodes;
};
bool ok(int distance, int k) { return distance <= k && !((k - distance) & 1); }
class Solver {
public:
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
vector<pair<int, int>> edg;
cin >> n;
int l, r;
for (int i = 1; i < n; ++i) {
cin >> l >> r;
edg.emplace_back(l, r);
}
LCAKaryTree lca(edg);
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int d1 = lca.Distance(a, b);
if (ok(d1, k)) {
cout << "YES" << endl;
continue;
}
int d2 = lca.Distance(x, a) + lca.Distance(y, b) + 1;
if (ok(d2, k)) {
cout << "YES" << endl;
continue;
}
int d3 = lca.Distance(y, a) + lca.Distance(x, b) + 1;
if (ok(d3, k)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
};
int main() {
Solver sol;
sol.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> edge;
vector<int> dist;
vector<int> et;
vector<int> first;
void inedge(int n, int m) {
edge.resize(n + 1);
dist.resize(n + 1, -1);
first.resize(n + 1);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
}
void dfs(int v, int p, int h) {
if (dist[v] != -1) return;
dist[v] = h;
first[v] = et.size();
et.push_back(v);
for (int i = 0; i < edge[v].size(); i++) {
if (p - edge[v][i]) {
dfs(edge[v][i], v, h + 1);
et.push_back(v);
}
}
}
vector<int> t;
int n;
void build(vector<int>& vv) {
n = vv.size();
t.resize(2 * n, INT_MAX);
for (int i = 0; i < n; i++) t[i + n] = vv[i];
for (int i = n - 1; i > 0; i--) {
t[i] = min(t[i << 1], t[i << 1 | 1]);
}
}
int rq(int l, int r) {
int res = INT_MAX;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(res, t[--r]);
}
return res;
}
int dt(int a, int b) {
if (first[a] > first[b]) swap(a, b);
int dlca = rq(first[a], first[b]);
return dist[a] + dist[b] - 2 * dlca;
}
int main() {
int n;
cin >> n;
inedge(n, n - 1);
dfs(1, -1, 0);
vector<int> vv;
for (int i = 0; i < et.size(); i++) vv.push_back(dist[et[i]]);
build(vv);
int q, x, y, a, b, k;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
int d1 = dt(a, b);
int d2 = dt(a, x) + dt(y, b) + 1;
int d3 = dt(a, y) + dt(x, b) + 1;
if (d1 <= k && (d1 % 2 == k % 2)) {
cout << "YES\n";
} else if (d2 <= k && (d2 % 2 == k % 2)) {
cout << "YES\n";
} else if (d3 <= k && (d3 % 2 == k % 2)) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int lev[100005];
void dfs(int u, int p, int **memo, int log, vector<int> *g) {
memo[u][0] = p;
for (int i = 1; i <= log; i++) memo[u][i] = memo[memo[u][i - 1]][i - 1];
for (int v : g[u]) {
if (v != p) {
lev[v] = lev[u] + 1;
dfs(v, u, memo, log, g);
}
}
}
int lca(int u, int v, int log, int **memo) {
if (lev[u] < lev[v]) swap(u, v);
for (int i = log; i >= 0; i--)
if ((lev[u] - pow(2, i)) >= lev[v]) u = memo[u][i];
if (u == v) return u;
for (int i = log; i >= 0; i--) {
if (memo[u][i] != memo[v][i]) {
u = memo[u][i];
v = memo[v][i];
}
}
return memo[u][0];
}
int main() {
int n;
cin >> n;
vector<int> g[n + 1];
int log = (int)ceil(log2(n));
int **memo = new int *[n + 1];
for (int i = 0; i < n + 1; i++) memo[i] = new int[log + 1];
for (int i = 0; i <= n; i++) memset(memo[i], -1, sizeof memo[i]);
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
g[b].push_back(a);
g[a].push_back(b);
}
dfs(1, 1, memo, log, g);
int q;
cin >> q;
while (q--) {
int x, y, k;
cin >> x >> y >> a >> b >> k;
int lc = lca(a, b, log, memo);
int disab = *(lev + a) + *(lev + b) - (*(lev + lc)) - (*(lev + lc));
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
lc = lca(a, x, log, memo);
int disax = *(lev + a) + *(lev + x) - (*(lev + lc)) - (*(lev + lc));
int lc1 = lca(y, b, log, memo);
int disyb = *(lev + y) + *(lev + b) - (*(lev + lc1)) - (*(lev + lc1));
disab = 1 + disax + disyb;
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
lc = lca(a, y, log, memo);
disax = *(lev + a) + *(lev + y) - (*(lev + lc)) - (*(lev + lc));
lc1 = lca(x, b, log, memo);
disyb = *(lev + x) + *(lev + b) - (*(lev + lc1)) - (*(lev + lc1));
disab = 1 + disax + disyb;
if (disab == k) {
cout << "YES\n";
continue;
} else if (disab < k) {
if ((k - disab) % 2 == 0) {
cout << "YES\n";
continue;
}
}
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long ans = 0, tag = 1;
while (!isdigit(c)) tag = (c == '-' ? -1 : 1), c = getchar();
while (isdigit(c)) ans = (ans << 3) + (ans << 1) + c - '0', c = getchar();
return ans * tag;
}
const long long maxn = 1e5 + 5;
long long n, cnt, head[maxn];
long long tot, fa[21][maxn], dep[maxn];
struct edge {
long long to, next;
} e[maxn << 1];
void add(long long x, long long y) {
e[++cnt] = (edge){y, head[x]};
head[x] = cnt;
}
void dfs(long long x, long long f) {
dep[x] = dep[f] + 1;
fa[0][x] = f;
for (long long i = 1; i <= tot; i++) {
fa[i][x] = fa[i - 1][fa[i - 1][x]];
}
for (long long i = head[x]; i; i = e[i].next) {
if (e[i].to == f) continue;
dfs(e[i].to, x);
}
}
long long lca(long long x, long long y) {
if (dep[x] < dep[y]) swap(x, y);
for (long long i = tot; i >= 0; i--) {
if (dep[fa[i][x]] >= dep[y]) x = fa[i][x];
}
if (x == y) return x;
for (long long i = tot; i >= 0; i--) {
if (fa[i][x] != fa[i][y]) {
x = fa[i][x];
y = fa[i][y];
}
}
return fa[0][x];
}
long long dist(long long x, long long y) {
return dep[x] + dep[y] - 2 * dep[lca(x, y)];
}
bool check(long long dis, long long k) {
return (dis <= k && ((dis & 1) == (k & 1)));
}
int main() {
n = read();
tot = log(n) / log(2) + 1;
for (long long i = 1, x, y; i < n; i++) {
x = read(), y = read();
add(x, y);
add(y, x);
}
dfs(1, 0);
long long q = read();
while (q--) {
long long x = read(), y = read(), a = read(), b = read(), k = read();
if (check(dist(a, b), k) || check(dist(a, x) + 1 + dist(b, y), k) ||
check(dist(a, y) + 1 + dist(b, x), k)) {
puts("YES");
} else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
class segment_tree_min {
private:
vector<int> m;
int n;
public:
segment_tree_min() {}
segment_tree_min(int nn) {
n = 1;
while (n < nn) {
n *= 2;
}
m.assign(2 * n, 1e9);
}
segment_tree_min(vector<int> d) {
n = 1;
while (n < d.size()) {
n *= 2;
}
m.assign(2 * n, 1e9);
for (int i = 0; i < d.size(); i++) {
update(i, d[i]);
}
}
int get_min(int l, int r) {
if (l > r) {
swap(l, r);
}
l += n;
r += n;
int ans = 1e9;
while (l <= r) {
if (l % 2 == 1) {
ans = min(ans, m[l]);
l++;
}
if (r % 2 == 0) {
ans = min(ans, m[r]);
r--;
}
l /= 2;
r /= 2;
}
return ans;
}
void update(int i, int val) {
i += n;
while (i >= 1) {
m[i] = min(m[i], val);
i /= 2;
}
}
};
class rmq {
private:
segment_tree_min min_tree;
vector<int> h;
vector<int> d;
vector<int> di;
int n;
void dfs(const vector<vector<int> >& g, int x, int l, int p) {
di[x] = d.size();
h[x] = l;
d.push_back(l);
for (int y : g[x]) {
if (y != p) {
dfs(g, y, l + 1, x);
d.push_back(l);
}
}
}
public:
rmq(const vector<vector<int> >& g) {
int n = g.size();
h.assign(n, 0);
di.assign(n, 0);
dfs(g, 0, 0, -1);
min_tree = segment_tree_min(d);
}
int get_dist(int x, int y) {
int parent_h = min_tree.get_min(di[x], di[y]);
return h[x] - parent_h + h[y] - parent_h;
}
};
bool check(int l, int k) {
if (l <= k && ((k - l) % 2 == 0)) {
return true;
} else {
return false;
}
}
void solve() {
int n;
cin >> n;
vector<vector<int> > g(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x - 1].push_back(y - 1);
g[y - 1].push_back(x - 1);
}
rmq r(g);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int ab = r.get_dist(a - 1, b - 1);
int ax = r.get_dist(a - 1, x - 1);
int ay = r.get_dist(a - 1, y - 1);
int bx = r.get_dist(b - 1, x - 1);
int by = r.get_dist(b - 1, y - 1);
int xy = 1;
if (check(ab, k) || check(ax + xy + by, k) || check(ay + xy + bx, k) ||
check(ax + xy + ay + ab, k)) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
solve();
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long level[1 << 18];
long long dp[1 << 18][18];
long long n;
vector<vector<long long>> g;
void dfs(long long u, long long par) {
if (par == -1)
level[u] = 0;
else
level[u] = level[par] + 1;
dp[u][0] = par;
for (auto it : g[u]) {
if (it == par) continue;
dfs(it, u);
}
}
void build_table() {
long long max_jumps = ceil(log2(n));
for (long long i = 0; i < max_jumps - 1; i++) {
for (long long j = 1; j <= n; j++) {
if (dp[j][i] != -1) dp[j][i + 1] = dp[dp[j][i]][i];
}
}
}
long long LCA(long long u, long long v) {
long long max_jumps = ceil(log2(n));
if (level[u] < level[v]) swap(u, v);
long long diff = level[u] - level[v];
for (long long i = 0; i < max_jumps; i++) {
if (diff & (1 << i)) u = dp[u][i];
}
if (u == v) return u;
for (long long i = max_jumps - 1; i >= 0; i--) {
if (dp[u][i] != dp[v][i]) {
u = dp[u][i];
v = dp[v][i];
}
}
return dp[u][0];
}
long long dist(long long u, long long v) {
return (level[u] + level[v] - 2 * level[LCA(u, v)]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long q, u, v, x, y, a, b, k;
cin >> n;
g.resize(n + 1);
for (long long i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
memset(dp, -1, sizeof(dp));
dfs(1, -1);
build_table();
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
pair<long long, long long> p = {0x3f3f3f3f, 0x3f3f3f3f};
long long d = dist(a, b);
if (d % 2)
p.second = d;
else
p.first = d;
d = dist(a, x) + 1 + dist(y, b);
if (d % 2)
p.second = min(d, p.second);
else
p.first = min(d, p.first);
d = dist(a, y) + 1 + dist(x, b);
if (d % 2)
p.second = min(d, p.second);
else
p.first = min(d, p.first);
bool flag = (k % 2) ? (p.second != 0x3f3f3f3f && k >= p.second)
: (p.first != 0x3f3f3f3f && k >= p.first);
flag ? cout << "YES\n" : cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> graf;
vector<int> timein;
vector<int> timeout;
int timer = 0;
const int kolvo = 2e5;
int binup[kolvo][19];
int a, l;
int rast[kolvo];
void dfs(int v, int deep, int p = 0) {
rast[v] = deep;
timein[v] = timer++;
binup[v][0] = p;
for (int q = 1; q <= l; q++) {
binup[v][q] = binup[binup[v][q - 1]][q - 1];
}
for (int q = 0; q < graf[v].size(); q++) {
if (graf[v][q] != p) {
dfs(graf[v][q], deep + 1, v);
}
}
timeout[v] = timer++;
}
bool check(int v1, int v2) {
return timein[v1] <= timein[v2] && timeout[v1] >= timeout[v2];
}
int lca(int v1, int v2) {
if (check(v1, v2)) {
return v1;
}
if (check(v2, v1)) {
return v2;
}
for (int q = l; q >= 0; q--) {
if (!check(binup[v1][q], v2)) {
v1 = binup[v1][q];
}
}
return binup[v1][0];
}
int rrast(int a, int b) { return rast[a] + rast[b] - 2 * rast[lca(a, b)]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
rast[0] = 0;
int b, c, t;
cin >> a;
graf.resize(a);
for (int q = 1; q < a; q++) {
cin >> b >> c;
graf[c - 1].push_back(b - 1);
graf[b - 1].push_back(c - 1);
}
timeout.resize(a);
timein.resize(a);
while ((1 << l) < a) {
l++;
}
dfs(0, 0, 0);
cin >> t;
int d, e, f, g;
while (t--) {
cin >> c >> d >> e >> f >> g;
if (rrast(e - 1, f - 1) % 2 == g % 2 && rrast(e - 1, f - 1) <= g) {
cout << "YES" << endl;
} else if ((rrast(e - 1, c - 1) + rrast(f - 1, d - 1) + 1) % 2 == g % 2 &&
(rrast(e - 1, c - 1) + rrast(f - 1, d - 1) + 1) <= g) {
cout << "YES" << endl;
} else if ((rrast(f - 1, c - 1) + rrast(e - 1, d - 1) + 1) % 2 == g % 2 &&
(rrast(f - 1, c - 1) + rrast(e - 1, d - 1) + 1) <= g) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5, mod = 1e9 + 7, inf = 0x3f3f3f3f;
long long n, m, Q, K, T;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long e = 1, to[maxn << 1], hed[maxn], nxt[maxn << 1];
void add(long long x, long long y) {
to[++e] = y;
nxt[e] = hed[x];
hed[x] = e;
to[++e] = x;
nxt[e] = hed[y];
hed[y] = e;
}
long long fa[maxn], dep[maxn], siz[maxn], son[maxn], top[maxn];
void dfs1(long long x, long long fu, long long deep) {
siz[x] = 1, fa[x] = fu;
dep[x] = deep;
for (long long i = hed[x]; i; i = nxt[i]) {
if (to[i] == fu) continue;
dfs1(to[i], x, deep + 1);
siz[x] += siz[to[i]];
if (siz[to[i]] > siz[son[x]]) son[x] = to[i];
}
return;
}
void dfs2(long long x, long long topx) {
top[x] = topx;
if (!son[x]) return;
dfs2(son[x], topx);
for (long long i = hed[x]; i; i = nxt[i]) {
if (to[i] == fa[x] || to[i] == son[x]) continue;
dfs2(to[i], to[i]);
}
return;
}
long long lca(long long x, long long y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
if (dep[x] > dep[y]) swap(x, y);
return x;
}
long long dis(long long x, long long y) {
return dep[x] + dep[y] - dep[lca(x, y)] * 2;
}
bool check(long long x, long long y, long long a, long long b, long long k) {
long long goal = (k & 1);
long long k1 = ((dis(a, b))), k2 = ((dis(a, x) + dis(b, y) + 1));
long long k3 = ((dis(a, y) + dis(b, x) + 1));
if (k1 <= k && k1 % 2 == goal) return true;
if (k2 <= k && k2 % 2 == goal) return true;
if (k3 <= k && k3 % 2 == goal) return true;
return false;
}
signed main() {
n = read();
for (long long i = (1); i <= (n - 1); ++i) add(read(), read());
dfs1(1, 0, 1);
dfs2(1, 1);
Q = read();
while (Q--) {
long long x = read(), y = read(), a = read(), b = read(), k = read();
puts((check(x, y, a, b, k)) ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> edge;
vector<int> dist;
vector<int> et;
vector<int> first;
void inedge(int n, int m) {
edge.resize(n + 1);
dist.resize(n + 1, -1);
first.resize(n + 1);
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
edge[a].push_back(b);
edge[b].push_back(a);
}
}
void dfs(int v, int p, int h) {
if (dist[v] != -1) return;
dist[v] = h;
first[v] = et.size();
et.push_back(h);
for (int i = 0; i < edge[v].size(); i++) {
if (p - edge[v][i]) {
dfs(edge[v][i], v, h + 1);
et.push_back(h);
}
}
}
vector<int> t;
int n;
void build(vector<int>& vv) {
n = vv.size();
t.resize(2 * n, INT_MAX);
for (int i = 0; i < n; i++) t[i + n] = vv[i];
for (int i = n - 1; i > 0; i--) {
t[i] = min(t[i << 1], t[i << 1 | 1]);
}
}
int rq(int l, int r) {
int res = INT_MAX;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(res, t[--r]);
}
return res;
}
int dt(int a, int b) {
if (first[a] > first[b]) swap(a, b);
int dlca = rq(first[a], first[b]);
return dist[a] + dist[b] - 2 * dlca;
}
int main() {
int n;
cin >> n;
inedge(n, n - 1);
dfs(1, -1, 0);
build(et);
int q, x, y, a, b, k;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
int d1 = dt(a, b);
int d2 = dt(a, x) + dt(y, b) + 1;
int d3 = dt(a, y) + dt(x, b) + 1;
if (d1 <= k && (d1 % 2 == k % 2)) {
cout << "YES\n";
} else if (d2 <= k && (d2 % 2 == k % 2)) {
cout << "YES\n";
} else if (d3 <= k && (d3 % 2 == k % 2)) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
constexpr int maxl = 21;
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> graph(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
vector<array<int, maxl>> step(n);
vector<int> tin(n), tout(n), depth(n, -1);
int time = 0;
function<void(int, int)> dfs = [&](int v, int p) {
step[v][0] = p;
for (int i = 0; i < maxl - 1; i++) step[v][i + 1] = step[step[v][i]][i];
depth[v] = depth[p] + 1;
tin[v] = time++;
for (int ne : graph[v])
if (ne != p) dfs(ne, v);
tout[v] = time++;
};
dfs(0, 0);
auto anc = [&](int high, int low) {
return tin[high] <= tin[low] and tout[low] <= tout[high];
};
auto lca = [&](int u, int v) {
if (anc(u, v)) return u;
if (anc(v, u)) return v;
for (int i = maxl - 1; i >= 0; i--)
if (!anc(step[u][i], v)) u = step[u][i];
return step[u][0];
};
auto dist = [&](int u, int v) {
return depth[u] + depth[v] - 2 * depth[lca(u, v)];
};
int tt;
cin >> tt;
while (tt--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
vector<int> ds = {dist(a, b), dist(a, x) + dist(y, b) + 1,
dist(b, x) + dist(y, a) + 1};
bool gud = false;
for (int d : ds) gud |= d % 2 == k % 2 and d <= k;
cout << (gud ? "YES" : "NO") << "\n";
}
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
vector<long long> adj[500005];
long long lev[500005], tr[500005][20];
void dfs(long long u, long long par) {
long long i, j;
for (i = 0; i < adj[u].size(); i++) {
long long p = adj[u][i];
if (p == par) continue;
lev[p] = lev[u] + 1;
tr[p][0] = u;
dfs(p, u);
}
}
void build(long long n) {
memset(tr, -1, sizeof(tr));
dfs(1, -1);
long long i, j;
for (j = 1; (1 << j) <= n; j++) {
for (i = 1; i <= n; i++) {
if (tr[i][j - 1] != -1) tr[i][j] = tr[tr[i][j - 1]][j - 1];
}
}
}
long long query(long long p, long long q) {
if (lev[q] > lev[p]) swap(p, q);
long long i, j;
for (i = 16; i >= 0; i--) {
if (lev[p] - (1 << i) >= lev[q]) {
p = tr[p][i];
}
}
if (p == q) return p;
for (i = 16; i >= 0; i--) {
if (tr[p][i] != tr[q][i] && tr[p][i] != -1 && tr[q][i] != -1) {
p = tr[p][i];
q = tr[q][i];
}
}
return tr[p][0];
}
long long dis(long long x, long long y) {
long long p = query(x, y);
return lev[x] + lev[y] - 2 * lev[p];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc, n, i, j, m, q;
while (cin >> n) {
for (i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
build(n);
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long d = dis(a, b);
if (d <= k && d % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
long long p1 = dis(x, a) + dis(y, b) + 1;
long long p2 = dis(x, b) + dis(y, a) + 1;
if (p1 <= k && p1 % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
if (p2 <= k && p2 % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, y, q, a, b, k, in[100009], out[100009], parent[100009][19], timer,
H[100009];
vector<int> v[100009];
void go(int x) {
timer++;
in[x] = timer;
for (int i = 2; i <= 17; i++) {
parent[x][i] = parent[parent[x][i - 1]][i - 1];
}
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i] != parent[x][1]) {
parent[v[x][i]][1] = x;
go(v[x][i]);
}
}
timer++;
out[x] = timer;
}
bool check(int a, int b) { return (in[a] <= in[b] && out[b] <= out[a]); }
int lca(int a, int b) {
if (check(a, b)) return a;
if (check(b, a)) return b;
for (int i = 17; i >= 1; i--) {
if (!check(parent[a][i], b)) a = parent[a][i];
}
return parent[a][1];
}
void High(int x, int h) {
H[x] = h;
for (int i = 0; i < v[x].size(); i++) {
if (H[v[x][i]] == 0) High(v[x][i], h + 1);
}
}
bool find(int a, int b, int k) {
int p = lca(a, b);
int depth = H[a] + H[b] - 2 * H[p];
if (k % 2 == depth % 2 && k >= depth)
return true;
else
return false;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
in[0] = 0;
out[0] = 3 * n;
go(1);
High(1, 1);
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
if (find(a, b, k)) {
cout << "YES" << endl;
continue;
}
int p = lca(a, x);
int depth = H[a] + H[x] - 2 * H[p];
depth++;
if (depth <= k) {
if (find(y, b, k - depth)) {
cout << "YES" << endl;
continue;
}
}
p = lca(a, y);
depth = H[a] + H[y] - 2 * H[p];
depth++;
if (depth <= k) {
if (find(x, b, k - depth)) {
cout << "YES" << endl;
continue;
}
}
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 1e3 + 1;
const int base = 1e9 + 7;
const long long mod = 1e9 + 7;
int n, m = 20;
vector<int> ke[N];
int f[N][25], pa[N], h[N];
void khoitao() {
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++) f[i][j] = -1;
for (int i = 1; i <= n; i++) f[i][0] = pa[i];
for (int j = 1; j <= m; j++)
for (int i = 1; i <= n; i++)
if (f[i][j - 1] != -1) f[i][j] = f[f[i][j - 1]][j - 1];
}
void dfs(int u, int cha, int hi) {
h[u] = hi;
for (int v : ke[u]) {
if (v == cha) continue;
if (h[v]) continue;
pa[v] = u;
dfs(v, u, hi + 1);
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
int x = 0;
while ((1 << x) <= h[u]) x++;
x--;
for (int i = x; i >= 0; i--)
if (h[u] - h[v] >= (1 << i)) u = f[u][i];
if (u == v) return u;
for (int i = x; i >= 0; i--) {
if (f[u][i] != -1 && f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
}
return pa[u];
}
int x, y, a, b, k, r, r1, r2, r3, r4, tmp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
ke[u].push_back(v);
ke[v].push_back(u);
}
for (int i = 1; i <= n; i++) h[i] = 0;
h[1] = 1;
dfs(1, -1, 1);
khoitao();
int q;
cin >> q;
while (q--) {
cin >> a >> b >> x >> y >> k;
r = lca(x, y);
int d = h[x] + h[y] - 2 * h[r];
r1 = h[x] + h[a] - 2 * h[lca(a, x)];
r2 = h[y] + h[b] - 2 * h[lca(b, y)];
r3 = h[x] + h[b] - 2 * h[lca(x, b)];
r4 = h[y] + h[a] - 2 * h[lca(y, a)];
tmp = min(r1 + r2, r3 + r4) + 1;
int res = base;
if ((d + k) % 2 == 0) {
res = d;
}
if ((tmp + k) % 2 == 0) res = min(res, tmp);
if (res <= k) {
cout << "YES" << '\n';
} else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = (1e9) + 7;
const long long N = 1e5 + 5;
const long long level = 25;
long long par[N][level], depth[N];
vector<long long> a[N];
void dfs(long long c, long long p) {
depth[c] = depth[p] + 1;
par[c][0] = p;
for (long long i = 1; i < level; i++) par[c][i] = par[par[c][i - 1]][i - 1];
for (auto ne : a[c]) {
if (ne == p) continue;
dfs(ne, c);
}
}
long long lca(long long u, long long v) {
if (depth[v] < depth[u]) swap(u, v);
long long diff = depth[v] - depth[u];
for (long long i = 0; i < level; i++)
if ((diff >> i) & 1) v = par[v][i];
if (u == v) return u;
for (long long i = level - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
long long dist(long long u, long long v) {
if (u == v) return 0;
long long res = 0;
if (depth[u] > depth[v]) swap(u, v);
long long l = lca(u, v);
return depth[u] + depth[v] - (2 * depth[l]);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long tc = 1;
for (long long ti = 1; ti <= tc; ti++) {
long long n;
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
dfs(1, 0);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long chk = dist(a, b);
if (chk <= k && !((k - chk) % 2)) {
cout << "YES" << endl;
continue;
}
chk = dist(a, x) + dist(y, b) + 1;
if (chk <= k && !((k - chk) % 2)) {
cout << "YES" << endl;
continue;
}
chk = dist(a, y) + dist(x, b) + 1;
if (chk <= k && !((k - chk) % 2)) {
cout << "YES" << endl;
continue;
}
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 20;
const int N = 1e5 + 7;
vector<int> g[N];
int h[N];
int tin[N];
int tout[N];
int p[N];
int up[K][N];
int timer = 0;
void dfs(int cur, int pr, int ch) {
h[cur] = ch;
p[cur] = pr;
tin[cur] = timer;
timer++;
for (auto t : g[cur]) {
if (t != p[cur]) {
dfs(t, cur, ch + 1);
}
}
tout[cur] = timer;
timer++;
}
void init(int n) {
for (int i = 0; i < n; i++) {
up[0][i] = p[i];
}
for (int i = 1; i < K; i++) {
for (int j = 0; j < n; j++) {
int mid = up[i - 1][j];
if (mid != -1) {
up[i][j] = up[i - 1][mid];
} else {
up[i][j] = -1;
}
}
}
}
bool anc(int u, int v) { return tin[u] <= tin[v] && tout[v] <= tout[u]; }
int get(int a, int b) {
if (anc(a, b)) {
return a;
} else if (anc(b, a)) {
return b;
} else {
for (int i = K - 1; i >= 0; i--) {
if (up[i][a] != -1 && !anc(up[i][a], b)) {
a = up[i][a];
}
}
return p[a];
}
}
int ln(int a, int b) { return h[a] + h[b] - 2 * h[get(a, b)]; }
int ok(int ln, int k) { return ln <= k && (ln % 2) == (k % 2); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i + 1 < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0, -1, 0);
init(n);
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int ans = 0;
ans |= ok(ln(a, b), k);
ans |= ok(ln(a, x) + 1 + ln(y, b), k);
swap(x, y);
ans |= ok(ln(a, x) + 1 + ln(y, b), k);
if (ans)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int first[(100 * 1000 + 5)], height[(100 * 1000 + 5)], tim = 0;
vector<int> euler, g[(100 * 1000 + 5)];
void dfs(int u, int p = -1, int h = 0) {
first[u] = tim++;
euler.push_back(u);
height[u] = h;
for (int v : g[u]) {
if (v != p) {
dfs(v, u, h + 1);
euler.push_back(u);
tim++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
int sz = 1;
int m = euler.size();
while (sz <= m) {
sz *= 2;
}
vector<pair<int, int>> tree(2 * sz, {((int)1e9), -1});
for (int i = 0; i < m; i++) {
tree[i + sz] = make_pair(height[euler[i]], euler[i]);
}
for (int i = sz - 1; i > 0; i--) {
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
auto lca = [&](int u, int v) {
int L = first[u] + sz, R = first[v] + sz;
assert(L && R);
if (L > R) swap(L, R);
pair<int, int> ans = {((int)1e9), -1};
while (L <= R) {
if (L % 2 == 1) ans = min(ans, tree[L++]);
if (R % 2 == 0) ans = min(ans, tree[R--]);
L /= 2, R /= 2;
}
assert(ans.second != -1);
return ans.second;
};
auto dist = [&](int u, int v) {
return height[u] + height[v] - 2 * height[lca(u, v)];
};
int queries;
cin >> queries;
while (queries--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
vector<int> options = {dist(a, b), dist(a, x) + dist(b, y) + 1,
dist(a, y) + dist(b, x) + 1};
bool ok = false;
for (int d : options) {
ok |= d <= k && d % 2 == k % 2;
}
cout << (ok ? "YES" : "NO") << '\n';
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.