text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10;
const int MAX2 = 17;
vector<vector<int>> g(MAX);
int n, p;
int pai[MAX2][MAX];
int in[MAX], out[MAX];
int sz[MAX];
void dfs(int k, int pr) {
in[k] = p++;
sz[k] = pr;
for (int i = 0; i < (int)g[k].size(); i++) {
if (in[g[k][i]] == -1) {
pai[0][g[k][i]] = k;
dfs(g[k][i], pr + 1);
}
}
out[k] = p++;
}
void build(int raiz) {
for (int i = 0; i < n; i++) pai[0][i] = i;
p = 0, memset(in, -1, sizeof(in));
dfs(raiz, 0);
for (int k = 1; k < MAX2; k++)
for (int i = 0; i < n; i++) pai[k][i] = pai[k - 1][pai[k - 1][i]];
}
bool anc(int a, int b) { return in[a] <= in[b] and out[a] >= out[b]; }
int lca(int a, int b) {
if (anc(a, b)) return a;
if (anc(b, a)) return b;
for (int k = MAX2 - 1; k >= 0; k--) {
if (!anc(pai[k][a], b)) a = pai[k][a];
}
return pai[0][a];
}
int dist(int a, int b) { return sz[a] + sz[b] - 2 * sz[lca(a, b)]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
build(0);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
int d1 = dist(a, b);
int d2 = dist(a, x) + 1 + dist(y, b);
int d3 = dist(a, y) + 1 + dist(x, b);
if (d1 <= k and (k - d1) % 2 == 0)
cout << "YES" << '\n';
else if (d2 <= k and (k - d2) % 2 == 0)
cout << "YES" << '\n';
else if (d3 <= k and (k - d3) % 2 == 0)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int nxt, to;
};
int n, m, s;
Edge e[100005 << 1];
int first[100005];
int ec;
int fa[100005][21];
int dep[100005];
int _log[100005];
void addEdge(int from, int to) {
e[++ec].to = to;
e[ec].nxt = first[from];
first[from] = ec;
}
void dfs(int u, int f) {
fa[u][0] = f;
dep[u] = dep[f] + 1;
for (int i = 1; i <= _log[dep[u]]; ++i) {
fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
for (int i = first[u]; i; i = e[i].nxt) {
if (e[i].to != f) dfs(e[i].to, u);
}
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
while (dep[a] > dep[b]) {
a = fa[a][_log[dep[a] - dep[b]] - 1];
}
if (a == b) return a;
for (int i = _log[dep[a]] - 1; i >= 0; --i) {
if (fa[a][i] != fa[b][i]) a = fa[a][i], b = fa[b][i];
}
return fa[a][0];
}
inline int dis(int x, int y) { return dep[x] + dep[y] - dep[lca(x, y)] * 2; }
int solve(int x, int y, int a, int b, int k) {
int tmp = dis(a, b);
if ((tmp <= k) && (tmp - k) % 2 == 0) return 1;
tmp = dis(a, x) + 1 + dis(y, b);
if ((tmp <= k) && (tmp - k) % 2 == 0) return 1;
tmp = dis(a, y) + 1 + dis(x, b);
if ((tmp <= k) && (tmp - k) % 2 == 0) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
_log[i] = _log[i - 1] + ((1 << _log[i - 1]) == i);
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
addEdge(u, v);
addEdge(v, u);
}
dfs(1, 0);
cin >> m;
for (int i = 1; i <= m; ++i) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
cout << (solve(x, y, a, b, k) ? "YES" : "NO") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
long long dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
long long x;
long long y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v == 0) return b;
if (b == 0) return v;
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
long long mod;
long long extgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<long long, long long> operator+(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first + r.first, l.second + r.second};
}
pair<long long, long long> operator-(const pair<long long, long long> &l,
const pair<long long, long long> &r) {
return {l.first - r.first, l.second - r.second};
}
long long pr[300100];
long long inv[300010];
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
long long comb(long long nn, long long rr) {
if (rr < 0 || rr > nn || nn < 0) return 0;
long long r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(long long ert) {
pr[0] = 1;
for (long long i = 1; i <= ert; i++) {
pr[i] = ((long long)pr[i - 1] * i) % mod;
}
inv[ert] = beki(pr[ert], mod - 2, mod);
for (long long i = ert - 1; i >= 0; i--) {
inv[i] = (long long)inv[i + 1] * (i + 1) % mod;
}
}
vector<long long> G[100020];
long long dp[20][100020];
long long dep[100020];
void dfs(long long r, long long p, long long dd = 0) {
dp[0][r] = p;
dep[r] = dd;
for (auto v : G[r])
if (v != p) {
dfs(v, r, dd + 1);
}
}
long long lca(long long a, long long b) {
if (dep[a] < dep[b]) swap(a, b);
long long sa = dep[a] - dep[b];
for (long long i = 0; i < 20; i++)
if (sa & (1 << i)) a = dp[i][a];
if (a == b) return a;
for (long long i = 19; i >= 0; i--)
if (dp[i][a] != dp[i][b]) {
a = dp[i][a];
b = dp[i][b];
}
return dp[0][a];
}
long long d(long long a, long long b) {
return dep[a] + dep[b] - 2 * dep[lca(a, b)];
}
void solve() {
long long x, y, a, b, k;
cin >> a >> b >> x >> y >> k;
long long p = d(a, b);
if (p % 2) {
long long len = min(d(x, y), 1 + min(d(a, x) + d(b, y), d(b, x) + d(a, y)));
if (len % 2 != k % 2 || len > k) {
cout << "NO\n";
} else
cout << "YES\n";
} else {
long long moto = d(x, y);
long long ne = 1 + min(d(a, x) + d(b, y), d(b, x) + d(a, y));
long long g;
if (moto % 2 == k % 2) {
g = moto;
} else
g = ne;
if (g <= k)
cout << "YES\n";
else
cout << "NO\n";
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long y, yy;
cin >> y >> yy;
G[y].push_back(yy), G[yy].push_back(y);
}
dfs(1, 1);
for (long long i = 1; i < 20; i++) {
for (long long j = 1; j <= n; j++) dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
long long q;
cin >> q;
for (long long i = 0; i < q; i++) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mo = 1e9 + 7;
int qpow(int a, int b) {
int ans = 1;
for (; b >= 1; b >>= 1, a = (long long)a * a % mo)
if (b & 1) ans = (long long)ans * a % mo;
return ans;
}
int q, n;
int f[N][21], d[N], dl[N], dr[N], idx;
vector<int> G[N];
void dfs(int u, int _f) {
d[u] = d[f[u][0] = _f] + 1;
dl[u] = ++idx;
for (int i = 1; i <= 20; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v != _f) dfs(v, u);
}
}
int lca(int u, int v) {
if (d[u] < d[v]) swap(u, v);
int c = d[u] - d[v];
for (int i = 20; ~i; i--)
if (c >> i & 1) u = f[u][i];
if (u == v) return u;
for (int i = 20; ~i; i--)
if (f[u][i] ^ f[v][i]) u = f[u][i], v = f[v][i];
return f[u][0];
}
int dis(int u, int v) { return d[u] + d[v] - 2 * d[lca(u, v)]; }
bool ok(int x, int y) { return x <= y && (y - x) % 2 == 0; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
scanf("%d", &q);
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 L = dis(x, y), d = dis(a, b);
bool tag = 0;
if (ok(d, k)) tag = 1;
if (ok(dis(a, x) + dis(b, y) + 1, k)) tag = 1;
if (ok(dis(a, y) + dis(b, x) + 1, k)) tag = 1;
puts(tag ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
std::vector<int> adj[200005];
int dp[200005][20], dis[200005] = {0}, tin[200005], tout[200005], tim = 0;
void dfs(int u, int par) {
tin[u] = ++tim;
for (int v : adj[u]) {
if (v == par) continue;
dp[v][0] = u;
dis[v] = dis[u] + 1;
dfs(v, u);
}
tout[u] = ++tim;
}
bool is_ancestor(int u, int v) {
if (tin[u] <= tin[v] && tout[u] >= tout[v]) return true;
return false;
}
int LCA(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = 19; i >= 0; i--) {
if (!is_ancestor(dp[u][i], v)) u = dp[u][i];
}
return dp[u][0];
}
int cal_dis(int a, int b) {
int lca = LCA(a, b);
return dis[a] + dis[b] - 2 * dis[lca];
}
bool solve(long long int x, long long int y, long long int a, long long int b,
long long int k) {
int dist = cal_dis(a, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
dist = cal_dis(a, x) + 1 + cal_dis(y, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
dist = cal_dis(a, y) + 1 + cal_dis(x, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
dp[1][0] = 1;
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) dp[j][i] = dp[dp[j][i - 1]][i - 1];
}
int q;
cin >> q;
while (q--) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (solve(x, y, a, b, k))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int h[N], nex[N << 1], to[N << 1], tot, dis[N];
void add(int x, int y) {
to[++tot] = y;
nex[tot] = h[x];
h[x] = tot;
}
int fa[N][30], dep[N], lg[N];
void dfs(int u, int fath, int d) {
dis[u] = d;
fa[u][0] = fath;
dep[u] = dep[fath] + 1;
for (int i = 1; i <= lg[dep[u]]; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int j = h[u]; j; j = nex[j])
if (to[j] != fath) dfs(to[j], u, d + 1);
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] > dep[y]) x = fa[x][lg[dep[x] - dep[y]] - 1];
if (x == y) return x;
for (int i = lg[dep[x] - 1]; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dfs(1, 0, 0);
int q;
scanf("%d", &q);
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 lcab = lca(a, b);
int d1 = dis[a] + dis[b] - 2 * dis[lcab];
if (k >= d1 && (k % 2) == (d1 % 2)) {
printf("Yes\n");
continue;
}
int lcax = lca(a, x);
int lcay = lca(a, y);
int lcby = lca(b, y);
int lcbx = lca(b, x);
int d2 = dis[x] + dis[a] - 2 * dis[lcax];
int d3 = dis[a] + dis[y] - 2 * dis[lcay];
int d4 = dis[b] + dis[y] - 2 * dis[lcby];
int d5 = dis[b] + dis[x] - 2 * dis[lcbx];
if (k >= (d2 + 1 + d4) && (k % 2) == ((d2 + 1 + d4) % 2)) {
printf("Yes\n");
} else if (k >= (d3 + 1 + d5) && (k % 2) == ((d3 + 1 + d5) % 2)) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v, dp;
vector<int> vis, dep;
int dfs(int x) {
vis[x] = 1;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (vis[y] == 0) {
dp[y][0] = x;
dep[y] = dep[x] + 1;
dfs(y);
}
}
return 0;
}
int lift(int x, int val) {
for (int i = 0; i <= 25; i++) {
if ((1 << i) & val) x = dp[x][i];
}
return x;
}
int lca(int x, int y) {
if (dep[x] > dep[y]) {
x = lift(x, dep[x] - dep[y]);
}
if (dep[y] > dep[x]) {
y = lift(y, dep[y] - dep[x]);
}
if (x == y) {
return x;
} else {
for (int i = 25; i >= 0; i--) {
if (dp[x][i] != dp[y][i]) {
x = dp[x][i];
y = dp[y][i];
}
}
return dp[x][0];
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
v.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dp.resize(n + 1);
for (int i = 0; i <= n; i++) dp[i].resize(26, -1);
vis.resize(n + 1, 0);
dep.resize(n + 1, 0);
dep[1] = 1;
dfs(1);
for (int j = 1; j <= 25; j++) {
for (int i = 1; i <= n; i++) {
int x = dp[i][j - 1];
if (x != -1) {
dp[i][j] = dp[x][j - 1];
}
}
}
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int lc1 = lca(a, b);
int u = dep[a] + dep[b] - 2 * dep[lc1];
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
int lc2 = lca(x, a);
int lc3 = lca(a, y);
int lc4 = lca(x, b);
int lc5 = lca(y, b);
int path1 =
1 + dep[a] + dep[x] - 2 * dep[lc2] + dep[b] + dep[y] - 2 * dep[lc5];
int path2 =
1 + dep[a] + dep[y] - 2 * dep[lc3] + dep[b] + dep[x] - 2 * dep[lc4];
u = path1;
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
u = path2;
if (u <= k && ((k - u) % 2 == 0)) {
cout << "YES"
<< "\n";
continue;
}
cout << "NO"
<< "\n";
continue;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (T i : v) os << i << ", ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
for (T i : v) os << i << " ";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const multiset<T> &v) {
for (T i : v) os << i << " ";
return os;
}
template <class T, class second>
ostream &operator<<(ostream &os, const pair<T, second> &v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class second>
ostream &operator<<(ostream &os, const map<T, second> &v) {
for (auto i : v) os << '(' << i.first << " => " << i.second << ')' << ' ';
return os;
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N = 1e5 + 5;
vector<vector<int>> v(N);
vector<int> par(N), level(N), mx(N, 0);
vector<vector<int>> dp(log2(N) + 5, vector<int>(N));
int n;
void dfs_lca(int a, int par, int lev) {
::par[a] = par;
level[a] = lev;
for (int i : v[a]) {
if (i == par) continue;
dfs_lca(i, a, lev + 1);
}
}
void find_ancestor() {
for (int i = 1; i <= n; i++) {
dp[0][i] = par[i];
}
for (int i = 1; i < dp.size(); i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
}
}
long long lca(int a, int b) {
if (level[b] < level[a]) swap(a, b);
int diff = level[b] - level[a];
while (diff) {
int log = log2(diff);
b = dp[log][b];
diff -= (1 << log);
}
while (a != b) {
int i = log2(level[a]);
while (i > 0 && dp[i][a] == dp[i][b]) i--;
a = dp[i][a];
b = dp[i][b];
}
return a;
}
void compute_lca() {
dfs_lca(1, 0, 0);
find_ancestor();
}
int dis(int a, int b) { return level[a] + level[b] - level[lca(a, b)] * 2; }
void solve() {
compute_lca();
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (level[a] < level[b]) swap(a, b);
int xy = dis(x, y);
int t = dis(a, b);
int t1 = dis(a, x) + dis(b, y) + 1;
int t4 = dis(a, y) + dis(b, x) + 1;
if (t <= k && (k - t) % 2 == 0) {
cout << "YES\n";
continue;
}
if (t1 <= k && (k - t1) % 2 == 0) {
cout << "YES\n";
continue;
}
if (t4 <= k && (k - t4) % 2 == 0) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
}
int main() {
fast();
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int lca[100005][20], depth[100005], in[100005], out[100005], indx;
vector<int> son[100005];
void dfs(int now, int fat) {
in[now] = ++indx;
lca[now][0] = fat;
int i;
depth[now] = depth[fat] + 1;
for (i = 1; i < 20; ++i) lca[now][i] = lca[lca[now][i - 1]][i - 1];
for (i = 0; i < son[now].size(); ++i) {
if (son[now][i] == fat) continue;
dfs(son[now][i], now);
}
out[now] = indx;
}
inline int zz(int x, int y) { return (in[y] >= in[x]) && (out[x] >= out[y]); }
inline int lc(int x, int y) {
int i;
if (depth[x] < depth[y]) swap(x, y);
for (i = 19; ~i; --i) {
if (depth[x] - (1 << i) >= depth[y]) x = lca[x][i];
}
if (x == y) return x;
for (i = 19; ~i; --i) {
if (lca[x][i] != lca[y][i]) {
x = lca[x][i];
y = lca[y][i];
}
}
return lca[x][0];
}
int n, i, q, dis1, dis2, dis3, rr, d, cir, f1, f2, f3, f4, p1, p2, x, y, a, b,
k;
int main() {
scanf("%d", &n);
for (i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
son[x].push_back(y);
son[y].push_back(x);
}
dfs(1, 0);
scanf("%d", &q);
while (q--) {
cin >> x >> y >> a >> b >> k;
dis1 = depth[a] + depth[b] - depth[lc(a, b)] * 2;
dis2 = 1 + depth[a] + depth[x] - 2 * (depth[lc(a, x)]) + depth[b] +
depth[y] - 2 * (depth[lc(b, y)]);
dis3 = 1 + depth[a] + depth[x] - 2 * (depth[lc(a, y)]) + depth[b] +
depth[y] - 2 * (depth[lc(b, x)]);
if (dis1 <= k && (k - dis1) % 2 == 0)
cout << "YES";
else if (dis2 <= k && (k - dis2) % 2 == 0)
cout << "YES";
else if (dis3 <= k && (k - dis2) % 2 == 0)
cout << "YES";
else
cout << "NO";
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 20;
void Dfs_Find_Center_Gravity(int x, vector<int> *a, int n, int *ChildNum,
int *visit, int *ans, int *pos) {
int temp;
for (int i = 0; i < a[x].size(); i++)
if (visit[a[x][i]] == 0) {
visit[a[x][i]] = 1;
Dfs_Find_Center_Gravity(a[x][i], a, n, ChildNum, visit, ans, pos);
temp = max(temp, ChildNum[a[x][i]]);
ChildNum[x] += ChildNum[a[x][i]] + 1;
}
temp = max(temp, n - 1 - ChildNum[x]);
if (temp < *ans) {
*ans = temp;
*pos = x;
}
return;
}
int Find_Center_Gravity(vector<int> *a, int n) {
int ans = n, pos = 0;
int ChildNum[N], visit[N];
memset(ChildNum, 0, sizeof(ChildNum));
memset(visit, 0, sizeof(visit));
visit[1] = 1;
Dfs_Find_Center_Gravity(1, a, n, ChildNum, visit, &ans, &pos);
return pos;
}
void Get_Father(vector<int> *a, int n, int root, int **father, int *depth) {
int visit[N];
memset(visit, 0, sizeof(visit));
visit[root] = 1;
queue<int> Q;
Q.push(root);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < a[x].size(); i++)
if (visit[a[x][i]] == 0) {
visit[a[x][i]] = 1;
father[a[x][i]][0] = x;
Q.push(a[x][i]);
depth[a[x][i]] = depth[x] + 1;
}
}
for (int deep = 0; (1 << deep) < n; deep++)
for (int i = 1; i <= n; i++)
if (father[father[i][deep]][deep] != 0)
father[i][deep + 1] = father[father[i][deep]][deep];
return;
}
int LCA(int x, int y, int **father, int *depth) {
if (depth[x] > depth[y]) swap(x, y);
int delta_depth = depth[y] - depth[x];
int deep = 0;
while (delta_depth) {
if (delta_depth % 2) y = father[y][deep];
deep++;
delta_depth /= 2;
}
if (x == y) return x;
deep = (int)(log(depth[x] - 1) / log(2));
for (int i = deep; i >= 0; i--)
if (father[x][i] != father[y][i]) {
x = father[x][i];
y = father[y][i];
}
return father[x][0];
}
int dist(int x, int y, int **father, int *depth) {
int lca = LCA(x, y, father, depth);
return depth[x] + depth[y] - 2 * depth[lca];
}
int main() {
vector<int> *a = new vector<int>[N];
int *depth = new int[N];
int **father = new int *[N];
for (int i = 0; i < N; i++) {
father[i] = new int[M];
memset(father[i], 0, M * sizeof(int));
}
int n, gra;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
gra = 1;
int root = gra;
memset(depth, 0, sizeof(depth));
depth[root] = 1;
Get_Father(a, n, root, father, depth);
int q;
cin >> q;
while (q--) {
int x, y, a, b, K;
cin >> x >> y >> a >> b >> K;
int length_path_1 = dist(a, b, father, depth);
int length_path_2 =
dist(a, x, father, depth) + 1 + dist(y, b, father, depth);
int length_path_3 =
dist(a, y, father, depth) + 1 + dist(x, b, father, depth);
int length_circle = dist(x, y, father, depth) + 1;
if (K % 2 == length_path_1 % 2 && K >= length_path_1) {
cout << "YES" << endl;
continue;
}
if (K % 2 == length_path_2 % 2 && K >= length_path_2) {
cout << "YES" << endl;
continue;
}
if (K % 2 == length_path_3 % 2 && K >= length_path_3) {
cout << "YES" << endl;
continue;
}
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> parents(vector<vector<long long int>> &G, int n) {
vector<int> Vis(n + 1, 0);
vector<long long int> P(n + 1, 0);
P[1] = -1;
Vis[1] = 1;
queue<long long int> Q;
Q.push(1);
while (!Q.empty()) {
int t = Q.front();
Q.pop();
for (int i = 0; i < G[t].size(); i++) {
int kaim = G[t][i];
if (Vis[kaim] == 0) {
P[kaim] = t;
Q.push(kaim);
Vis[kaim] = 1;
}
}
}
return P;
}
long long int lca(long long int a, long long int b,
vector<vector<long long int>> &P2, vector<long long int> &D) {
if (a == 1 || b == 1) {
return 1;
}
if (D[a] > D[b]) {
swap(a, b);
}
long long int x = D[b] - D[a];
int i = 0;
while (x > 0) {
if (x % 2 == 1) {
b = P2[b][i];
}
i++;
x = x / 2;
}
if (a == b) {
return a;
}
for (int i = 19; i >= 0; i--) {
long long int a1 = P2[a][i];
long long int b1 = P2[b][i];
if (a1 != b1 && a1 > 0 && b1 > 0) {
a = a1;
b = b1;
}
}
return P2[a][0];
}
vector<long long int> atstumai(vector<vector<long long int>> &G, int a) {
vector<long long int> D(G.size(), -1);
queue<long long int> Q;
Q.push(a);
D[a] = 0;
while (!Q.empty()) {
int t = Q.front();
Q.pop();
for (int i = 0; i < G[t].size(); i++) {
int kaim = G[t][i];
if (D[kaim] == -1) {
D[kaim] = D[t] + 1;
Q.push(kaim);
}
}
}
return D;
}
long long int dist(long long int a, long long int b,
vector<vector<long long int>> &P2,
vector<long long int> &D) {
return D[a] + D[b] - 2 * D[lca(a, b, P2, D)];
}
void solve(long long int x, long long int y, long long int a, long long int b,
long long int k, vector<vector<long long int>> &P2,
vector<long long int> &D) {
long long int v = dist(a, b, P2, D);
if (v <= k && (k - v) % 2 == 0) {
cout << "YES" << endl;
return;
}
long long int a2 = dist(a, x, P2, D) + dist(b, y, P2, D) + 1;
if (a2 <= k && (k - a2) % 2 == 0) {
cout << "YES" << endl;
return;
}
long long int a3 = dist(a, y, P2, D) + dist(b, x, P2, D) + 1;
if (a3 <= k && (k - a3) % 2 == 0) {
cout << "YES" << endl;
return;
}
cout << "NO" << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<long long int>> G(n + 1);
for (int i = 0; i < n - 1; i++) {
long long int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
vector<long long int> D = atstumai(G, 1);
vector<long long int> P = parents(G, n);
vector<vector<long long int>> P2(n + 1);
for (int i = 0; i < n + 1; i++) {
P2[i].push_back(P[i]);
}
for (int i = 1; i < 20; i++) {
for (int j = 0; j < n + 1; j++) {
long long int x = P2[j][i - 1];
if (x == -1) {
P2[j].push_back(-1);
} else {
P2[j].push_back(P2[x][i - 1]);
}
}
}
int q;
cin >> q;
for (int f = 0; f < q; f++) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
solve(x, y, a, b, k, P2, D);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int h[N], nxt[N << 1], to[N << 1], sz[N], fa[N], dep[N], bl[N], cnt;
void init() {
memset(h, 0, sizeof h);
cnt = 0;
}
void add(int x, int y) {
to[++cnt] = y;
nxt[cnt] = h[x];
h[x] = cnt;
}
void dfs1(int x) {
sz[x] = 1;
for (int i = h[x]; i; i = nxt[i])
if (to[i] != fa[x]) {
fa[to[i]] = x;
dep[to[i]] = dep[x] + 1;
dfs1(to[i]);
sz[x] += sz[to[i]];
}
}
void dfs2(int x, int c) {
int k = 0;
bl[x] = c;
for (int i = h[x]; i; i = nxt[i])
if (to[i] != fa[x] && sz[to[i]] > sz[k]) k = to[i];
if (!k) return;
dfs2(k, c);
for (int i = h[x]; i; i = nxt[i])
if (to[i] != fa[x] && to[i] != k) dfs2(to[i], to[i]);
}
int lca(int x, int y) {
while (bl[x] != bl[y]) {
if (dep[bl[x]] < dep[bl[y]]) swap(x, y);
x = fa[bl[x]];
}
if (dep[x] < dep[y]) return x;
return y;
}
int dist(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int n, m;
int main() {
scanf("%d", &n);
for (int x, y, i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
dfs1(1);
dfs2(1, 1);
scanf("%d", &m);
while (m--) {
int a, b, k, x, y;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int l = dist(a, b);
int f = min(dist(a, x) + dist(b, y), dist(a, y) + dist(b, x)) + 1;
if ((k >= l && (k - l) % 2 == 0) || (k >= f && (k - f) % 2 == 0))
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 11;
const int max2H = 25;
int n;
vector<int> g[maxn];
int depth[maxn];
int btable[25 + 5][maxn];
int q;
void dfs(int at, int p, int d) {
depth[at] = d;
btable[0][at] = p;
for (auto x : g[at]) {
if (x != p) dfs(x, at, d + 1);
}
}
int findLCA(int a, int b) {
if (depth[a] > depth[b]) swap(a, b);
int diff = depth[b] - depth[a];
for (int j = max2H; j >= 0; j--) {
if ((diff >> j) & 1) {
b = btable[j][b];
}
}
if (a == b) return a;
for (int j = max2H; j >= 0; j--) {
if (btable[j][a] != btable[j][b]) {
a = btable[j][a];
b = btable[j][b];
}
}
return btable[0][a];
}
int dist(int a, int b) {
if (a == b) return 0;
int lca = findLCA(a, b);
return (depth[a] + depth[b] - 2 * depth[lca]);
}
bool poss(int x, int y, int a, int b, int k) {
int curdist = dist(a, b);
if (curdist <= k && curdist % 2 == k % 2) return true;
curdist = dist(a, x) + 1 + dist(b, y);
if (curdist <= k && curdist % 2 == k % 2) return true;
curdist = dist(a, y) + 1 + dist(b, x);
if (curdist <= k && curdist % 2 == k % 2) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(btable, -1, sizeof btable);
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0, 0);
for (int j = 1; j <= max2H; j++) {
for (int i = 1; i <= n; i++) {
if (btable[j - 1][i] != -1) {
btable[j][i] = btable[j - 1][btable[j - 1][i]];
}
}
}
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (poss(x, y, a, b, k)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
int n, d[N], f[N][25], v[N], lg, k, m, tot, head[N], a, b;
void read(int &x) {
long long f = 0;
x = 0;
char ch = getchar();
for (; !(ch >= '0' && ch <= '9'); ch = getchar()) f |= ch == '-';
for (; (ch >= '0' && ch <= '9'); ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
x = (f) ? -x : x;
}
struct data {
int to, next;
} e[N];
void add(int x, int y) {
e[++tot].to = y;
e[tot].next = head[x];
head[x] = tot;
}
void dfs(int x) {
v[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (v[y]) continue;
d[y] = d[x] + 1;
f[y][0] = x;
dfs(y);
}
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
for (int i = lg; i >= 0; i--)
if (d[f[x][i]] >= d[y]) x = f[x][i];
if (x == y) return y;
for (int i = lg; i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
bool q(int g) {
if (g <= k) return (g % 2 == k % 2) ? 1 : 0;
return 0;
}
int ro(int x, int y) {
int root = lca(x, y);
return (d[x] - d[root]) + (d[y] - d[root]);
}
int main() {
read(n);
for (int i = 1; i < n; i++) {
int x, y;
read(x), read(y);
add(x, y);
add(y, x);
}
d[1]++;
f[1][0] = 1;
dfs(1);
lg = 20;
for (int j = 1; j <= lg; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
read(m);
for (int i = 1; i <= m; i++) {
int x, y;
read(x), read(y), read(a), read(b), read(k);
int fi = ro(a, b);
int s = ro(a, x) + ro(y, b) + 1;
int t = ro(a, y) + ro(x, b) + 1;
if (q(fi) || q(s) || q(t))
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod1 = 998244353, mod = 1e9 + 7;
const int MAXN = 1e6 + 6, MAXM = 2e5 + 5;
const int inf = 2e9;
const long long linf = 1e18;
template <class T>
struct RMQ {
vector<vector<T>> spt;
vector<int> lg;
void init(const vector<T> &arr) {
int N = arr.size(), tmp = 1, K = 1;
while (tmp < N) tmp *= 2, ++K;
lg.assign(N, 0);
spt.assign(K, arr);
for (int i = 2; i < N; i++) lg[i] = lg[i / 2] + 1;
for (int i = 1; i < K; i++) {
for (int j = 0; j < N; j++) {
spt[i][j] =
min(spt[i - 1][j], spt[i - 1][min(N - 1, j + (1 << (i - 1)))]);
}
}
}
T query(int l, int r) {
int d = lg[r - l];
return min(spt[d][l], spt[d][r - (1 << d)]);
}
};
struct LCA {
vector<int> st;
vector<int> dep;
vector<pair<int, int>> arr;
int N;
RMQ<pair<int, int>> rmq;
LCA(vector<vector<int>> &adj, int r = 0) {
N = adj.size();
st.resize(N);
dep.resize(N);
arr.reserve(N * 2);
dfs(adj, r, 0);
rmq.init(arr);
}
void dfs(vector<vector<int>> &adj, int u, int p, int h = 0) {
st[u] = arr.size();
dep[u] = h;
arr.emplace_back(h, u);
for (auto v : adj[u])
if (v != p) {
dfs(adj, v, u, h + 1);
arr.emplace_back(h, u);
}
}
int query(int a, int b) {
if (a == b) return a;
a = st[a], b = st[b];
return rmq.query(min(a, b), max(a, b)).second;
}
int dist(int a, int b) {
int lca = query(a, b);
return dep[a] + dep[b] - 2 * dep[lca];
}
};
void Solve() {
int n;
cin >> n;
vector<vector<int>> adj(n, vector<int>());
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
u--;
v--;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
LCA lca(adj);
int q, x, y, a, b, k;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int d1 = lca.dist(a, b);
int d2 = lca.dist(a, x) + lca.dist(b, y) + 1;
int d3 = lca.dist(a, y) + lca.dist(b, x) + 1;
if ((d1 <= k && (k - d1) % 2 == 0) || (d2 <= k && (k - d2) % 2 == 0) ||
(d3 <= k && (k - d3) % 2 == 0)) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
signed main() {
if (fopen(""
".inp",
"r")) {
freopen(
""
".inp",
"r", stdin);
freopen(
""
".out",
"w", stdout);
};
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int TC = 1;
while (TC--) Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e5;
vector<int> adj[mxn + 1];
bool vis[mxn + 1];
int dep[mxn + 1], first[mxn + 1];
int n;
vector<int> euler, t;
void dfs(int v, int d = 0) {
vis[v] = true;
dep[v] = d;
first[v] = euler.size();
euler.push_back(v);
for (int nbr : adj[v]) {
if (!vis[nbr]) {
dfs(nbr, d + 1);
euler.push_back(v);
}
}
}
int minh(int u, int v) {
if (dep[u] < dep[v])
return u;
else
return v;
}
void build() {
for (int i = euler.size() - 1; i > 0; --i)
t[i] = minh(t[i << 1], t[i << 1 | 1]);
}
int query(int l, int r) {
int out = 0;
for (l += euler.size(), r += euler.size(); l < r; l >>= 1, r >>= 1) {
if (l & 1) out = minh(out, t[l++]);
if (r & 1) out = minh(out, t[--r]);
}
return out;
}
int lca(int u, int v) {
int l = min(first[u], first[v]);
int r = max(first[u], first[v]);
return query(l, r + 1);
}
int dist(int u, int v) {
int a = lca(u, v);
return dep[u] + dep[v] - 2 * dep[a];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
dep[0] = INT_MAX;
t.resize(2 * euler.size());
for (int i = 0; i < euler.size(); ++i) t[i + euler.size()] = euler[i];
build();
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int ab = dist(a, b);
if (ab <= k && ab % 2 == k % 2) {
cout << "YES\n";
continue;
}
int via = min(dist(a, x) + dist(b, y) + 1, dist(a, y) + dist(b, x) + 1);
if (via <= k && via % 2 == k % 2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int euler[2 * 100005], fir[100005], dep[100005];
int st[8 * 100005];
int cr = 0, n, q;
vector<int> adj[100005];
void dfs(int i, int p) {
fir[i] = cr;
euler[cr] = i;
cr++;
for (auto x : adj[i]) {
if (x == p) continue;
dep[x] = dep[i] + 1;
dfs(x, i);
euler[cr] = i;
cr++;
}
}
void build(int lo, int hi, int pos) {
if (lo == hi) {
st[pos] = euler[lo];
return;
}
int mid = (lo + hi) / 2;
build(lo, mid, 2 * pos + 1);
build(mid + 1, hi, 2 * pos + 2);
if (dep[st[2 * pos + 1]] > dep[st[2 * pos + 2]]) {
st[pos] = st[2 * pos + 2];
} else {
st[pos] = st[2 * pos + 1];
}
return;
}
int rq(int qlo, int qhi, int lo, int hi, int pos) {
if (qlo > hi || qhi < lo) {
return n;
}
if (qlo <= lo && hi <= qhi) {
return st[pos];
}
int mid = (lo + hi) / 2;
int le = rq(qlo, qhi, lo, mid, 2 * pos + 1);
int ri = rq(qlo, qhi, mid + 1, hi, 2 * pos + 2);
if (dep[le] > dep[ri]) {
return ri;
} else {
return le;
}
}
void swap(int &i, int &j) {
if (i > j) {
int tmp = j;
j = i;
i = tmp;
}
}
int lca(int i, int j) {
i = fir[i];
j = fir[j];
swap(i, j);
return rq(i, j, 0, cr, 0);
}
int dist(int i, int j) {
int z = lca(i, j);
return dep[i] + dep[j] - 2 * dep[z];
}
void query() {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int dis[2];
dis[0] = 2e9;
dis[1] = 2e9;
int d1 = dist(a, b);
dis[d1 % 2] = min(dis[d1 % 2], d1);
d1 = dist(a, x) + dist(y, b) + 1;
dis[d1 % 2] = min(dis[d1 % 2], d1);
d1 = dist(a, y) + dist(x, b) + 1;
dis[d1 % 2] = min(dis[d1 % 2], d1);
if (dis[k % 2] <= k) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
return;
}
void solve() {
cin >> n;
for (long long i = (long long)1; i != (long long)n; i = i + 1) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dep[0] = 0;
dep[n] = 2e9;
dfs(0, -1);
build(0, cr, 0);
cin >> q;
for (long long i = (long long)0; i != (long long)q; i = i + 1) {
query();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
long long int inf = 9 * 1e18;
long long int begtime = clock();
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cout << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cout << " | ";
else
cout << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cout << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
long long int n, m;
long long int binpow(long long int val, long long int deg) {
if (deg < 0) return 0;
if (!deg) return 1 % M;
if (deg & 1) return binpow(val, deg - 1) * val % M;
long long int res = binpow(val, deg >> 1);
return (res * res) % M;
}
long long int modinv(long long int n) { return binpow(n, M - 2); }
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 l;
vector<vector<long long int>> adj;
long long int timer;
vector<long long int> tin, tout;
vector<vector<long long int>> up;
void dfs(long long int vector, long long int p) {
tin[vector] = ++timer;
up[vector][0] = p;
for (long long int i = 1; i <= l; ++i)
up[vector][i] = up[up[vector][i - 1]][i - 1];
for (long long int u : adj[vector]) {
if (u != p) dfs(u, vector);
}
tout[vector] = ++timer;
}
bool is_ancestor(long long int u, long long int vector) {
return tin[u] <= tin[vector] && tout[u] >= tout[vector];
}
long long int lca(long long int u, long long int vector) {
if (is_ancestor(u, vector)) return u;
if (is_ancestor(vector, u)) return vector;
for (long long int i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], vector)) u = up[u][i];
}
return up[u][0];
}
void preprocess(long long int root) {
tin.resize(n);
tout.resize(n);
timer = 0;
l = ceil(log2(n));
up.assign(n, vector<long long int>(l + 1));
dfs(root, root);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, t, k, x, y, z, N;
cin >> n;
adj.resize(n);
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
preprocess(0);
queue<long long int> q;
vector<long long int> used(n, 0);
vector<long long int> d(n, inf), p(n, -1);
long long int s = 0;
q.push(s);
used[s] = 1;
d[s] = 0;
while (!q.empty()) {
long long int V = q.front();
q.pop();
for (long long int u : adj[V]) {
if (!used[u]) {
used[u] = 1;
q.push(u);
d[u] = d[V] + 1;
p[u] = V;
}
}
}
long long int m;
cin >> m;
for (i = 0; i < m; i++) {
long long int a, b;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
long long int d1 = d[a] + d[b] - 2 * d[lca(a, b)];
long long int flg = 0;
if (d1 <= k) {
if ((k - d1) % 2 == 0) flg = 1;
}
long long int d2 = d[x] + d[a] - 2 * d[lca(a, x)];
long long int d3 = d[y] + d[b] - 2 * d[lca(b, y)];
long long int dum = d2 + d3 + 1;
if (dum <= k) {
if ((k - dum) % 2 == 0) flg = 1;
}
d2 = d[x] + d[b] - 2 * d[lca(b, x)];
d3 = d[y] + d[a] - 2 * d[lca(a, y)];
dum = d2 + d3 + 1;
if (dum <= k) {
if ((k - dum) % 2 == 0) flg = 1;
}
if (flg)
cout << "YES\n";
else
cout << "NO\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);
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;
int n, q;
struct edge {
int next, v;
} edges[100005 * 2];
int cnt;
int head[100005];
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
}
void addedge(int u, int v) {
edges[cnt].next = head[u];
edges[cnt].v = v;
head[u] = cnt++;
}
int dep[100005];
int f[100005][21];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
for (int i = 0; i <= 19; i++) f[u][i + 1] = f[f[u][i]][i];
for (int i = head[u]; i != -1; i = edges[i].next) {
int v = edges[i].v;
if (v == fa) 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(int a, int b) { return dep[a] + dep[b] - 2 * dep[lca(a, b)]; }
int main() {
scanf("%d", &n);
int x, y;
init();
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
dfs(1, 0);
scanf("%d", &q);
int aa, bb, a, b, k, res, ress, resss;
while (q--) {
scanf("%d%d%d%d%d", &aa, &bb, &a, &b, &k);
res = dis(a, b);
ress = dis(a, aa) + dis(b, bb) + 1;
resss = dis(a, bb) + dis(b, aa) + 1;
if (k >= res && (k - res) % 2 == 0) {
printf("YES\n");
} else if (k >= ress && (k - ress) % 2 == 0) {
printf("YES\n");
} else if (k >= resss && (k - resss) % 2 == 0) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
inline int rd() {
int first = 0;
char p = getchar();
while (p < '0' || p > '9') p = getchar();
while (p >= '0' && p <= '9') first = first * 10 + p - '0', p = getchar();
return first;
}
const int N = 1e6 + 50;
int n, m, s, sz[N], dep[N];
int L[N], R[N], fa[N], son[N], top[N];
vector<int> g[N];
void dfs(int first, int d, int f) {
sz[first] = 1, fa[first] = f, dep[first] = d;
for (int second : g[first])
if (second != f) {
dfs(second, d + 1, first), sz[first] += sz[second];
if (sz[second] > sz[son[first]]) son[first] = second;
}
}
void dfs(int first, int tf) {
top[first] = tf;
if (son[first]) dfs(son[first], tf);
for (int second : g[first])
if (!top[second]) dfs(second, second);
}
int lca(int first, int second) {
while (top[first] != top[second]) {
if (dep[top[first]] < dep[top[second]]) swap(first, second);
first = fa[top[first]];
}
return dep[first] < dep[second] ? first : second;
}
int dis(int first, int second) {
return dep[first] + dep[second] - 2 * dep[lca(first, second)];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0, 0), dfs(1, 1);
int q;
scanf("%d", &q);
while (q--) {
int first, second, a, b, k;
scanf("%d%d%d%d%d", &first, &second, &a, &b, &k);
int d1 = dis(a, b);
if (d1 <= k && d1 % 2 == k % 2) {
puts("YES");
continue;
}
int d2 = dis(a, first) + 1 + dis(second, b);
if (d2 <= k && d2 % 2 == k % 2) {
puts("YES");
continue;
}
int d3 = dis(a, second) + 1 + dis(first, b);
if (d3 <= k && d3 % 2 == k % 2) {
puts("YES");
continue;
}
if (d2 > d3) swap(d2, d3);
int c = d3 - d1;
if (c % 2 == 1) {
puts("NO");
continue;
}
if (k - d1 >= c && (k - d1 - c) % 2 == 0 ||
k - d2 >= c && (k - d2 - c) % 2 == 0)
puts("YES");
else
puts("NO");
}
}
|
#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;
int step[maxl][100000];
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<int> tin(n), tout(n), depth(n, -1);
int time = 0;
function<void(int, int)> dfs = [&](int v, int p) {
step[0][v] = p;
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);
for (int l = 0; l < maxl - 1; l++)
for (int v = 0; v < n; v++) step[l + 1][v] = step[l][step[l][v]];
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[i][u], v)) u = step[i][u];
return step[0][u];
};
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>
using namespace std;
const int maxn = 1e5 + 50;
int cnt, ans, disx, n, m;
int a, b, x, y, k;
int head[maxn];
int fa[maxn][22];
int lg[maxn];
int depth[maxn];
int res[maxn];
bool vis[maxn];
struct edge {
int t, nex;
};
edge e[maxn << 1];
void add(int a, int b) {
e[++cnt].t = b;
e[cnt].nex = head[a];
head[a] = cnt;
}
void dfs(int f, int fath) {
depth[f] = depth[fath] + 1;
fa[f][0] = fath;
for (int i = 1; (1 << i) <= depth[f]; i++) fa[f][i] = fa[fa[f][i - 1]][i - 1];
for (int i = head[f]; i; i = e[i].nex)
if (e[i].t != fath) dfs(e[i].t, f);
}
int lca(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
while (depth[x] > depth[y]) x = fa[x][lg[depth[x] - depth[y]] - 1];
if (x == y) return x;
for (int k = lg[depth[x]] - 1; k >= 0; k--)
if (fa[x][k] != fa[y][k]) x = fa[x][k], y = fa[y][k];
return fa[x][0];
}
int cal(int x, int y) { return depth[x] + depth[y] - 2 * depth[lca(x, y)]; }
int main() {
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d %d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
cin >> m;
for (int i = 1; i <= m; ++i) {
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int disab = cal(a, b);
if (disab <= k && abs(disab - k) % 2 == 0) {
printf("YES\n");
continue;
}
int disax = cal(a, x);
int disby = cal(b, y);
int tot1 = disax + disby + 1;
if (tot1 <= k && abs(tot1 - k) % 2 == 0) {
printf("YES\n");
continue;
}
int disay = cal(a, y);
int disbx = cal(b, x);
int tot2 = disay + disbx + 1;
if (tot2 <= k && abs(tot2 - k) % 2 == 0) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int LGN = 17;
vector<int> g[N];
int d[N], par[N][LGN];
void dfs(int v, int p) {
d[v] = d[p] + 1;
par[v][0] = p;
for (auto u : g[v]) {
if (u != p) dfs(u, v);
}
}
inline int dist(int u, int v) {
int x = u, y = v;
if (d[x] < d[y]) swap(x, y);
int diff = d[x] - d[y];
for (int i = 0; i < LGN; i++) {
if (diff & (1 << i)) x = par[x][i];
}
if (x == y) return d[u] + d[v] - 2 * d[x];
for (int i = LGN - 1; i >= 0; i--) {
if (par[x][i] != par[y][i]) {
x = par[x][i];
y = par[y][i];
}
}
x = par[x][0];
return d[u] + d[v] - 2 * d[x];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << setprecision(32);
int n, u, v;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
for (int k = 1; k < LGN; k++) {
for (int i = 1; i <= n; i++) {
par[i][k] = par[par[i][k - 1]][k - 1];
}
}
int q, x, y, k, a, b;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
int d1 = dist(a, b);
int d2 = dist(a, x) + 1 + dist(y, b);
int d3 = dist(a, y) + 1 + dist(x, b);
if (d1 <= k && (d1 % 2) == (k % 2)) {
cout << "YES" << '\n';
continue;
}
if (d2 <= k && (d2 % 2) == (k % 2)) {
cout << "YES" << '\n';
continue;
}
if (d3 <= k && (d3 % 2) == (k % 2)) {
cout << "YES" << '\n';
continue;
}
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
const int nax = 1 << 17;
const int LOG = 17;
vector<int> G[nax];
int N, Q;
int in[nax], out[nax], dep[nax];
int jmp[nax][LOG + 1];
int TIME;
void dfs(int v, int p) {
in[v] = ++TIME;
jmp[v][0] = p;
for (int i = 1; i <= LOG; ++i) jmp[v][i] = jmp[jmp[v][i - 1]][i - 1];
for (int ch : G[v]) {
if (ch == p) continue;
dep[ch] = dep[v] + 1;
dfs(ch, v);
}
out[v] = ++TIME;
}
inline bool is_ancestor(int u, int v) {
return in[u] <= in[v] && out[u] >= out[v];
}
int lca(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = LOG; i >= 0; --i)
if (!is_ancestor(jmp[u][i], v)) u = jmp[u][i];
return jmp[u][0];
}
inline int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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, 1);
cin >> Q;
for (int tt = 1; tt <= Q; ++tt) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int bef = dist(a, b);
int aft = min(dist(a, x) + dist(y, b), dist(a, y) + dist(x, b)) + 1;
int valid_dist = 1e9 + 10;
if (bef % 2 == k % 2) uin(valid_dist, bef);
if (aft % 2 == k % 2) uin(valid_dist, aft);
cout << (valid_dist <= k ? "YES" : "NO") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, l, timer = 0;
vector<long long int> adj[100005];
vector<vector<long long int> > up(100005, vector<long long int>(20));
vector<long long int> tin(100005), tout(100005), dist(100005, 0);
void dfs(long long int v, long long int p) {
tin[v] = ++timer;
up[v][0] = p;
for (long long int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (long long int u : adj[v]) {
if (u != p) {
dist[u] = dist[v] + 1LL;
dfs(u, v);
}
}
tout[v] = ++timer;
}
bool is_ancestor(long long int u, long long int v) {
return ((tin[u] <= tin[v]) && (tout[u] >= tout[v]));
}
long long int lca(long long int u, long long int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (long long int i = l; i >= 0; i--) {
if (!is_ancestor(up[u][i], v)) u = up[u][i];
}
return up[u][0];
}
long long int length(long long int u, long long int v) {
long long int req = lca(u, v);
return (dist[u] + dist[v] - 2 * dist[req]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long int i = 0; i <= n - 2; i++) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
timer = 0;
l = ceil(log2(n));
long long int root = 1;
dfs(root, root);
long long int w;
cin >> w;
while (w--) {
long long int x, y, a, b, k;
cin >> a >> b >> x >> y >> k;
long long int dis = length(x, y);
if (dis <= k && ((dis % 2) == (k % 2))) {
cout << "YES" << '\n';
continue;
}
dis = length(x, a) + length(y, b) + 1LL;
if (dis <= k && ((dis % 2) == (k % 2))) {
cout << "YES" << '\n';
continue;
}
dis = length(x, b) + length(y, a) + 1LL;
if (dis <= k && ((dis % 2) == (k % 2))) {
cout << "YES" << '\n';
continue;
}
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int begin, end, next;
} edge[100010 * 2 + 10];
int cnt, Head[100010], P[100010][19], deep[100010], n;
void addedge(int bb, int ee) {
edge[++cnt].begin = bb;
edge[cnt].end = ee;
edge[cnt].next = Head[bb];
Head[bb] = cnt;
}
void addedge1(int bb, int ee) {
addedge(bb, ee);
addedge(ee, bb);
}
void dfs(int u, int fa) {
int i, v;
for (i = Head[u]; i != -1; i = edge[i].next) {
v = edge[i].end;
if (v == fa) continue;
P[v][0] = u;
deep[v] = deep[u] + 1;
dfs(v, u);
}
}
void Ycl() {
int i, j;
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 x, int y) {
int i, j;
if (deep[x] < deep[y]) swap(x, y);
for (i = 0; (1 << i) <= deep[x]; i++)
;
i--;
for (j = i; j >= 0; j--)
if (deep[x] - (1 << j) >= deep[y]) x = P[x][j];
if (x == y) return x;
for (j = i; j >= 0; j--) {
if (P[x][j] != -1 && P[x][j] != P[y][j]) {
x = P[x][j];
y = P[y][j];
}
}
return P[x][0];
}
int DIS(int x, int y) {
int z = LCA(x, y);
return deep[x] + deep[y] - 2 * deep[z];
}
int main() {
int i, u, v, TT, x, y, a, b, k, jl;
scanf("%d", &n);
memset(Head, -1, sizeof(Head));
cnt = 1;
for (i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
addedge1(u, v);
}
memset(P, -1, sizeof(P));
memset(deep, 0, sizeof(deep));
dfs(1, 0);
Ycl();
scanf("%d", &TT);
while (TT--) {
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
jl = DIS(a, b);
if (k >= jl && (k - jl) % 2 == 0) {
printf("YES\n");
continue;
}
jl = DIS(a, x) + 1 + DIS(y, b);
if (k >= jl && (k - jl) % 2 == 0) {
printf("YES\n");
continue;
}
jl = DIS(a, y) + 1 + DIS(x, b);
if (k >= jl && (k - jl) % 2 == 0) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 1000007;
const long long MOD = 1004535809;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const long long P = 19260817;
int n, Q;
struct edge {
int v, nxt;
} e[maxn << 1];
int sz[maxn];
int son[maxn];
int fa[maxn], dep[maxn];
int top[maxn];
int cnt;
int head[maxn];
void addedge(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = head[u];
head[u] = cnt;
}
void dfs1(int u, int f) {
fa[u] = f;
dep[u] = dep[f] + 1;
son[u] = 0;
sz[u] = 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs1(v, u);
sz[u] += sz[v];
if (son[u] == 0 || sz[v] > sz[son[u]]) {
son[u] = v;
}
}
}
void dfs2(int u, int t) {
top[u] = t;
if (son[u]) dfs2(son[u], t);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa[u] || v == son[u]) continue;
dfs2(v, v);
}
}
int lca(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
int dis(int x, int y) {
if (x == y) return 0;
return dep[x] + dep[y] - 2 * dep[lca(x, y)];
}
int d[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dfs1(1, 0);
dfs2(1, 1);
scanf("%d", &Q);
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 xa = dis(a, x), xb = dis(b, x), ya = dis(a, y), yb = dis(b, y),
xy = dis(x, y), ab = dis(a, b);
d[1] = ab;
d[2] = min(xa + yb, xb + ya) + 1;
int dr = xy + 1;
int da = (xa + ya - xy) / 2, db = (xb + yb - xy) / 2;
d[3] = dr - (d[2] - da - db) + da + db;
d[4] = d[1] + dr + 2 * min(da, db);
int f = 0;
for (int i = 1; i <= 4; i++) {
if (!f && k >= d[i] && ((d[i] ^ k) & 1) == 0) {
printf("YES\n");
f = 1;
}
}
if (!f) puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int h = 22;
const int maxn = 100228;
bool used[maxn];
vector<int> g[maxn];
int tin[maxn];
int tout[maxn];
int hi[maxn];
int la[maxn][h];
int t = 0;
bool check(int u, int v) { return tin[u] <= tin[v] && tin[v] <= tout[u]; }
void dfs(int root) {
for (int cur = 1; cur < h; cur++) {
la[root][cur] = la[la[root][cur - 1]][cur - 1];
}
t++;
tin[root] = t;
for (int to : g[root]) {
if (!used[to]) {
hi[to] = hi[root] + 1;
used[to] = true;
la[to][0] = root;
dfs(to);
}
}
t++;
tout[root] = t;
}
int lca(int v, int u) {
if (check(v, u)) {
return v;
}
if (check(u, v)) {
return u;
}
for (int cur = h - 1; cur >= 0; cur--) {
if (!check(la[v][cur], u)) {
v = la[v][cur];
}
}
return la[v][0];
}
int dist(int a, int b) {
int l = lca(a, b);
return abs(hi[a] - hi[l]) + abs(hi[b] - hi[l]);
}
signed main() {
int i, j, n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
used[0] = true;
dfs(0);
int q;
cin >> q;
for (i = 0; i < q; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
if (dist(a, b) <= k && (abs(dist(a, b) - k) % 2 == 0)) {
cout << "YES" << '\n';
} else {
int ans1 = dist(a, x) + dist(y, b) + 1;
int ans2 = dist(a, y) + dist(x, b) + 1;
if (min(ans1, ans2) <= k && (abs(min(ans1, ans2) - k) % 2 == 0)) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
using namespace std;
std::vector<int> adj[200005];
int dp[200005][20], dis[200005] = {0}, tin[200005], tout[200005], tim = 0;
void dfs(int u, int par) {
dp[u][0] = par;
tin[u] = ++tim;
for (int v : adj[u]) {
if (v == par) continue;
dis[v] = dis[u] + 1;
dfs(v, u);
}
tout[u] = ++tim;
}
bool is_ancestor(int u, int v) {
if (tin[u] <= tin[v] && tout[u] >= tout[v]) return true;
return false;
}
int LCA(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = 19; i >= 0; i--) {
if (!is_ancestor(dp[u][i], v)) u = dp[u][i];
}
return dp[u][0];
}
int cal_dis(int a, int b) {
int lca = LCA(a, b);
return dis[a] + dis[b] - 2 * dis[lca];
}
bool solve(long long int x, long long int y, long long int a, long long int b,
long long int k) {
int dist = cal_dis(a, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
dist = cal_dis(a, x) + 1 + cal_dis(y, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
dist = cal_dis(a, y) + 1 + cal_dis(x, b);
if (k >= dist && (k - dist) % 2 == 0) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) dp[j][i] = dp[dp[j][i - 1]][i - 1];
}
int q;
cin >> q;
while (q--) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (solve(x, y, a, b, k))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
constexpr ll inf = 0x3FFFFFFFFFFFFF;
struct SparseTable {
vector<vector<int>> st;
vector<int> log;
vector<ll> *a;
bool better(int lidx, int ridx) { return a->at(lidx) <= a->at(ridx); }
void init(vector<ll> *vec) {
a = vec;
log.assign((ll)(*a).size() + 1, 0);
for (int i = 2; i <= (ll)(*a).size(); i++) log[i] = log[i / 2] + 1;
st.assign((ll)(*a).size(), vector<int>(log.back() + 1));
for (int i = 0; i < (ll)(*a).size(); i++) st[i][0] = i;
for (int j = 1; j <= log.back(); j++) {
for (int i = 0; i + (1 << j) <= (ll)(*a).size(); i++) {
st[i][j] = better(st[i][j - 1], st[i + (1 << (j - 1))][j - 1])
? st[i][j - 1]
: st[i + (1 << (j - 1))][j - 1];
}
}
}
int queryIdempotent(int l, int r) {
int j = log[r - l];
return better(st[l][j], st[r - (1 << j)][j]) ? st[l][j]
: st[r - (1 << j)][j];
}
};
struct LCA {
vector<ll> depth;
vector<int> visited, first;
int idx;
SparseTable st;
void init(vector<vector<int>> &g, int root) {
depth.assign(2 * (ll)(g).size(), 0);
visited.assign(2 * (ll)(g).size(), -1);
first.assign((ll)(g).size(), 2 * (ll)(g).size());
idx = 0;
visit(g, root);
st.init(&depth);
}
void visit(vector<vector<int>> &g, int v, ll d = 0, int p = -1) {
visited[idx] = v, depth[idx] = d;
first[v] = min(idx, first[v]), idx++;
for (int w : g[v]) {
if (w != p && first[w] == 2 * (ll)(g).size()) {
visit(g, w, d + 1, v);
visited[idx] = v, depth[idx] = d, idx++;
}
}
}
int getLCA(int a, int b) {
if (first[a] > first[b]) swap(a, b);
return visited[st.queryIdempotent(first[a], first[b] + 1)];
}
int getDist(int a, int b) {
int lca = getLCA(a, b);
return abs(depth[first[a]] - depth[first[lca]]) +
abs(depth[first[b]] - depth[first[lca]]);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
LCA lca;
lca.init(adj, 0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
ll x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
bool ok = false;
auto check = [&](int d) {
if (d <= k && (k - d) % 2 == 0) ok = true;
};
check(lca.getDist(a, b));
check(lca.getDist(a, x) + 1 + lca.getDist(y, b));
check(lca.getDist(a, y) + 1 + lca.getDist(x, b));
cout << (ok ? "YES" : "NO") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class segtree {
private:
int n, sz;
vector<pair<T, int> > node;
public:
void resize(vector<T>& v) {
sz = (int)v.size();
n = 1;
while (n < sz) {
n *= 2;
}
node.resize(2 * n);
for (int i = 0; i < sz; i++) {
node[i + n] = make_pair(v[i], i);
}
for (int i = n - 1; i >= 1; i--) {
node[i] = min(node[2 * i], node[2 * i + 1]);
}
}
void update(int k, T a) {
node[k += n] = make_pair(a, k);
while (k >>= 1) {
node[k] = min(node[2 * k], node[2 * k + 1]);
}
}
pair<T, int> query(int a, int b) {
pair<T, int> res1 = make_pair(numeric_limits<T>::max(), -1);
pair<T, int> res2 = make_pair(numeric_limits<T>::max(), -1);
a += n, b += n;
while (a != b) {
if (a % 2) res1 = min(res1, node[a++]);
if (b % 2) res2 = min(res2, node[--b]);
a >>= 1, b >>= 1;
}
return min(res1, res2);
}
};
class LCA {
private:
int V;
vector<vector<int> > G;
vector<int> ord, depth, id;
segtree<int> st;
void dfs(int u, int p, int k) {
id[u] = (int)ord.size();
ord.push_back(u);
depth[u] = k;
for (int v : G[u]) {
if (v != p) {
dfs(v, u, k + 1);
ord.push_back(u);
}
}
}
public:
LCA(int node_size) : V(node_size), G(V), depth(V), id(V, -1) {}
void add_edge(int from, int to) {
G[from].push_back(to), G[to].push_back(from);
}
void build() {
ord.reserve(2 * V - 2);
for (int i = 0; i < V; i++) {
if (id[i] < 0) {
dfs(i, -1, 0);
}
}
vector<int> stvec(2 * V - 2);
for (int i = 0; i < 2 * V - 2; i++) {
stvec[i] = depth[ord[i]];
}
st.resize(stvec);
}
int lca(int u, int v) {
return ord[st.query(min(id[u], id[v]), max(id[u], id[v]) + 1).second];
}
int dist(int u, int v) {
int lca_ = lca(u, v);
return depth[u] + depth[v] - 2 * depth[lca_];
}
};
void solve();
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int t = 1;
for (int _ = 0; _ < t; _++) solve();
return 0;
}
void solve() {
int n;
cin >> n;
LCA G(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--, b--;
G.add_edge(a, b);
}
G.build();
int q;
cin >> q;
for (int _ = 0; _ < q; _++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
int d = G.dist(a, b);
if (k >= d and (k - d) % 2 == 0) {
cout << "YES" << '\n';
} else {
int d2 = min(G.dist(a, x) + G.dist(y, b), G.dist(a, y) + G.dist(x, b));
d2++;
if (k >= d2 and (k - d2) % 2 == 0) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
return;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 41;
const int mod = 1e9 + 7;
const int inf = 1e9 + 90;
const long long INF = 1e18;
vector<int> g[N];
int tin[N], tout[N], up[N][20], d[N], timer, a, b;
void dfs(int v = 1, int p = 1) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i <= 18; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (int to : g[v])
if (to != p) {
d[to] = d[v] + 1;
dfs(to, v);
}
tout[v] = ++timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = 18; i >= 0; --i) {
if (!upper(up[a][i], b)) {
a = up[a][i];
}
}
return up[a][0];
}
int dist(int a, int b) { return d[a] + d[b] - 2 * d[lca(a, b)]; }
bool ok(int dist1, int dist2) {
return dist1 >= dist2 && ((dist1 & 1) == (dist2 & 1));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
;
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs();
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
bool res = 0;
res |= ok(k, dist(a, b));
res |= ok(k, dist(a, x) + 1 + dist(y, b));
res |= ok(k, dist(a, y) + 1 + dist(x, b));
res |= ok(k, dist(x, y) + 1 + dist(a, x) + dist(x, b));
res |= ok(k, dist(x, y) + 1 + dist(a, y) + dist(y, b));
cout << (res ? "YES\n" : "NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> adj[N];
int lvl[N], anc[N][25];
int n;
void dfs(int u = 0, int par = 0, int l = 0) {
lvl[u] = l;
anc[u][0] = par;
for (auto nxt : adj[u])
if (nxt != par) dfs(nxt, u, l + 1);
}
void buildLCA() {
int lg = ceil(log2(n));
for (int j = 1; j < lg; j++)
for (int i = 0; i < n; i++) anc[i][j] = anc[anc[i][j - 1]][j - 1];
}
int LCA(int i, int j) {
int lg = ceil(log2(n));
int st = lg;
if (lvl[i] > lvl[j]) swap(i, j);
int cur = lvl[j];
for (; st >= 0; st--)
if (cur - (1 << st) >= lvl[i]) cur -= (1 << st), j = anc[j][st];
if (i == j) return 2 * i - j;
cur = lvl[i];
for (st = lg; st >= 0; st--)
if (anc[i][st] != anc[j][st])
cur -= (1 << st), i = anc[i][st], j = anc[j][st];
return anc[i][0];
}
int dis(int a, int b) { return lvl[a] + lvl[b] - 2 * lvl[LCA(a, b)]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n;
int a, b;
for (int i = 0; i < int(n - 1); i++) {
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs();
buildLCA();
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> a >> b >> x >> y >> k;
x--, y--, a--, b--;
{
int d = dis(x, y);
if (d <= k && (k - d) % 2 == 0) {
cout << "YES" << '\n';
continue;
}
}
{
int d = dis(x, a) + dis(y, b) + 1;
if (d <= k && (k - d) % 2 == 0) {
cout << "YES" << '\n';
continue;
}
}
{
int d = dis(x, b) + dis(y, a) + 1;
if (d <= k && (k - d) % 2 == 0) {
cout << "YES" << '\n';
continue;
}
}
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dep[111111];
pair<int, int> dp[111111][18];
vector<int> v[111111];
void recur(int now, int left, int num) {
dep[now] = num;
dp[now][0] = make_pair(left, 1);
for (int e = 0; e < v[now].size(); e++) {
int next = v[now][e];
if (next != left) {
recur(next, now, num + 1);
}
}
}
int getdist(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int diff = dep[a] - dep[b];
int num = 0, dist = 0;
for (; diff != 0;) {
if (diff % 2) {
dist += dp[a][num].second;
a = dp[a][num].first;
}
num++;
diff /= 2;
}
if (a != b) {
for (int p = 17; p >= 0; p--) {
if (dp[a][p].first != dp[b][p].first) {
dist += dp[a][p].second;
dist += dp[b][p].second;
a = dp[a][p].first;
b = dp[b][p].first;
}
}
dist += dp[a][0].second;
dist += dp[b][0].second;
a = dp[a][0].first;
b = dp[b][0].first;
}
return dist;
}
bool can(int x, int y, int a) {
int f1 = getdist(x, y);
int a1 = getdist(x, a), a2 = getdist(y, a);
if (a1 + a2 == f1) return true;
return false;
}
int main(void) {
memset(dp, -1, sizeof(dp));
int n;
scanf("%d", &n);
for (int e = 0; e < n - 1; e++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
recur(1, -1, 1);
for (int e = 1; e < 18; e++) {
for (int p = 1; p <= n; p++) {
if (dp[p][e - 1].first != -1) {
dp[p][e].first = dp[dp[p][e - 1].first][e - 1].first;
dp[p][e].second =
dp[dp[p][e - 1].first][e - 1].second + dp[p][e - 1].second;
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &a, &b, &x, &y, &k);
int f1 = getdist(x, y);
if (f1 <= k && (k - f1) % 2 == 0) {
printf("YES\n");
continue;
} else {
int a1 = getdist(a, x) + 1 + getdist(b, y);
int a2 = getdist(a, y) + 1 + getdist(b, x);
if (a1 <= k && (k - a1) % 2 == 0)
printf("YES\n");
else if (a2 <= k && (k - a2) % 2 == 0)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, q, f[maxn][25], h[maxn];
struct node {
int nxt, to;
} v[maxn << 1];
int head[maxn << 1], cnt = 1, lg[500001];
void add(int from, int to) {
v[cnt].to = to;
v[cnt].nxt = head[from];
head[from] = cnt++;
}
int lca(int x, int y) {
if (h[x] < h[y]) swap(x, y);
while (h[x] > h[y]) x = f[x][lg[h[x] - h[y]] - 1];
if (x == y) return x;
for (int k = lg[h[x]] - 1; k >= 0; --k)
if (f[x][k] != f[y][k]) x = f[x][k], y = f[y][k];
return f[x][0];
}
int solve(int x, int y) { return h[x] + h[y] - h[lca(x, y)] * 2; }
void dfs(int now, int fath) {
f[now][0] = fath;
h[now] = h[fath] + 1;
for (int i = 1; i <= lg[h[now]]; ++i) f[now][i] = f[f[now][i - 1]][i - 1];
for (int i = head[now]; i; i = v[i].nxt)
if (v[i].to != fath) dfs(v[i].to, now);
}
bool check(int x, int y) {
if (y >= x && ((x % 2) == (y % 2))) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
add(u, v);
add(v, u);
}
dfs(1, 0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 20; j++) f[i][j] = f[f[i][j - 1]][j - 1];
cin >> q;
for (int i = 0; i < q; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int X = solve(a, b), Y = solve(a, x) + solve(y, b) + 1,
Z = solve(a, y) + solve(x, b) + 1;
if (check(X, k) || check(Y, k) || check(Z, k))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
const int mod = 1e9 + 7;
vector<int> g[N];
int par[N][20], dep[N], sz[N], st[N], en[N], T;
void dfs(int u, int pre) {
par[u][0] = pre;
dep[u] = dep[pre] + 1;
st[u] == ++T;
sz[u] = 1;
for (int i = 1; i <= 18; i++) par[u][i] = par[par[u][i - 1]][i - 1];
for (auto v : g[u]) {
if (v == pre) continue;
dfs(v, u);
sz[u] += sz[v];
}
en[u] = T;
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int k = 18; k >= 0; k--)
if (dep[par[u][k]] >= dep[v]) u = par[u][k];
if (u == v) return u;
for (int k = 18; k >= 0; k--)
if (par[u][k] != par[v][k]) u = par[u][k], v = par[v][k];
return par[u][0];
}
int kth(int u, int k) {
assert(k >= 0);
for (int i = 0; i <= 18; i++)
if (k & (1 << i)) u = par[u][i];
return u;
}
int dist(int u, int v) {
int lc = lca(u, v);
return dep[u] + dep[v] - 2 * dep[lc];
}
int isanc(int u, int v) { return st[u] <= st[v] && en[v] <= en[u]; }
int nearest(int u, int v, int x) {
int lc = lca(u, v);
int d = dist(u, lc);
int l = 0, r = d, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (isanc(kth(u, mid), x)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans != -1) return kth(u, ans);
l = 0, r = dist(v, lc), ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (isanc(kth(v, mid), x)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans != -1) return kth(v, ans);
return lc;
}
int32_t main() {
int n = ({
int a;
scanf("%d", &a);
a;
});
for (int i = 1; i < n; i++) {
int u = ({
int a;
scanf("%d", &a);
a;
}),
v = ({
int a;
scanf("%d", &a);
a;
});
g[u].emplace_back(v);
g[v].emplace_back(u);
}
dfs(1, 0);
int q = ({
int a;
scanf("%d", &a);
a;
});
while (q--) {
int x = ({
int a;
scanf("%d", &a);
a;
}),
y = ({
int a;
scanf("%d", &a);
a;
}),
u = ({
int a;
scanf("%d", &a);
a;
}),
v = ({
int a;
scanf("%d", &a);
a;
}),
k = ({
int a;
scanf("%d", &a);
a;
});
int ans = 0;
int d = dist(u, v);
if (d <= k && d % 2 == k % 2) ans = 1;
int p = nearest(x, y, u), q = nearest(x, y, v);
int trial = dist(u, p) + dist(p, q) + dist(q, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, p) + dist(x, y) + 1 - dist(p, q) + dist(q, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, q) + dist(p, q) + dist(p, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, q) + dist(x, y) + 1 - dist(p, q) + dist(p, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, x) + dist(x, y) + dist(y, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, y) + dist(x, y) + dist(x, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, x) + 1 + dist(y, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, y) + 1 + dist(x, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, p) + dist(p, y) + dist(y, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(u, q) + dist(q, y) + dist(y, v);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(v, p) + dist(p, x) + dist(x, u);
if (trial <= k && trial % 2 == k % 2) ans = 1;
trial = dist(v, q) + dist(q, x) + dist(x, u);
if (trial <= k && trial % 2 == k % 2) ans = 1;
if (ans)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long L = ceil(log2(N)) + 1;
vector<vector<long long> > adj(N, vector<long long int>());
vector<long long int> tin(N, 0), tout(N, 0);
vector<vector<long long> > up(N, vector<long long int>(L));
vector<long long int> d(N, 0);
long long n;
long long tr = 0;
void dfs(long long u, long long p) {
tin[u] = tr++;
if (p != -1) {
d[u] = d[p] + 1;
for (long long int i = 0; i < L; i++) {
if (i == 0)
up[u][0] = p;
else
up[u][i] = up[up[u][i - 1]][i - 1];
}
}
for (long long int i = 0; i < (long long int)adj[u].size(); i++)
if (adj[u][i] != p) dfs(adj[u][i], u);
tout[u] = tr++;
return;
}
long long 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 - 1; i >= 0; i--) {
if (is_ancestor(up[u][i], v) == 0) u = up[u][i];
}
return up[u][0];
}
long long dist(long long u, long long v) {
long long an = lca(u, v);
return d[u] - d[an] + d[v] - d[an];
}
int solve() {
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
long long d1 = dist(a, b);
long long d2 = dist(a, x) + 1 + dist(y, b);
long long d3 = dist(a, y) + 1 + dist(x, b);
if ((d1 <= k && (d1 - k) % 2 == 0) || (d2 <= k && (d2 - k) % 2 == 0) ||
(d3 <= k && (d3 - k) % 2 == 0))
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
int main() {
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test_cases = 1;
while (test_cases--) solve();
auto stop = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::milliseconds>(stop - start);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double eps = 1e-9;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
inline int read() {
int ret = 0, sgn = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') sgn = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
ret = ret * 10 + ch - '0';
ch = getchar();
}
return ret * sgn;
}
inline void Out(int a) {
if (a > 9) Out(a / 10);
putchar(a % 10 + '0');
}
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); }
long long qpow(long long a, long long b, long long mod) {
if (a >= mod) a = a % mod + mod;
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans * a;
if (ans >= mod) ans = ans % mod + mod;
}
a *= a;
if (a >= mod) a = a % mod + mod;
b >>= 1;
}
return ans;
}
int Fermat(int a, int p) { return qpow(a, p - 2, p); }
int exgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int g = exgcd(b, a % b, x, y);
int t = x;
x = y;
y = t - a / b * y;
return g;
}
int mod_reverse(int a, int p) {
int d, x, y;
d = exgcd(a, p, x, y);
if (d == 1)
return (x % p + p) % p;
else
return -1;
}
long long china(int a[], int b[], int n) {
int M = 1, y, x = 0;
for (int i = 0; i < n; ++i) M *= a[i];
for (int i = 0; i < n; ++i) {
int w = M / a[i];
int tx = 0;
int t = exgcd(w, a[i], tx, y);
x = (x + w * (b[i] / t) * x) % M;
}
return (x + M) % M;
}
int n, q;
int a, b, x, y, k;
const int N = 1e5 + 5;
struct Edge {
int to, nxt;
} e[N << 1];
int head[N], tote;
void add_edge(int u, int v) {
e[++tote].to = v, e[tote].nxt = head[u];
head[u] = tote;
}
int maxn, depth[N], dp[N][20];
void dfs(int u, int fa) {
dp[u][0] = fa, depth[u] = depth[fa] + 1;
for (int i = 1; i <= maxn; i++) dp[u][i] = dp[dp[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].nxt)
if (e[i].to != fa) dfs(e[i].to, u);
}
int LCA(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
for (int i = maxn; i >= 0; i--)
if ((1 << i) <= (depth[x] - depth[y])) x = dp[x][i];
if (x == y) return x;
for (int i = maxn; i >= 0; i--)
if (dp[x][i] != dp[y][i]) x = dp[x][i], y = dp[y][i];
return dp[x][0];
}
int cal(int a, int b) { return depth[a] + depth[b] - 2 * depth[LCA(a, b)]; }
void init(int n) {
for (int i = 0; i <= n; i++) {
head[i] = 0;
}
tote = 0;
maxn = floor(log(n + 0.0) / log(2.0));
}
int main() {
scanf("%d", &n);
init(n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
depth[0] = 0;
dp[1][0] = 0, depth[1] = depth[0] + 1;
for (int i = 1; i <= maxn; i++) dp[1][i] = dp[dp[1][i - 1]][i - 1];
for (int i = head[1]; i; i = e[i].nxt)
if (e[i].to != 0) dfs(e[i].to, 1);
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d", &x, &y);
scanf("%d%d%d", &a, &b, &k);
int dis = cal(a, b);
if (((k & 1) == (dis & 1)) && dis <= k) {
puts("YES");
continue;
}
dis = 1 + cal(a, x) + cal(b, y);
if (((k & 1) == (dis & 1)) && dis <= k) {
puts("YES");
continue;
}
dis = 1 + cal(a, y) + cal(b, x);
if (((k & 1) == (dis & 1)) && dis <= k) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> e[N];
int anc[N][20];
int dep[N];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
anc[u][0] = fa;
for (int i = 1; i <= 17; i++) {
anc[u][i] = anc[anc[u][i - 1]][i - 1];
}
for (auto v : e[u]) {
if (v == fa) continue;
dfs(v, u);
}
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int d = dep[u] - dep[v];
for (int i = 0; i <= 17; i++) {
if (d & (1 << i)) {
u = anc[u][i];
}
}
if (u == v) return u;
for (int i = 17; i >= 0; i--) {
if (anc[u][i] != anc[v][i]) {
u = anc[u][i];
v = anc[v][i];
}
}
return anc[u][0];
}
int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
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 = dist(a, b);
int dis2 = min(dist(a, x) + 1 + dist(y, b), dist(a, y) + 1 + dist(x, b));
if (((dis1 & 1) ^ (k & 1)) == 0 && dis1 <= k ||
((dis2 & 1) ^ (k & 1)) == 0 && dis2 <= k) {
printf("YES\n");
} else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
int n, q;
struct edge {
int v, nxt;
} e[N << 1];
int head[N], ecnt;
inline void ad(int u, int v) {
e[++ecnt].v = v;
e[ecnt].nxt = head[u];
head[u] = ecnt;
}
int dep[N], f[N][23];
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 = e[i].nxt) {
int v = e[i].v;
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 getdis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int k;
bool check(int d) {
if (d > k) return false;
if ((k - d) % 2 == 0)
return true;
else
return false;
}
int main() {
cin >> n;
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
ad(x, y), ad(y, x);
}
dfs(1, 0);
cin >> q;
int dis[5] = {0};
while (q--) {
int x, y, a, b;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
dis[1] = getdis(a, b);
dis[2] = getdis(x, a) + getdis(b, y) + 1;
dis[3] = getdis(x, b) + getdis(a, y) + 1;
if (check(dis[1]) || check(dis[2]) || check(dis[3])) {
puts("YES");
} else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
a %= m;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res;
}
long long timer;
const long long LG = 22, maxN = 1e5 + 5;
long long tin[maxN], tout[maxN];
long long up[maxN][LG + 1];
vector<long long> adj[maxN];
long long depth[maxN];
void dfs(long long v = 1, long long p = 1, long long d = 0) {
tin[v] = ++timer;
up[v][0] = p;
depth[v] = d;
for (long long i = 1; i <= LG; ++i) {
up[v][i] = up[up[v][i - 1]][i - 1];
}
for (long long u : adj[v]) {
if (u != p) {
dfs(u, v, d + 1);
}
}
tout[v] = ++timer;
}
bool isAncestor(long long u, long long v) {
return (tin[u] <= tin[v]) and (tout[u] >= tout[v]);
}
long long LCA(long long u, long long v) {
if (isAncestor(u, v)) return u;
if (isAncestor(v, u)) return v;
for (long long i = LG; i >= 0; --i) {
if (!isAncestor(up[u][i], v)) {
u = up[u][i];
}
}
return up[u][0];
}
long long dist(long long a, long long b) {
long long lca = LCA(a, b);
return depth[a] + depth[b] - depth[lca] * 2;
}
int32_t main() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
long long n;
cin >> n;
long long u, v;
for (long long i = 0; i < (n - 1); i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs();
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long p1 = dist(a, b);
long long p2 = dist(a, x) + dist(b, y) + 1;
long long p3 = dist(a, y) + dist(b, x) + 1;
if (p1 <= k and !((p1 & 1) ^ (k & 1))) {
cout << "YES" << endl;
} else if (p2 <= k and !((p2 & 1) ^ (k & 1))) {
cout << "YES" << endl;
} else if (p3 <= k and !((p3 & 1) ^ (k & 1))) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct lca {
long long Log;
vector<vector<long long>> memo;
vector<long long> depth;
lca(const vector<vector<long long>> &graph, long long root) {
long long n = graph.size();
Log = 1;
while ((1 << Log) < n) ++Log;
depth.resize(n, 0);
memo.resize(n, vector<long long>(Log));
dfs(root, root, graph);
}
void dfs(long long node, long long par,
const vector<vector<long long>> &graph) {
memo[node][0] = par;
for (long long i = 1; i < Log; ++i) {
memo[node][i] = memo[memo[node][i - 1]][i - 1];
}
for (long long to : graph[node]) {
if (to == par) continue;
depth[to] = 1 + depth[node];
dfs(to, node, graph);
}
}
long long getLca(long long x, long long y) {
if (depth[x] < depth[y]) swap(x, y);
long long diff = depth[x] - depth[y];
for (long long bit = 0; bit < Log; ++bit) {
if (diff & (1 << bit)) {
x = memo[x][bit];
}
}
for (long long bit = Log - 1; bit >= 0; --bit) {
if (memo[x][bit] != memo[y][bit]) {
x = memo[x][bit];
y = memo[y][bit];
}
}
if (x != y) x = memo[x][0];
return x;
}
long long distEdges(long long x, long long y) {
return depth[x] + depth[y] - 2 * depth[getLca(x, y)];
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<vector<long long>> adj(n);
for (long long i = 0; i < n - 1; ++i) {
long long u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
lca l(adj, 0);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
--x, --y, --a, --b;
long long currDistEdges = l.distEdges(a, b);
if (currDistEdges % 2 == k % 2 && currDistEdges <= k) {
cout << "YES\n";
continue;
}
currDistEdges = l.distEdges(a, x) + 1 + l.distEdges(y, b);
if (currDistEdges % 2 == k % 2 && currDistEdges <= k) {
cout << "YES\n";
continue;
}
currDistEdges = l.distEdges(a, y) + 1 + l.distEdges(x, b);
if (currDistEdges % 2 == k % 2 && currDistEdges <= k) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int K = 17;
int n;
vector<int> adj[N];
int depth[N];
int P[N][K];
void dfs(int u, int p, int d) {
depth[u] = d;
P[u][0] = p;
for (int v : adj[u]) {
if (v == p) continue;
dfs(v, u, d + 1);
}
}
int LCA(int a, int b) {
if (depth[a] < depth[b]) swap(a, b);
for (int j = K - 1; j >= 0; --j) {
if (depth[a] - (1 << j) >= depth[b]) {
a = P[a][j];
}
}
if (a == b) return a;
for (int j = K - 1; j >= 0; --j) {
if (P[a][j] != -1 && P[a][j] != P[b][j]) {
a = P[a][j], b = P[b][j];
}
}
return P[a][0];
}
inline int dist(int a, int b) {
return depth[a] + depth[b] - 2 * depth[LCA(a, b)];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, -1, 0);
for (int j = 1; j < K; ++j) {
for (int i = 1; i <= n; ++i) {
if (P[i][j - 1] == -1) {
P[i][j] = -1;
} else {
P[i][j] = P[P[i][j - 1]][j - 1];
}
}
}
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int aux;
int cyclen = 1 + dist(x, y);
aux = k - dist(a, b);
if (aux >= 0 && aux % 2 == 0) {
cout << "YES\n";
continue;
}
aux = k - 1 - dist(a, x) - dist(y, b);
if (aux >= 0 && aux % 2 == 0) {
cout << "YES\n";
continue;
}
aux -= cyclen;
if (aux >= 0 && aux % 2 == 0) {
cout << "YES\n";
continue;
}
aux = k - 1 - dist(a, y) - dist(x, b);
if (aux >= 0 && aux % 2 == 0) {
cout << "YES\n";
continue;
}
aux -= cyclen;
if (aux >= 0 && aux % 2 == 0) {
cout << "YES\n";
continue;
}
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;
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);
for (int l = 0; l < maxl - 1; l++)
for (int v = 0; v < n; v++) step[v][l + 1] = step[step[v][l]][l];
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>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
struct cow {
int v, next;
} E[200009 << 1];
int head[200009];
int n, k;
int tot = 0;
void add(int u, int v) {
E[++tot].v = v;
E[tot].next = head[u];
head[u] = tot;
E[++tot].v = u;
E[tot].next = head[v];
head[v] = tot;
}
int dep[200009], fa[200009][30];
void dfs(int u, int faa, int dis) {
dep[u] = dis;
fa[u][0] = faa;
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].v;
if (v == faa) continue;
dfs(v, u, dis + 1);
}
}
void init(int n) {
for (int k = 1; k <= 23; k++) {
for (int i = 1; i <= n; i++) {
fa[i][k] = fa[fa[i][k - 1]][k - 1];
}
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 23; i >= 0; i--) {
if (dep[fa[x][i]] >= dep[y]) x = fa[x][i];
}
if (x == y) return x;
for (int i = 23; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
int get(int a, int b) {
int lca = LCA(a, b);
return dep[a] + dep[b] - dep[lca] * 2;
}
int main() {
int n = read(), u, v, x, y, a, b, k, tmp, cir;
for (int i = 1; i < n; i++) {
u = read();
v = read();
add(u, v);
}
dfs(1, 0, 0);
init(n);
int m = read();
while (m--) {
x = read();
y = read();
a = read();
b = read();
k = read();
tmp = k - get(a, b);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, x) + get(b, y) + 1);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + 1);
if (tmp >= 0 && tmp % 2 == 0) {
printf("YES\n");
continue;
}
cir = get(x, y) + 1;
tmp = k - (get(a, x) + get(b, y) + 1);
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + 1);
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, x) + get(b, y) + get(x, y));
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
tmp = k - (get(a, y) + get(b, x) + get(x, y));
if (tmp >= 0 && tmp % cir == 0) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#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;
int step[100000][maxl];
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<int> tin(n), tout(n), depth(n, -1);
int time = 0;
function<void(int, int)> dfs = [&](int v, int p) {
step[v][0] = p;
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);
for (int l = 0; l < maxl - 1; l++)
for (int v = 0; v < n; v++) step[v][l + 1] = step[step[v][l]][l];
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>
using namespace std;
int n, a, b, q, x, y, k;
vector<int> G[100009];
int vis[100009], dist[100009];
int p[100009][20], t[100009];
void DFS(int v) {
vis[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
int w = G[v][i];
if (vis[w] == 0) {
t[w] = v;
dist[w] = dist[v] + 1;
DFS(w);
}
}
}
void make_table() {
for (int i = 1; i <= n; i++) {
for (int j = 0; (1 << j) < n; j++) {
p[i][j] = -1;
}
}
for (int i = 2; i <= n; i++) {
p[i][0] = t[i];
}
for (int j = 1; (1 << j) < n; j++) {
for (int i = 1; i <= n; i++) {
if (p[i][j - 1] != -1) {
p[i][j] = p[p[i][j - 1]][j - 1];
}
}
}
}
int lca(int v, int w) {
if (dist[v] < dist[w]) {
swap(v, w);
}
int log;
for (log = 1; (1 << log) < dist[v]; log++)
;
for (int i = log; i >= 0; i--) {
if (dist[v] - (1 << i) >= dist[w]) v = p[v][i];
}
if (v == w) return v;
for (int i = log; i >= 0; i--) {
if (p[v][i] != -1 && p[v][i] != p[w][i]) {
v = p[v][i];
w = p[w][i];
}
}
return t[v];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
DFS(1);
make_table();
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
int len = dist[a] + dist[b] - 2 * dist[lca(a, b)];
int mod = abs((dist[a] % 2) - (dist[b] % 2));
if (k % 2 == mod && len <= k) {
cout << "YES\n";
continue;
}
len = dist[a] + dist[x] - 2 * dist[lca(a, x)] + 1 + dist[y] + dist[b] -
2 * dist[lca(y, b)];
mod = abs((dist[a] % 2) - (dist[x] % 2)) +
abs((dist[y] % 2) - (dist[b] % 2)) + 1;
mod %= 2;
if (k % 2 == mod && len <= k) {
cout << "YES\n";
continue;
}
len = dist[a] + dist[y] - 2 * dist[lca(a, y)] + 1 + dist[x] + dist[b] -
2 * dist[lca(x, b)];
mod = abs((dist[a] % 2) - (dist[y] % 2)) +
abs((dist[x] % 2) - (dist[b] % 2)) + 1;
mod %= 2;
if (k % 2 == mod && len <= k) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MB = 20;
const int MOD = 998244353;
vector<vector<int>> g, p;
vector<int> h;
void dfs(int v, int pr = -1) {
p[0][v] = pr == -1 ? v : pr;
for (int i = 0; i < MB - 1; i++) {
p[i + 1][v] = p[i][p[i][v]];
}
for (int u : g[v]) {
if (u != pr) {
h[u] = h[v] + 1;
dfs(u, v);
}
}
}
int getLCA(int a, int b) {
if (h[a] < h[b]) swap(a, b);
for (int i = MB - 1; i >= 0; i--) {
if (h[p[i][a]] >= h[b]) a = p[i][a];
}
if (a == b) return a;
for (int i = MB - 1; i >= 0; i--) {
if (p[i][a] != p[i][b]) {
a = p[i][a];
b = p[i][b];
}
}
return p[0][a];
}
int getLen(int a, int b) {
int c = getLCA(a, b);
return h[a] + h[b] - 2 * h[c];
}
void solve() {
int n;
cin >> n;
g.resize(n);
for (int i = 0; i < n - 1; i++) {
int from, to;
cin >> from >> to;
from--;
to--;
g[from].push_back(to);
g[to].push_back(from);
}
p.resize(MB, vector<int>(n));
h.resize(n);
dfs(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int len = getLen(a, b);
bool good = false;
if (len <= k && (k - len) % 2 == 0) good = true;
len = getLen(a, x) + getLen(b, y) + 1;
if (len <= k && (k - len) % 2 == 0) good = true;
len = getLen(a, y) + getLen(b, x) + 1;
if (len <= k && (k - len) % 2 == 0) good = true;
cout << (good ? "YES\n" : "NO\n");
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int n, q;
vector<int> edge[100005];
int dis[100005];
int father[100005][20];
void dfs(int u, int fa) {
dis[u] = dis[fa] + 1;
father[u][0] = fa;
for (auto i : edge[u]) {
if (i == fa) continue;
dfs(i, u);
}
}
int LCA(int u, int v) {
if (dis[u] < dis[v]) swap(u, v);
for (int i = 18; i >= 0; i--) {
if (dis[father[u][i]] >= dis[v]) {
u = father[u][i];
}
}
if (u == v) return u;
for (int i = 18; i >= 0; i--) {
if (father[u][i] != father[v][i]) {
u = father[u][i];
v = father[v][i];
}
}
return father[u][0];
}
int get_dis(int a, int b) { return dis[a] + dis[b] - 2 * dis[LCA(a, b)]; }
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
}
dis[0] = 0;
dfs(1, 0);
for (int j = 1; j <= 18; j++) {
for (int i = 1; i <= n; i++) {
father[i][j] = father[father[i][j - 1]][j - 1];
}
}
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int yes = 0;
int d = get_dis(a, b);
if (d <= k && d % 2 == k % 2) yes = 1;
d = get_dis(a, x) + get_dis(b, y) + 1;
if (d <= k && d % 2 == k % 2) yes = 1;
d = get_dis(b, x) + get_dis(a, y) + 1;
if (d <= k && d % 2 == k % 2) yes = 1;
if (yes)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class LCA {
private:
vector<vector<int>> anc;
vector<vector<int>> cost;
vector<int> level;
vector<int> dist;
vector<bool> vis;
int start_idx;
int n;
private:
void build(const vector<vector<pair<int, int>>> &adj) {
dist[this->start_idx] = 0;
dfs_LCA(this->start_idx, -1, 1, -1, adj);
for (int j = 1; j < anc.front().size(); j++)
for (int i = 0; i < anc.size(); i++)
if (this->anc[i][j - 1] != -1) {
this->anc[i][j] = this->anc[this->anc[i][j - 1]][j - 1];
}
}
void dfs_LCA(const int u, const int p, const int d, const int w,
const vector<vector<pair<int, int>>> &adj) {
this->level[u] = d;
this->vis[u] = true;
this->anc[u][0] = p;
for (const pair<int, int> &x : adj[u]) {
if (this->vis[x.first]) continue;
this->dist[x.first] = this->dist[u] + x.second;
dfs_LCA(x.first, u, d + 1, x.second, adj);
}
}
public:
explicit LCA(const int n, const int start_idx,
const vector<vector<pair<int, int>>> &adj) {
this->n = n;
this->anc.resize(n + 1, vector<int>((int)log2(n) + 1, -1));
this->level.resize(n + 1, -1);
this->dist.resize(n + 1);
this->vis.resize(n + 1, false);
this->start_idx = start_idx;
this->build(adj);
}
int query(int a, int b) {
assert(start_idx <= min(a, b));
assert(max(a, b) < this->n + start_idx);
const int a_cpy = a, b_cpy = b;
if (this->level[b] > this->level[a]) swap(a, b);
const int lg = log2(this->level[a]);
for (int i = lg; i >= 0; i--)
if (this->level[a] - (1 << i) >= this->level[b]) a = this->anc[a][i];
if (a == b)
return this->dist[a_cpy] + this->dist[b_cpy] - 2 * this->dist[a];
for (int i = lg; i >= 0; i--)
if (this->anc[a][i] != -1 && this->anc[a][i] != this->anc[b][i]) {
a = this->anc[a][i];
b = this->anc[b][i];
}
return this->dist[a_cpy] + this->dist[b_cpy] - 2 * this->dist[anc[a][0]];
}
int max_edge(int v, int p) {
if (this->level[v] < this->level[p]) swap(v, p);
int k = this->level[v] - this->level[p];
int ans = -1;
for (int i = 0; k > 0; i++, k >>= 1)
if (k & 1) {
v = this->anc[v][i];
}
return ans;
}
int go_back(int x, int k) {
for (int i = 0; k > 0; i++, k >>= 1)
if (k & 1) x = this->anc[x][i];
return x;
}
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<pair<int, int>>> adj(n + 1);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(pair<int, int>(v, 1));
adj[v].push_back(pair<int, int>(u, 1));
}
LCA lca(n, 1, adj);
int q;
cin >> q;
while (q--) {
int from, to, x, y, k;
cin >> x >> y >> from >> to >> k;
string ans = "NO";
int p1 = lca.query(from, to);
if (p1 <= k && ((p1 & 1) == (k & 1))) ans = "YES";
int p2 = lca.query(from, y) + 1 + lca.query(x, to);
if (p2 <= k && ((p2 & 1) == (k & 1))) ans = "YES";
int p3 = lca.query(from, x) + 1 + lca.query(y, to);
if (p3 <= k && ((p3 & 1) == (k & 1))) ans = "YES";
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int LIM = 17;
const int INF = (int)1e9 + 7;
vector<int> adj[MAX_N + 5];
int depth[MAX_N + 5];
int par[MAX_N + 5][LIM + 1];
void build(int cur, int p) {
int i;
depth[cur] = depth[p] + 1;
par[cur][0] = p;
for (i = 1; i <= LIM; i++) par[cur][i] = par[par[cur][i - 1]][i - 1];
for (int x : adj[cur])
if (x != p) build(x, cur);
}
int lca_len(int a, int b) {
int i, len = 0;
if (depth[a] > depth[b]) swap(a, b);
for (i = LIM; i >= 0; i--) {
if (depth[par[b][i]] >= depth[a]) {
b = par[b][i];
len += (1 << i);
}
}
if (a == b) return len;
for (i = LIM; i >= 0; i--) {
if (par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
len += (1 << (i + 1));
}
}
return len + 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q, i;
cin >> n;
for (i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
build(1, 0);
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int without = lca_len(a, b);
int with =
min(lca_len(a, x) + lca_len(y, b), lca_len(a, y) + lca_len(x, b)) + 1;
int ans = INF;
if (without % 2 == k % 2) ans = without;
if (with % 2 == k % 2) ans = min(ans, with);
cout << (ans <= k ? "YES" : "NO") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, T, x, y, a, b, k;
vector<int> vec[N];
int dep[N];
int f[N][30];
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
for (int i = 0; i < 20; ++i) f[x][i + 1] = f[f[x][i]][i];
for (int i = 0; i < vec[x].size(); ++i) {
int t = vec[x][i];
if (t == fa) continue;
f[t][0] = x;
dfs(t, x);
}
}
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 main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
vec[u].emplace_back(v);
vec[v].emplace_back(u);
}
dfs(1, 0);
scanf("%d", &T);
while (T--) {
scanf("%d%d%d%d%d", &a, &b, &x, &y, &k);
int p = lca(x, y);
int dis = dep[x] + dep[y] - 2 * dep[p];
if (k >= dis && (k - dis) % 2 == 0) {
puts("YES");
continue;
}
int p1 = lca(x, a);
int dis1 = dep[x] + dep[a] - 2 * dep[p1];
int p2 = lca(y, b);
int dis2 = dep[y] + dep[b] - 2 * dep[p2];
dis = dis1 + dis2 + 1;
if (k >= dis && (k - dis) % 2 == 0) {
puts("YES");
continue;
}
p1 = lca(x, b);
dis1 = dep[x] + dep[b] - 2 * dep[p1];
p2 = lca(y, a);
dis2 = dep[y] + dep[a] - 2 * dep[p2];
dis = dis1 + dis2 + 1;
if (k >= dis && (k - dis) % 2 == 0) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
int per, to;
} a[100010 << 1];
int head[100010], deep[100010], root[100010];
bool vis[100010], in[100010];
int f[100010][21];
int n, tot, aa, bb, xx, yy, k, q;
void addedge(int from, int to) {
a[++tot].to = to;
a[tot].per = head[from];
head[from] = tot;
}
void dfs(int u, int fa) {
if (fa == -1) {
deep[u] = 0;
f[u][0] = 0;
} else {
deep[u] = deep[fa] + 1;
f[u][0] = fa;
}
for (int i = 1; i <= 20; ++i) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
for (int i = head[u]; i > 0; i = a[i].per) {
int v = a[i].to;
if (v == fa || vis[v]) continue;
dfs(v, u);
}
}
int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 20; i >= 0; --i) {
if (deep[f[x][i]] >= deep[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 main() {
ios_base::sync_with_stdio(false);
cin >> n;
memset(head, -1, sizeof(head));
for (int i = 1; i <= n - 1; ++i) {
int u, v;
cin >> u >> v;
addedge(u, v);
addedge(v, u);
in[v] = 1;
}
int rt;
for (int i = 1; i <= n; ++i) {
if (!in[i]) {
rt = i;
break;
}
}
dfs(rt, -1);
cin >> q;
while (q--) {
cin >> xx >> yy >> aa >> bb >> k;
int ff1 = lca(aa, bb), ff2 = lca(aa, xx), ff3 = lca(bb, yy),
ff4 = lca(aa, yy), ff5 = lca(bb, xx);
int dis1 = deep[bb] + deep[aa] - 2 * deep[ff1];
int dis2 = deep[aa] + deep[xx] - 2 * deep[ff2] + deep[bb] + deep[yy] -
2 * deep[ff3] + 1;
int dis3 = deep[aa] + deep[yy] - 2 * deep[ff4] + deep[bb] + deep[xx] -
2 * deep[ff5] + 1;
if ((k >= dis1 && k % 2 == dis1 % 2) || (k >= dis2 && k % 2 == dis2 % 2) ||
(k >= dis3 && k % 2 == dis3 % 2)) {
cout << "YES\n";
} else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int next, to;
} e[200005];
int fa[100005][18], head[100005], dep[100005], lg[100005], g;
int read() {
int A;
bool K;
char C;
C = A = K = 0;
while (C < '0' || C > '9') K |= C == '-', C = getchar();
while (C > '/' && C < ':') A = (A << 3) + (A << 1) + (C ^ 48), C = getchar();
return (K ? -A : A);
}
void write(int X) {
if (X < 0) putchar('-'), X = -X;
if (X > 9) write(X / 10);
putchar(X % 10 | 48);
}
inline void sw_ap(int& _, int& __) { _ ^= __ ^= _ ^= __; }
inline void add(int u, int v) {
e[++g].to = v;
e[g].next = head[u];
head[u] = g;
}
void build(int now, int t) {
int i = 0, v;
fa[now][0] = t;
dep[now] = dep[t] + 1;
while (1 << ++i <= dep[now]) fa[now][i] = fa[fa[now][i - 1]][i - 1];
for (i = head[now]; i; i = e[i].next) {
v = e[i].to;
if (v != t) build(v, now);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) sw_ap(x, y);
while (dep[x] > dep[y]) x = fa[x][lg[dep[x] - dep[y]]];
if (x == y) return x;
int i;
for (i = lg[dep[x]]; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[y][0];
}
int main() {
int n, m, i, x, y, tmp1, tmp2, k, pp, q, a, b;
n = read();
for (i = 1; i <= n - 1; i++) {
x = read(), y = read();
add(x, y), add(y, x);
}
build(1, 0);
lg[0] = -1;
for (i = 1; i <= n; i++) lg[i] = lg[i >> 1] + 1;
q = read();
while (q--) {
x = read(), y = read();
a = read(), b = read(), k = read();
tmp1 = lca(a, b);
pp = dep[a] - dep[tmp1] + dep[b] - dep[tmp1];
if (pp <= k && (pp & 1) == (k & 1)) {
puts("YES");
continue;
}
tmp1 = lca(a, x), tmp2 = lca(b, y);
pp = dep[a] - dep[tmp1] + dep[x] - dep[tmp1] + dep[b] - dep[tmp2] + dep[y] -
dep[tmp2] + 1;
if ((pp & 1) == (k & 1) && pp <= k) {
puts("YES");
continue;
}
tmp1 = lca(a, y), tmp2 = lca(b, x);
pp = dep[a] - dep[tmp1] + dep[y] - dep[tmp1] + dep[b] - dep[tmp2] + dep[x] -
dep[tmp2] + 1;
if ((pp & 1) == (k & 1) && pp <= k) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int lim = 20;
struct node {
int u, to;
} E[maxn << 1];
int head[maxn], cnt, dep[maxn], n, m;
int anc[maxn][lim];
inline void add(int x, int y) {
cnt++;
E[cnt].u = y;
E[cnt].to = head[x];
head[x] = cnt;
return;
}
inline void update(int x, int fx) {
anc[x][0] = fx;
for (int i = 1; i < lim; ++i) {
anc[x][i] = anc[anc[x][i - 1]][i - 1];
}
dep[x] = dep[fx] + 1;
return;
}
inline void swim(int &x, int h) {
for (int i = 0; h > 0; ++i) {
if (h & 1) {
x = anc[x][i];
}
h >>= 1;
}
return;
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
swim(x, dep[x] - dep[y]);
if (x == y) return x;
for (int i = lim - 1; i >= 0; i--) {
if (anc[x][i] != anc[y][i]) {
x = anc[x][i];
y = anc[y][i];
}
}
return anc[x][0];
}
void dfs(int u, int fa) {
for (int i = head[u]; i > 0; i = E[i].to) {
int v = E[i].u;
if (v == fa) continue;
update(v, u);
dfs(v, u);
}
return;
}
int get_len(int x, int y) {
int xy = lca(x, y);
return dep[x] + dep[y] - dep[xy] - dep[xy];
}
int k;
bool judge(int x) { return (x <= k && ((x - k) % 2 == 0)); }
void sol() {
int x, y, a, b;
int len;
while (m--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
bool flag = false;
len = get_len(a, b);
flag |= judge(len);
len = get_len(a, x) + 1 + get_len(b, y);
flag |= judge(len);
len = get_len(a, y) + 1 + get_len(b, x);
flag |= judge(len);
len = get_len(a, x) + get_len(x, y) + get_len(y, b);
flag |= judge(len);
len = get_len(a, y) + get_len(x, y) + get_len(x, b);
flag |= judge(len);
if (flag)
puts("YES");
else
puts("NO");
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) head[i] = -1;
dep[1] = 0;
cnt = 0;
int x, y;
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 1);
scanf("%d", &m);
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
void put1() { puts("YES"); }
void put2() { puts("NO"); }
void put3() { puts("-1"); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
using namespace std;
const int manx = 3e5 + 5;
long long head[manx], d[manx], f[manx][21], lg[manx];
long long k = 0;
struct node {
long long v, next;
} e[manx * 2];
void add(long long u, long long v) {
e[++k].v = v;
e[k].next = head[u];
head[u] = k;
}
void dfs(long long u, long long fa) {
d[u] = d[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= lg[d[u]]; i++) f[u][i] = f[f[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].next)
if (e[i].v != fa) dfs(e[i].v, u);
}
long long lca(long long a, long long b) {
if (d[a] < d[b]) swap(a, b);
while (d[a] > d[b]) a = f[a][lg[d[a] - d[b]] - 1];
if (a == b) return a;
for (int i = lg[d[a]] - 1; i >= 0; i--)
if (f[a][i] != f[b][i]) a = f[a][i], b = f[b][i];
return f[a][0];
}
long long dis(long long x, long long y) {
return d[x] + d[y] - d[lca(x, y)] * 2;
}
bool check(long long x, long long y) { return y >= x && x % 2 == y % 2; }
int main() {
long long n = read();
for (int i = 1; i < n; i++) {
long long u = read(), v = read();
add(u, v);
add(v, u);
}
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dfs(1, 0);
long long m = read();
for (int i = 1; i <= m; i++) {
long long x = read(), y = read(), a = read(), b = read(), k = read();
long long d1 = dis(a, b), d2 = dis(a, x) + 1 + dis(y, b),
d3 = dis(a, y) + 1 + dis(x, b);
if (check(d1, k) || check(d2, k) || check(d3, k))
put1();
else
put2();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100012;
const int LOG = 19;
int n, tin[MN], tout[MN], pa[MN][LOG], dt[MN], ctr = 0;
vector<int> g[MN];
void dfs(int u, int p = 0) {
tin[u] = ctr++;
pa[u][0] = p;
if (u > 0) dt[u] = dt[p] + 1;
for (int i = 1; i < LOG; i++) pa[u][i] = pa[pa[u][i - 1]][i - 1];
for (int v : g[u]) {
if (v == p) continue;
dfs(v, u);
}
tout[u] = ctr++;
}
bool anc(int u, int v) { return tin[u] <= tin[v] and tout[u] >= tout[v]; }
int lca(int u, int v) {
if (anc(u, v)) return u;
if (anc(v, u)) return v;
for (int i = LOG - 1; i >= 0; i--)
if (!anc(pa[u][i], v)) u = pa[u][i];
return pa[u][0];
}
int dist(int u, int v) {
int a = lca(u, v);
return dt[u] - dt[a] + dt[v] - dt[a];
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
memset(dt, 0, sizeof(dt));
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0);
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
--x;
--y;
--a;
--b;
int da = dist(a, b);
int db = min(dist(a, x) + dist(b, y), dist(a, y) + dist(b, x)) + 1;
if (da > k and db > k)
cout << "NO\n";
else {
int rk = k & 1, ra = da & 1, rb = db & 1;
if (da <= k and rk == ra)
cout << "YES\n";
else if (db <= k and rk == rb)
cout << "YES\n";
else
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, LOG = 20;
vector<vector<int>> g(N), p(N, vector<int>(LOG));
vector<int> d(N), tin(N), tout(N);
int f = 1;
void dfs(int u, int pr, int depth) {
p[u][0] = pr;
tin[u] = f++;
for (int i = 1; i < LOG; i++) {
p[u][i] = p[p[u][i - 1]][i - 1];
}
d[u] = depth;
for (auto v : g[u]) {
if (v != pr) {
dfs(v, u, depth + 1);
}
}
tout[u] = f++;
}
bool is_ancestor(int u, int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v) {
if (is_ancestor(u, v)) {
return u;
}
if (is_ancestor(v, u)) {
return v;
}
for (int i = LOG - 1; i >= 0; i--) {
if (!is_ancestor(p[u][i], v)) {
u = p[u][i];
}
}
return p[u][0];
}
int dist(int u, int v) {
int a = lca(u, v);
return d[u] + d[v] - 2 * d[a];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[--u].push_back(--v);
g[v].push_back(u);
}
dfs(0, 0, 0);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int a, b, x, y, k;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
--a, --b, --x, --y;
int distance = dist(a, b);
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
distance = dist(a, x) + 1;
distance += dist(b, y);
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
distance = dist(a, y) + 1;
distance += dist(b, x);
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
puts("no");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxl = 1e5 + 10;
int n, q, cnt;
int ehead[maxl], dep[maxl];
int f[21][maxl];
struct ed {
int to, nxt;
} e[maxl << 1];
inline void add(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = ehead[u];
ehead[u] = cnt;
}
inline void dfs(int u, int fa) {
f[0][u] = fa;
int v;
for (int i = ehead[u]; i; i = e[i].nxt) {
v = e[i].to;
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
}
}
inline void prework() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n; j++) f[i][j] = f[i - 1][f[i - 1][j]];
}
inline int lca(int u, int v) {
if (dep[v] > dep[u]) swap(u, v);
for (int i = 0; i <= 20; i++)
if ((1 << i) & (dep[u] - dep[v])) u = f[i][u];
if (u == v) return u;
for (int i = 20; i >= 0; i--)
if (f[i][u] != f[i][v]) u = f[i][u], v = f[i][v];
return f[0][u];
}
inline int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
inline void mainwork() {
scanf("%d", &q);
int a, b, x, y, k, len;
bool flag;
a = lca(2, 3);
for (int i = 1; i <= q; i++) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
flag = false;
len = dist(a, b);
if ((len & 1) == (k & 1) && len <= k) flag = true;
len = dist(a, x) + dist(b, y) + 1;
if ((len & 1) == (k & 1) && len <= k) flag = true;
len = dist(a, y) + dist(b, x) + 1;
if ((len & 1) == (k & 1) && len <= k) flag = true;
if (flag)
puts("YES");
else
puts("NO");
}
}
int main() {
prework();
mainwork();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
struct node {
int to, next;
} edge[maxn << 2];
int head[maxn], dep[maxn], fa[maxn][20], cnt, n;
void add(int a, int b) {
edge[++cnt].to = b;
edge[cnt].next = head[a];
head[a] = cnt;
}
void dfs(int now, int f) {
dep[now] = dep[f] + 1;
fa[now][0] = f;
for (int i = head[now]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (to == f) continue;
dfs(to, now);
}
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
for (int i = 17; i >= 0; --i) {
if (dep[fa[a][i]] >= dep[b]) {
a = fa[a][i];
}
}
for (int i = 17; i >= 0; --i) {
if (fa[a][i] != fa[b][i]) {
a = fa[a][i];
b = fa[b][i];
}
}
if (a != b) return fa[a][0];
return a;
}
int dis(int a, int b) { return dep[a] + dep[b] - 2 * dep[lca(a, b)]; }
int main() {
int m, a, b, x, y, k;
memset(head, -1, sizeof(head));
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &a, &b);
add(a, b), add(b, a);
}
dfs(1, 0);
for (int i = 1; i <= 17; ++i) {
for (int j = 1; j <= n; ++j) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
}
scanf("%d", &m);
while (m--) {
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int len = dis(a, b), ans = 0;
if (len <= k && ((len & 1) == (k & 1))) {
ans = 1;
} else {
len = dis(a, x) + dis(y, b) + 1;
if (len <= k && ((len & 1) == (k & 1))) {
ans = 1;
}
len = dis(a, y) + dis(x, b) + 1;
if (len <= k && ((len & 1) == (k & 1))) {
ans = 1;
}
}
printf("%s\n", ans ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
namespace IO {
bool REOF = 1;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && REOF &&
(p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? (REOF = 0, EOF)
: *p1++;
}
template <class T>
inline bool read(T &x) {
if (!REOF) return false;
char c = nc();
bool f = 0;
x = 0;
while (c < '0' || c > '9') c == '-' && (f = 1), c = nc();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + (c ^ 48), c = nc();
if (f) x = -x;
return true;
}
template <typename T, typename... T2>
inline bool read(T &x, T2 &...rest) {
if (!REOF) return false;
read(x);
return read(rest...);
}
inline bool need(char &c) {
return ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9')) ||
((c >= 'A') && (c <= 'Z'));
}
inline bool read_str(char *a) {
if (!REOF) return false;
while ((*a = nc()) && need(*a) && REOF) ++a;
*a = '\0';
return true;
}
inline bool read_dbl(double &x) {
if (!REOF) return false;
bool f = 0;
char ch = nc();
x = 0;
while (ch < '0' || ch > '9') {
f |= (ch == '-');
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10.0 + (ch ^ 48);
ch = nc();
}
if (ch == '.') {
double tmp = 1;
ch = nc();
while (ch >= '0' && ch <= '9') {
tmp = tmp / 10.0;
x = x + tmp * (ch ^ 48);
ch = nc();
}
}
if (f) x = -x;
return true;
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << '\n';
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',' << ' ';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.st << "," << P.nd << ")";
}
} // namespace IO
using namespace IO;
const int maxn = 1e5 + 5;
const int mod = 998244353;
const int INF = 1e9 + 7;
const double eps = 1e-12;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct edge {
int v, nxt;
} e[maxn << 1];
int n, q, head[maxn], tot = 1;
void addedge(int u, int v) {
e[tot] = (edge){v, head[u]};
head[u] = tot++;
e[tot] = (edge){u, head[v]};
head[v] = tot++;
}
int sz[maxn], son[maxn], fa[maxn], h[maxn], top[maxn], cnt;
void dfs1(int u, int f) {
sz[u] = 1;
son[u] = 0;
fa[u] = f;
h[u] = h[f] + 1;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs1(v, u);
sz[u] += sz[v];
if (sz[son[u]] < sz[v]) son[u] = v;
}
}
void dfs2(int u, int f, int k) {
top[u] = k;
if (son[u]) dfs2(son[u], u, k);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == f || v == son[u]) continue;
dfs2(v, u, v);
}
}
int LCA(int u, int v) {
while (top[u] != top[v]) {
if (h[top[u]] < h[top[v]]) swap(u, v);
u = fa[top[u]];
}
if (h[u] > h[v]) swap(u, v);
return u;
}
void solve() {
read(n);
int u, v;
for (int i = 1; i <= n - 1; i++) {
read(u, v);
addedge(u, v);
}
dfs1(1, 0);
dfs2(1, 0, 1);
read(q);
int x, y, a, b, k;
while (q--) {
read(x, y, a, b, k);
bool flag = false;
int ab = LCA(a, b);
int dab = h[a] + h[b] - 2 * h[ab];
if (dab <= k && (k - dab) % 2 == 0) flag = true;
int ax = LCA(a, x);
int dax = h[a] + h[x] - 2 * h[ax];
int by = LCA(b, y);
int dby = h[b] + h[y] - 2 * h[by];
int daxyb = dax + 1 + dby;
if (daxyb <= k && (k - daxyb) % 2 == 0) flag = true;
int ay = LCA(a, y);
int day = h[a] + h[y] - 2 * h[ay];
int bx = LCA(b, x);
int dbx = h[b] + h[x] - 2 * h[bx];
int dayxb = day + 1 + dbx;
if (dayxb <= k && (k - dayxb) % 2 == 0) flag = true;
puts(flag ? "YES" : "NO");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1000005;
long long int tp[1000005];
int tin[maxn];
int tout[maxn];
int curt = 0;
int const maxl = 19;
int par[maxn][maxl];
int deep[maxn];
vector<long long int> ve[1000005];
void dfs(const int v, const int p = 1) {
tin[v] = curt++;
par[v][0] = p;
deep[v] = deep[p] + 1;
for (int i = 1; i < maxl; ++i) par[v][i] = par[par[v][i - 1]][i - 1];
for (int ne : ve[v])
if (ne != p) dfs(ne, v);
tout[v] = curt++;
}
inline bool upper(const int x, const int y) {
return tin[x] <= tin[y] && tout[y] <= tout[x];
}
inline int lca(int x, int y) {
if (upper(x, y)) return x;
if (upper(y, x)) return y;
for (int i = maxl - 1; i >= 0; --i)
if (!upper(par[x][i], y)) x = par[x][i];
return par[x][0];
}
inline int dist(const int x, const int y) {
return deep[x] + deep[y] - 2 * deep[lca(x, y)];
}
bool vis[1000005];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 1; i <= n - 1; i++) {
long long int u, v;
cin >> u >> v;
ve[u].push_back(v);
ve[v].push_back(u);
}
dfs(1);
long long int qq;
cin >> qq;
while (qq--) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long int dis = dist(a, b);
if (dis % 2 == k % 2) {
if (k >= dis) {
cout << "YES"
<< " " << endl;
;
continue;
}
}
long long int minn = dist(a, x) + dist(y, b) + 1;
if (minn % 2 == k % 2) {
if (k >= minn) {
cout << "YES"
<< " " << endl;
;
continue;
}
}
minn = dist(b, x) + dist(y, a) + 1;
if (minn % 2 == k % 2) {
if (k >= minn) {
cout << "YES"
<< " " << endl;
;
continue;
}
}
cout << "NO"
<< " " << endl;
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct A {
int nod, nvl;
};
queue<int> q;
vector<int> v[100005], rmq[18];
A Repr_Euler[200005];
int nr;
int nivel[100005], prima_aparitie[100005];
void nivelare();
void dfs(int nod);
int distanta(int nod1, int nod2);
int main() {
int n, i, j, q, x, y, a, b, k, D1, D2, D3;
cin >> n;
for (i = 1; i < n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
nivelare();
dfs(1);
n = 2 * n - 1;
x = log2(n);
for (i = 1; i <= n; i++) rmq[0].push_back(Repr_Euler[i].nvl);
for (i = 1; i <= x; i++)
for (j = 0; j < n - (1 << i) + 1; j++)
rmq[i].push_back(min(rmq[i - 1][j], rmq[i - 1][j + (1 << (i - 1))]));
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
D1 = distanta(a, b);
D2 = 1 + distanta(a, x) + distanta(y, b);
D3 = 1 + distanta(a, y) + distanta(x, b);
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';
}
return 0;
}
void nivelare() {
int x, i;
nivel[1] = 1;
q.push(1);
while (q.empty() == 0) {
x = q.front();
q.pop();
for (i = 0; i < v[x].size(); i++)
if (nivel[v[x][i]] == 0) {
nivel[v[x][i]] = nivel[x] + 1;
q.push(v[x][i]);
}
}
}
void dfs(int nod) {
int i;
for (i = 0; i < v[nod].size(); i++)
if (nivel[nod] == nivel[v[nod][i]] - 1) {
Repr_Euler[++nr].nod = nod;
Repr_Euler[nr].nvl = nivel[nod];
if (prima_aparitie[nod] == 0) prima_aparitie[nod] = nr;
dfs(v[nod][i]);
}
Repr_Euler[++nr].nod = nod;
Repr_Euler[nr].nvl = nivel[nod];
if (prima_aparitie[nod] == 0) prima_aparitie[nod] = nr;
}
int distanta(int nod1, int nod2) {
int st, dr, x, val, a, b;
st = prima_aparitie[nod1] - 1;
dr = prima_aparitie[nod2] - 1;
if (st > dr) swap(st, dr);
x = log2(dr - st + 1);
a = rmq[x][st];
b = rmq[x][dr - (1 << x) + 1];
val = min(rmq[x][st], rmq[x][dr - (1 << x) + 1]);
return nivel[nod1] + nivel[nod2] - 2 * val;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::string;
int n, m, d;
int ver[200010], next[200010], head[200010], tot;
int dis[100010], fa[100010][20];
inline void link(int x, int y) {
ver[++tot] = y, next[tot] = head[x], head[x] = tot;
}
inline void dfs(int now, int father) {
dis[now] = dis[father] + 1, fa[now][0] = father;
for (register int i = head[now]; i; i = next[i]) {
if (ver[i] != father) dfs(ver[i], now);
}
return;
}
inline int LCA(int x, int y) {
if (dis[x] < dis[y]) std::swap(x, y);
int tx = x, ty = y;
for (register int i = d; i >= 0; --i) {
if (dis[fa[x][i]] >= dis[y]) x = fa[x][i];
}
if (x != y) {
for (register int i = d; i >= 0; --i) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
x = fa[x][0];
}
return std::abs(dis[x] - dis[tx]) + std::abs(dis[x] - dis[ty]);
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int x, y, a, b, l;
cin >> n;
for (register int i = 1; i < n; ++i) {
cin >> x >> y;
link(x, y), link(y, x);
}
while ((1 << d) <= n) ++d;
dfs(x, 0);
for (register int j = 1; j <= d; ++j) {
for (register int i = 1; i <= n; ++i) {
fa[i][j] = fa[fa[i][j - 1]][j - 1];
}
}
cin >> m;
for (register int i = 1; i <= m; ++i) {
cin >> x >> y >> a >> b >> l;
int l1 = LCA(a, b), l2 = LCA(a, x) + LCA(b, y) + 1,
l3 = LCA(b, x) + LCA(a, y) + 1;
if (l1 <= l && l1 % 2 == l % 2)
cout << "YES\n";
else if (l2 <= l && l2 % 2 == l % 2)
cout << "YES\n";
else if (l3 <= l && l3 % 2 == l % 2)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NIL = -1;
template <class T>
inline T mx(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T mi(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline void sw(T &a, T &b) {
T t = a;
a = b;
b = t;
}
template <class T>
inline T mabs(T x) {
return x < 0 ? -x : x;
}
inline char gc() {
char ret;
while ((ret = getchar()) == ' ' || ret == '\n' || ret == '\t')
;
return ret;
}
template <class T>
inline T sq(T x) {
return x * x;
}
int n;
const int lim = 1e5 + 10;
int fa[lim][40], dept[lim];
vector<int> adj[lim];
void dfs(int u, int f) {
dept[u] = dept[f] + 1;
int v;
fa[u][0] = f;
for (int i = 1; i < 32; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == f) continue;
dfs(v, u);
}
}
int lca(int x, int y) {
if (dept[x] < dept[y]) sw(x, y);
for (int i = 32; i >= 0; i--) {
if (dept[fa[x][i]] >= dept[y]) x = fa[x][i];
if (x == y) return x;
}
for (int i = 32; i >= 0; i--) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
int dist(int x, int y) {
int c = lca(x, y);
return dept[x] + dept[y] - 2 * dept[c];
}
int main() {
scanf("%d", &n);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v), adj[v].push_back(u);
}
dfs(1, 0);
int q, x, y, a, b, k;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
bool flag = false;
int tmp = k - dist(a, b);
if (tmp >= 0 && !(tmp & 1)) flag = true;
if (!flag) {
tmp = k - dist(a, x) - dist(y, b) - 1;
if (tmp >= 0 && !(tmp & 1)) flag = true;
}
if (!flag) {
tmp = k - dist(a, y) - dist(x, b) - 1;
if (tmp >= 0 && !(tmp & 1)) flag = true;
}
printf("%s\n", flag ? "YES" : "NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1.0) * 4;
const int64_t INF = 100000000000000003;
const int32_t LOG = 21;
const int MOD = 1e9 + 7;
int n, l;
vector<int> adj[100005];
int timer;
vector<int> tin, tout;
int up[100005][20];
int depth[100005];
void dfs(int v, int p) {
tin[v] = ++timer;
up[v][0] = p;
for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (int u : adj[v]) {
if (u != p) dfs(u, v);
}
tout[v] = ++timer;
}
bool is_ancestor(int u, int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], v)) u = up[u][i];
}
return up[u][0];
}
void preprocess(int root) {
tin.resize(n + 2);
tout.resize(n + 2);
timer = 0;
l = ceil(log2(n));
dfs(root, root);
}
void dfs1(int i, int prev, int depth1) {
depth[i] = depth1;
for (int j = 0; j < adj[i].size(); j++) {
if (adj[i][j] != prev) dfs1(adj[i][j], i, depth1 + 1);
}
}
int dist(int u, int v) {
int x = lca(u, v);
int ans = depth[u] + depth[v] - 2 * depth[x];
return ans;
}
bool check(int val1, int val11, int val, int value) {
if (val1 <= val && val11 == value) return true;
return false;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int tests = 1;
for (int ii = 0; ii < tests; ii++) {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs1(1, -1, 1);
preprocess(1);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int val1 = dist(a, b);
int val2 = dist(a, x) + dist(y, b) + 1;
int val3 = dist(a, y) + dist(x, b) + 1;
int val = k;
int val11 = val1 & 1, val22 = val2 & 1, val33 = val3 & 1;
int value = val & 1;
if (check(val1, val11, val, value) || check(val2, val22, val, value) ||
check(val3, val33, val, value))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long md(long long x) { return x < 1000000007 ? x : x % 1000000007; }
long long power(long long x, long long y) {
if (y == 0) {
return 1;
}
long long x_ = power(x, y / 2);
if (y & 1) {
return md(md(x_ * x_) * md(x));
} else {
return md(x_ * x_);
}
}
long long mod_inverse(long long x) { return power(x, 1000000007 - 2); }
vector<long long> tree[100001];
long long depth[100001];
long long parent[100001][18];
void dfs(long long cur, long long prev) {
depth[cur] = depth[prev] + 1;
parent[cur][0] = prev;
for (long long i = 0; i < tree[cur].size(); i++) {
if (tree[cur][i] != prev) dfs(tree[cur][i], cur);
}
}
void precomputeSparseMatrix(long long n) {
for (long long i = 1; i < 18; i++) {
for (long long node = 1; node <= n; node++) {
if (parent[node][i - 1] != -1)
parent[node][i] = parent[parent[node][i - 1]][i - 1];
}
}
}
long long lca(long long u, long long v) {
if (depth[v] < depth[u]) swap(u, v);
long long diff = depth[v] - depth[u];
long long ans = 0;
ans += diff;
for (long long i = 0; i < 18; i++)
if ((diff >> i) & 1) v = parent[v][i];
if (u == v) return ans;
for (long long i = 18 - 1; i >= 0; i--)
if (parent[u][i] != parent[v][i]) {
u = parent[u][i];
v = parent[v][i];
ans += 2 * (1 << i);
}
return ans + 2;
}
void addEdge(long long u, long long v) {
tree[u].push_back(v);
tree[v].push_back(u);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
memset(parent, -1, sizeof(parent));
for (long long i = 0; i < (n - 1); i++) {
long long u, v;
cin >> u >> v;
addEdge(u, v);
}
dfs(1, 0);
precomputeSparseMatrix(n);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long d = lca(a, b);
long long d1 = lca(a, x) + lca(b, y) + 1;
long long d2 = lca(a, y) + lca(b, x) + 1;
if (d <= k && (d & 1) == (k & 1)) {
cout << "YES" << endl;
} else if (d1 <= k && (d1 & 1) == (k & 1)) {
cout << "YES" << endl;
} else if (d2 <= k && (d2 & 1) == (k & 1)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10e5 + 5;
int n;
vector<int> G[maxn];
int f[18][maxn];
int d[maxn];
void dfs(int x) {
for (int i = 0; i < G[x].size(); i++) {
int v = G[x][i];
if (v == f[0][x]) continue;
f[0][v] = x;
d[v] = d[x] + 1;
dfs(v);
}
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
for (int i = 17; i >= 0; i--) {
if (d[x] - (1 << i) >= d[y]) x = f[i][x];
}
if (x == y) return x;
for (int 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 d[x] + d[y] - 2 * d[lca(x, y)]; }
bool check(int x, int y) { return y >= x && ((x % 2) == (y % 2)); }
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(1);
for (int i = 1; i <= 17; i++) {
for (int j = 1; j <= n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
}
}
int t;
cin >> t;
while (t--) {
int x1, y1, a1, b1, dist1;
cin >> x1 >> y1 >> a1 >> b1 >> dist1;
if (check(dis(a1, b1), dist1) ||
check(dis(a1, x1) + dis(y1, b1) + 1, dist1) ||
check(dis(a1, y1) + dis(x1, b1) + 1, dist1))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[200005];
int n;
int f[200005], size[200005], son[200005], top[200005], d[200005];
void dfs1(int u, int pre, int deep) {
f[u] = pre;
d[u] = deep;
size[u] = 1;
for (auto v : G[u]) {
if (v == pre) continue;
dfs1(v, u, deep + 1);
size[u] += size[v];
if (size[son[u]] < size[v]) son[u] = v;
}
}
void dfs2(int u, int tp) {
top[u] = tp;
if (son[u]) dfs2(son[u], tp);
for (auto v : G[u]) {
if (v == son[u] || v == f[u]) continue;
dfs2(v, v);
}
}
int LCA(int u, int v) {
while (top[u] != top[v]) {
if (d[top[u]] < d[top[v]]) swap(u, v);
u = f[top[u]];
}
if (d[u] > d[v]) swap(u, v);
return u;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs1(1, 0, 0);
dfs2(1, 1);
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int lca1 = LCA(a, b);
int dis1 = d[a] + d[b] - 2 * d[lca1];
if (k >= dis1 && (k - dis1) % 2 == 0) {
puts("YES");
continue;
}
int lca2 = LCA(a, x), lca3 = LCA(b, y);
int lca4 = LCA(a, y), lca5 = LCA(b, x);
int dis2 = d[a] + d[x] - 2 * d[lca2];
dis2 += d[b] + d[y] - 2 * d[lca3] + 1;
int dis3 = d[a] + d[y] - 2 * d[lca4];
dis3 += d[b] + d[x] - 2 * d[lca5] + 1;
if (k >= dis2 && (k - dis2) % 2 == 0) {
puts("YES");
continue;
}
if (k >= dis3 && (k - dis3) % 2 == 0) {
puts("YES");
continue;
}
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long INF = 1ll << 60;
const double Inf = 1e20;
const double eps = 1e-9;
void gmax(int &a, int b) { a = (a > b ? a : b); }
void gmin(int &a, int b) { a = (a < b ? a : b); }
const int maxn = 100050;
int n, dep[maxn], fa[maxn][20];
vector<int> adj[maxn];
void dfs(int u) {
for (auto p : adj[u])
if (!dep[p]) {
dep[p] = dep[u] + 1;
fa[p][0] = u;
dfs(p);
}
}
int get_lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int c = (dep[u] - dep[v]);
for (int j = 19; j >= 0; --j)
if (c & (1 << j)) u = fa[u][j];
for (int j = 19; j >= 0; --j)
if (fa[u][j] != fa[v][j]) u = fa[u][j], v = fa[v][j];
if (u != v)
return fa[u][0];
else
return u;
}
int calc(int x, int y) { return dep[x] + dep[y] - 2 * dep[get_lca(x, y)]; }
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);
}
dep[1] = 1;
dfs(1);
for (int j = 1; j <= 19; ++j)
for (int i = 1; i <= n; ++i) fa[i][j] = fa[fa[i][j - 1]][j - 1];
int q;
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
if (calc(a, b) <= k && (calc(a, b) % 2) == (k % 2))
printf("YES\n");
else if ((calc(a, x) + 1 + calc(y, b)) <= k &&
(calc(a, x) + 1 + calc(y, b)) % 2 == (k % 2))
printf("YES\n");
else if ((calc(a, y) + 1 + calc(x, b)) <= k &&
(calc(a, y) + 1 + calc(x, b)) % 2 == (k % 2))
printf("YES\n");
else if ((calc(a, x) + calc(x, y) + 1 + calc(x, b)) <= k &&
(calc(a, x) + calc(x, y) + 1 + calc(x, b)) % 2 == (k % 2))
printf("YES\n");
else if ((calc(a, y) + calc(y, x) + 1 + calc(y, b)) <= k &&
(calc(a, y) + calc(y, x) + 1 + calc(y, b)) % 2 == (k % 2))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string FILENAME = "filename";
unordered_map<int, unordered_set<int>> G;
unordered_map<int, int> mapper;
unordered_map<int, int> id;
int dpth[100001];
void preorder(unordered_map<int, unordered_set<int>> G) {
deque<pair<int, int>> S;
unordered_set<int> VST;
S.push_back(make_pair(1, 0));
while (!S.empty()) {
pair<int, int> V = S.front();
S.pop_front();
VST.insert(V.first);
dpth[V.first] = V.second;
for (int NB : G[V.first]) {
if (VST.count(NB)) continue;
S.push_back(make_pair(NB, V.second + 1));
}
}
}
vector<int> treetrav(unordered_map<int, unordered_set<int>> G) {
vector<int> R(2 * G.size() - 1);
unordered_map<int, int> VST;
stack<int> S;
S.push(1);
int I = 0;
while (!S.empty()) {
int V = S.top();
S.pop();
if (VST.count(V)) {
R[I++] = VST[V];
continue;
}
VST[V] = I;
R[I++] = VST[V];
for (int NB : G[V]) {
if (VST.count(NB)) continue;
S.push(V);
S.push(NB);
}
}
mapper = VST;
return R;
}
struct SegTree {
vector<int> T, REF;
int SZ;
SegTree(vector<int> A) {
SZ = A.size();
T.resize(SZ * 4);
REF = A;
build(0, 0, SZ - 1);
}
int build(int V, int L, int R) {
if (L == R) return T[V] = REF[L];
return T[V] = min(build(V * 2 + 1, L, (L + R) / 2),
build(V * 2 + 2, (L + R) / 2 + 1, R));
}
int value(int L, int R) { return value(0, 0, SZ - 1, L, R); }
int value(int ND, int SL, int SR, int L, int R) {
if (SR < L || SL > R)
return INT_MAX;
else if (L <= SL && R >= SR)
return T[ND];
return min(value(ND * 2 + 1, SL, (SL + SR) / 2, L, R),
value(ND * 2 + 2, (SL + SR) / 2 + 1, SR, L, R));
}
void update(int I, int V) { update(0, 0, SZ - 1, I, V); }
int update(int ND, int SL, int SR, int I, int V) {
if (I < SL || I > SR) return T[ND];
if (SL == SR) return T[ND] = V;
return T[ND] = min(update(ND * 2 + 1, SL, (SL + SR) / 2, I, V),
update(ND * 2 + 2, (SL + SR) / 2 + 1, SR, I, V));
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].insert(b);
G[b].insert(a);
}
preorder(G);
vector<int> thingy = treetrav(G);
for (auto it : mapper) id[it.second] = it.first;
SegTree LK(thingy);
int q;
cin >> q;
for (int _ = 0; _ < q; _++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int LCA =
id[LK.value(min(mapper[a], mapper[b]), max(mapper[a], mapper[b]))];
int pathl = -2 * dpth[LCA] + dpth[a] + dpth[b];
if (pathl <= k and k % 2 == pathl % 2) {
cout << "YES" << endl;
continue;
}
int LCA2 =
id[LK.value(min(mapper[a], mapper[x]), max(mapper[a], mapper[x]))];
int LCA3 =
id[LK.value(min(mapper[y], mapper[b]), max(mapper[y], mapper[b]))];
int pathl2 = -2 * dpth[LCA2] + dpth[a] + dpth[x];
int pathl3 = -2 * dpth[LCA3] + dpth[y] + dpth[b];
if (pathl2 + pathl3 + 1 <= k and (pathl2 + pathl3 + 1) % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
LCA2 = id[LK.value(min(mapper[b], mapper[x]), max(mapper[b], mapper[x]))];
LCA3 = id[LK.value(min(mapper[y], mapper[a]), max(mapper[y], mapper[a]))];
pathl2 = -2 * dpth[LCA2] + dpth[b] + dpth[x];
pathl3 = -2 * dpth[LCA3] + dpth[y] + dpth[a];
if (pathl2 + pathl3 + 1 <= k and (pathl2 + pathl3 + 1) % 2 == k % 2) {
cout << "YES" << endl;
continue;
}
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, u, v, q, x, y, a, b, k, p[100007][22], d[100007];
vector<long long int> adj[100007];
void dfs(long long int x, long long int par) {
d[x] = d[par] + 1;
p[x][0] = par;
for (long long int i = 1; i <= 20; ++i) {
p[x][i] = p[p[x][i - 1]][i - 1];
}
for (long long int i : adj[x]) {
if (i != par) dfs(i, x);
}
}
long long int dist(long long int a, long long int b) {
if (d[a] > d[b]) swap(a, b);
long long int res = 0;
for (long long int i = 19; i >= 0; --i) {
if (d[p[b][i]] >= d[a]) {
b = p[b][i];
res += (1 << i);
}
}
if (a == b) return res;
for (long long int i = 19; i >= 0; --i) {
if (p[b][i] != p[a][i]) {
b = p[b][i];
a = p[a][i];
res += (1 << (i + 1));
}
}
return res + 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long int i = 0; i < n - 1; ++i) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
long long int ans = dist(a, b), ans2 = (dist(a, x) + dist(y, b)) + 1,
ans3 = (dist(a, y) + dist(x, b)) + 1;
long long int f = 0x3f3f3f3f3f3f3f3f;
if (ans % 2 == k % 2) f = min(f, ans);
if (ans2 % 2 == k % 2) f = min(f, ans2);
if (ans3 % 2 == k % 2) f = min(f, ans3);
if (f <= k)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, k, a, b, c, tmp, ans, xx, yy, gg[200005], root[200005],
rt[200005], anx[200005], any[200005], dep[600000], jp[600000][50];
vector<int> ee[200005];
priority_queue<int> q, qq;
void jpp(int first, int fa) {
int ii;
gg[first] = 1;
dep[first] = dep[fa] + 1;
for (int ii = 1; ii <= 20; ii++) {
jp[first][ii] = jp[jp[first][ii - 1]][ii - 1];
}
for (int ii = 0; ii < ee[first].size(); ii++)
if (ee[first][ii] != fa) {
jp[ee[first][ii]][0] = first;
jpp(ee[first][ii], first);
}
}
int lca(int first, int second) {
int cost = 0, ii;
if (dep[first] < dep[second]) swap(first, second);
for (int ii = 20; ii >= 0; ii--) {
if (dep[jp[first][ii]] >= dep[second]) {
cost += (1 << ii);
first = jp[first][ii];
}
if (first == second) return cost;
}
for (int ii = 20; ii >= 0; ii--) {
if (jp[first][ii] != jp[second][ii]) {
cost += (1 << ii) * 2;
first = jp[first][ii];
second = jp[second][ii];
}
}
return cost + 2;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
ee[a].push_back(b);
ee[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (ee[i].size() == 1 && gg[i] == 0) {
jpp(i, i);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d%d%d", &xx, &yy, &a, &b, &c);
ans = 0;
tmp = lca(a, b);
if (tmp <= c && (c - tmp) % 2 == 0) ans = 1;
tmp = lca(a, xx) + lca(yy, b) + 1;
if (tmp <= c && (c - tmp) % 2 == 0) ans = 1;
tmp = lca(a, yy) + lca(xx, b) + 1;
if (tmp <= c && (c - tmp) % 2 == 0) ans = 1;
if (ans)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __f(const char*, T&&);
template <typename T1, typename... T2>
void __f(const char*, T1&&, T2&&...);
const int N = 2e5 + 5;
const int maxHeight = 20 + 1;
int level[N], parent[N], dp[N][maxHeight];
vector<vector<int>> gph(N);
int n, q;
void dfs(int u, int par, int lvl) {
parent[u] = par;
level[u] = lvl;
for (auto v : gph[u])
if (v != par) dfs(v, u, lvl + 1);
}
void fill_dp() {
for (int i = 1; i <= n; i++) dp[i][0] = parent[i];
for (int j = 1; j < maxHeight; j++) {
for (int i = 1; i <= n; i++) {
dp[i][j] = dp[dp[i][j - 1]][j - 1];
}
}
}
int lca(int u, int v) {
if (level[v] < level[u]) {
swap(u, v);
}
int difference = level[v] - level[u];
while (difference > 0) {
int _log = log2(difference);
v = dp[v][_log];
difference -= (1 << _log);
}
while (u != v) {
int i = log2(level[u]);
while (i > 0 && dp[u][i] == dp[v][i]) i--;
u = dp[u][i];
v = dp[v][i];
}
return u;
}
long long distance_btw_two(int u, int v) {
return level[u] + level[v] - 2 * level[lca(u, v)];
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
gph[u].push_back(v);
gph[v].push_back(u);
}
dfs(1, 0, 0);
fill_dp();
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long dist_a_b = 0, min_dist = 0, ans = INT32_MAX;
dist_a_b = distance_btw_two(a, b);
min_dist = min(distance_btw_two(a, x) + distance_btw_two(b, y),
distance_btw_two(a, y) + distance_btw_two(b, x)) +
1;
if (k % 2 == dist_a_b % 2) ans = dist_a_b;
if (k % 2 == min_dist % 2) ans = min(ans, min_dist);
if (ans <= k)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
template <typename T>
void __f(const char* variable_name, T&& value) {
cout << variable_name << ": " << value << endl;
}
template <typename T1, typename... T2>
void __f(const char* names, T1&& arg1, T2&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt;
edge(int to = 0, int nxt = -1) : to(to), nxt(nxt) {}
} e[200001];
int n, q, head[100001], E, dep[100001], f[100001][21];
void checkmin(int &x, int y) {
if (x > y) {
x = y;
}
}
void add(int f, int t) {
e[E].to = t;
e[E].nxt = head[f];
head[f] = E++;
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= 20; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
for (int i = head[u]; i != -1; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) {
continue;
}
dfs(v, u);
}
}
int get(int x, int y) {
int ans = 0;
if (dep[x] > dep[y]) {
swap(x, y);
}
for (int i = 20; i >= 0; i--) {
if (dep[f[y][i]] >= dep[x]) {
y = f[y][i];
ans += (1 << i);
}
}
if (x == y) {
return ans;
}
for (int i = 20; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i];
y = f[y][i];
ans += (1 << (i + 1));
}
}
return ans + 2;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
memset(head, -1, sizeof(head));
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
scanf("%d", &q);
while (q--) {
int x, y, a, b, k, t1, t2, ans = 2e9;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
t1 = get(a, b);
t2 = min(get(a, x) + get(b, y), get(b, x) + get(a, y)) + 1;
if (!((t1 ^ k) & 1)) {
checkmin(ans, t1);
}
if (!((t2 ^ k) & 1)) {
checkmin(ans, t2);
}
if (ans <= k) {
printf("YES\n");
} else {
printf("NO\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int MOD = INT_MAX;
const double PI = acos(-1);
void openfile() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
const int N = 1e5 + 5;
vector<int> G[N];
int parent[25][N];
int depth[N];
int n;
void dfs(int v, int par, int d) {
parent[0][v] = par;
depth[v] = d;
for (int i = 0; i < ((long long int)G[v].size()); i++) {
if (G[v][i] != par) dfs(G[v][i], v, d + 1);
}
}
void init() {
dfs(1, -1, 0);
for (int k = 0; k < 20; k++) {
for (int i = 1; i <= n; i++) {
if (parent[k][i] < 0)
parent[k + 1][i] = -1;
else
parent[k + 1][i] = parent[k][parent[k][i]];
}
}
}
int lca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < 20; k++) {
if ((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
}
if (u == v) return u;
for (int k = 19; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int i = 0; i < (n - 1); i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
init();
int q;
cin >> q;
for (long long int qq = 0; qq < (q); qq++) {
int a, b, x, y, d;
cin >> a >> b >> x >> y >> d;
int xy_lca = lca(x, y);
int ax_lca = lca(a, x);
int ay_lca = lca(a, y);
int bx_lca = lca(b, x);
int by_lca = lca(b, y);
int xy_length = depth[x] + depth[y] - depth[xy_lca] * 2;
int ax_length = depth[a] + depth[x] - depth[ax_lca] * 2;
int ay_length = depth[a] + depth[y] - depth[ay_lca] * 2;
int bx_length = depth[b] + depth[x] - depth[bx_lca] * 2;
int by_length = depth[b] + depth[y] - depth[by_lca] * 2;
bool ok = 0;
if (xy_length <= d && (d - xy_length) % 2 == 0) ok = 1;
if (ax_length + by_length + 1 <= d &&
(d - (ax_length + by_length + 1)) % 2 == 0)
ok = 1;
if (ay_length + bx_length + 1 <= d &&
(d - (ay_length + bx_length + 1)) % 2 == 0)
ok = 1;
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, q;
vector<int> g[maxn];
int d[maxn];
int deda[maxn][20];
int brojac;
int in[maxn];
int out[maxn];
void dfs(int v, int p) {
deda[v][0] = p;
for (int i = 1; i < 18; i++) deda[v][i] = deda[deda[v][i - 1]][i - 1];
in[v] = ++brojac;
for (auto u : g[v]) {
if (u != p) {
d[u] = d[v] + 1;
dfs(u, v);
}
}
out[v] = brojac;
}
bool predak(int u, int v) { return (in[u] <= in[v] && out[u] >= out[v]); }
int lca(int u, int v) {
if (predak(u, v)) return u;
if (predak(u, v)) return v;
for (int i = 18; i >= 0; i--) {
if (deda[u][i] && !predak(deda[u][i], v)) u = deda[u][i];
}
return deda[u][0];
}
int dist(int u, int v) { return d[u] + d[v] - 2 * d[lca(u, v)]; }
long long calc(int u) {
for (int i = 18; i >= 0; i--) {
if (u & (1 << i)) u = deda[u][i];
}
return u;
}
bool check(int x, int k) { return (x <= k && (x % 2 == k % 2)); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int kec = dist(a, b);
int dva = dist(a, x) + dist(b, y) + 1;
int tri = dist(b, x) + dist(a, y) + 1;
if (check(kec, k) || check(dva, k) || check(tri, k))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 100 + 5;
const long long inf = 9223372036854775807;
int n, q, mark[maxn], h[maxn], par[maxn][50];
vector<int> adj[maxn];
void dfs(int v) {
mark[v] = 1;
for (auto u : adj[v]) {
if (mark[u] == 0) {
mark[u] = 1;
h[u] = h[v] + 1;
par[u][0] = v;
for (int i = 1; i <= 31; i++) {
par[u][i] = par[par[u][i - 1]][i - 1];
}
dfs(u);
}
}
}
int lca(int u, int v) {
if (h[v] < h[u]) {
swap(u, v);
}
for (int i = 31; i >= 0; i--) {
if (par[v][i] != 0 && h[par[v][i]] >= h[u]) {
v = par[v][i];
}
}
if (v == u) return v;
for (int i = 31; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
v = par[v][i], u = par[u][i];
}
}
return par[v][0];
}
int lp(int u, int v) {
int lc = lca(u, v), ans = 0;
for (int i = 31; i >= 0; i--) {
if (par[u][i] != 0 && h[par[u][i]] >= h[lc]) {
ans += pow(2, i);
u = par[u][i];
}
if (par[v][i] != 0 && h[par[v][i]] >= h[lc]) {
ans += pow(2, i);
v = par[v][i];
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
cin >> q;
for (int i = 1; i <= q; i++) {
int u, v, a, b, k;
cin >> u >> v >> a >> b >> k;
int x = lp(a, b), y = lp(a, u) + 1 + lp(v, b), z = lp(a, v) + 1 + lp(u, b);
if (x <= k && x % 2 == k % 2) {
cout << "YES";
} else if (y <= k && y % 2 == k % 2) {
cout << "YES";
} else if (z <= k && z % 2 == k % 2) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int qur;
bool vis[200001];
int f[200001][21], deep[200001];
int first[200001], nex[200001], v[200001], num;
inline void add(int x, int y) {
num++;
v[num] = y;
nex[num] = first[x];
first[x] = num;
}
inline void pre(int u, int fa) {
vis[u] = true;
deep[u] = deep[fa] + 1;
f[u][0] = fa;
for (int i = 1; i <= 20; i++) {
f[u][i] = f[f[u][i - 1]][i - 1];
}
for (int i = first[u]; i != -1; i = nex[i]) {
int to = v[i];
if (!vis[to]) pre(to, u);
}
}
inline int lca(int x, int y) {
if (deep[x] < deep[y]) swap(x, y);
for (int i = 20; i >= 0; i--) {
if (deep[f[x][i]] >= deep[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 main() {
memset(first, -1, sizeof first);
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
pre(1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, a, b, k;
bool flag = false;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
int len1 = deep[a] + deep[b] - 2 * deep[lca(a, b)];
int len2 = deep[a] + deep[x] - 2 * deep[lca(a, x)] + deep[y] + deep[b] -
2 * deep[lca(y, b)] + 1;
int len3 = deep[a] + deep[y] - 2 * deep[lca(a, y)] + 1 + deep[x] + deep[b] -
2 * deep[lca(x, b)];
if (len1 <= k && (k - len1) % 2 == 0) {
flag = true;
}
if (len2 <= k && (k - len2) % 2 == 0) {
flag = true;
}
if (len3 <= k && (k - len3) % 2 == 0) {
flag = true;
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct yyy {
int t, nex;
} e[2 * 100005];
int depth[100005] = {0}, fa[100005][22] = {0}, lg[100005] = {0}, head[100005];
int tot;
void add(int x, int y) {
e[++tot].t = y;
e[tot].nex = head[x];
head[x] = tot;
}
void dfs(int f, int fath) {
depth[f] = depth[fath] + 1;
fa[f][0] = fath;
for (int i = 1; (1 << i) <= depth[f]; i++) fa[f][i] = fa[fa[f][i - 1]][i - 1];
for (int i = head[f]; i; i = e[i].nex)
if (e[i].t != fath) dfs(e[i].t, f);
}
int lca(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
for (int i = 0; i < 22; i++)
if ((depth[x] - depth[y]) & (1 << i)) x = fa[x][i];
if (x == y) return x;
for (int k = lg[depth[x]] - 1; k >= 0; k--)
if (fa[x][k] != fa[y][k]) x = fa[x][k], y = fa[y][k];
return fa[x][0];
}
int askd(int x, int y) { return depth[x] + depth[y] - 2 * depth[lca(x, y)]; }
int n, m, s;
int main() {
scanf("%d", &n);
s = 1;
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(s, 0);
for (int i = 1; i <= n; i++) lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int without = askd(a, b);
int with = min(askd(a, x) + askd(y, b), askd(a, y) + askd(x, b)) + 1;
int ans = 0x3f3f3f3f;
if (without % 2 == k % 2) ans = without;
if (with % 2 == k % 2) ans = min(ans, with);
cout << (ans <= k ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, tim = 0;
long long strtim[100005], endtim[100005], level[100005];
long long par[20 + 5][100005];
vector<long long> gr[100005];
void dfs(long long x, long long parent, long long lvl) {
strtim[x] = ++tim;
level[x] = lvl;
par[0][x] = parent;
for (auto it : gr[x])
if (it != parent) dfs(it, x, lvl + 1);
endtim[x] = tim;
}
void precompute() {
for (long long j = 1; j < 20; j++)
for (long long i = 1; i <= n; i++) par[j][i] = par[j - 1][par[j - 1][i]];
}
long long kth_ancestor(long long u, long long k) {
for (long long j = 20; j >= 0; j--)
if (k & (1LL << j)) u = par[j][u];
return u;
}
long long LCA(long long u, long long v) {
if (level[u] < level[v]) swap(u, v);
long long diff = level[u] - level[v];
for (long long i = 20 - 1; i >= 0; i--) {
if ((1 << i) & diff) {
u = par[i][u];
}
}
if (u == v) return u;
for (long long i = 20 - 1; i >= 0; i--) {
if (par[i][u] && par[i][u] != par[i][v]) {
u = par[i][u];
v = par[i][v];
}
}
return par[0][u];
}
long long dist(long long u, long long v) {
return level[u] + level[v] - 2 * level[LCA(u, v)];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
gr[x].push_back(y);
gr[y].push_back(x);
}
dfs(1, 0, 1);
precompute();
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long flag = 0;
long long dist_a_b = dist(a, b);
long long dist_a_x_y_b = dist(a, x) + 1 + dist(y, b);
long long dist_a_y_x_b = dist(a, y) + 1 + dist(x, b);
if ((k - dist_a_b) >= 0 and (k - dist_a_b) % 2 == 0) flag = 1;
if ((k - dist_a_x_y_b) >= 0 and (k - dist_a_x_y_b) % 2 == 0) flag = 1;
if ((k - dist_a_y_x_b) >= 0 and (k - dist_a_y_x_b) % 2 == 0) flag = 1;
if (flag == 1)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 5;
struct node {
int to, nxt;
} e[N << 1];
int h[N], tot, p[N][17], d[N];
inline void add(int a, int b) {
e[++tot].to = b;
e[tot].nxt = h[a];
h[a] = tot;
}
void dfs(int u, int pre) {
d[u] = d[pre] + 1;
p[u][0] = pre;
for (register int i = 1; i <= 16; ++i) p[u][i] = p[p[u][i - 1]][i - 1];
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == pre) continue;
dfs(v, u);
}
}
int lca(int a, int b) {
if (d[a] > d[b]) {
int temp = a;
a = b;
b = temp;
};
register int i;
for (i = 16; i >= 0; --i)
if (d[a] <= d[b] - (1 << i)) b = p[b][i];
if (a == b) return a;
for (i = 16; i >= 0; --i)
if (p[a][i] != p[b][i]) a = p[a][i], b = p[b][i];
return p[a][0];
}
int main() {
int q, n, a, b, x, y, k;
register int i;
scanf("%d", &n);
for (i = 1; i < n; ++i) {
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
dfs(1, 0);
scanf("%d", &q);
for (i = 1; i <= q; ++i) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int c = lca(a, b), dis;
dis = d[a] + d[b] - 2 * d[c];
if (dis <= k && (k - dis) % 2 == 0)
printf("YES\n");
else {
c = lca(a, x);
dis = d[a] + d[x] - 2 * d[c];
c = lca(b, y);
dis += d[b] + d[y] - 2 * d[c] + 1;
if (dis <= k && (k - dis) % 2 == 0)
printf("YES\n");
else {
c = lca(a, y);
dis = d[a] + d[y] - 2 * d[c];
c = lca(b, x);
dis += d[b] + d[x] - 2 * d[c] + 1;
if (dis <= k && (k - dis) % 2 == 0)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-9;
const long long MOD = 1e9 + 7;
const long long INF = 0x3f3f3f3f;
const long long MAXN = 1e5 + 7;
const long long LOG = 20;
int n, q, h[MAXN], f[MAXN][LOG];
vector<int> g[MAXN];
void dfs(int u, int fa, int height) {
h[u] = height;
f[u][0] = fa;
for (int i = 1; i < LOG; ++i) f[u][i] = f[f[u][i - 1]][i - 1];
for (auto v : g[u]) {
if (v == fa) continue;
dfs(v, u, height + 1);
}
}
int proc(int a, int b) {
int x = h[a], y = h[b];
if (x < y) swap(a, b);
for (int i = LOG - 1; i >= 0; --i) {
if (h[f[a][i]] >= h[b]) a = f[a][i];
}
if (h[a] > h[b]) a = f[a][0];
for (int i = LOG - 1; i >= 0; --i) {
if (f[a][i] != f[b][i]) a = f[a][i], b = f[b][i];
}
if (a != b) a = f[a][0];
int z = x - h[a] + y - h[a];
return z;
}
void solve() {
cin >> n;
for (int u, v, i = 1; i < n; ++i) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0, 1);
int x, y, a, b, k;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
vector<int> path;
path.push_back(proc(a, b));
path.push_back(proc(a, x) + 1 + proc(y, b));
path.push_back(proc(a, y) + 1 + proc(x, b));
int ans = 0;
for (auto v : path) ans |= (v <= k && (v & 1) == (k & 1));
cout << (ans ? "YES" : "NO") << endl;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, Case = 1;
while (Case--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long pp = 1e6;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
long long n, m, k;
int dad[18][pp], h[pp];
vector<int> V[pp];
string S;
map<long long, long long> M;
set<long long> Set;
void dfs(int u) {
for (auto v : V[u])
if (v != dad[0][u]) {
dad[0][v] = u;
h[v] = h[u] + 1;
dfs(v);
}
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int i = 17; i >= 0; --i)
if (((h[u] - h[v]) >> i) & 1) u = dad[i][u];
if (u == v) return u;
for (int i = 17; i >= 0; --i)
if (dad[i][u] != dad[i][v]) u = dad[i][u], v = dad[i][v];
return dad[0][u];
}
int get(int u, int v) { return (h[u] + h[v] - 2 * h[lca(u, v)]); }
bool ok(int x, int y) { return y >= x && x % 2 == y % 2; }
void dowork() {
cin >> n;
for (int i = 1; i <= n - 1; ++i) {
int u, v;
cin >> u >> v;
V[u].push_back(v);
V[v].push_back(u);
}
dfs(1);
for (int i = 1; i <= 17; ++i)
for (int j = 1; j <= n; ++j) dad[i][j] = dad[i - 1][dad[i - 1][j]];
cin >> m;
for (int i = 1; i <= m; ++i) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int path1 = get(a, b);
int path2 = get(a, x) + get(b, y) + 1;
int path3 = get(a, y) + get(b, x) + 1;
if (ok(path1, k) || ok(path2, k) || ok(path3, k)) {
cout << "YES";
} else
cout << "NO";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
dowork();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 100;
const int INF = 0x3f3f3f3f;
inline long long fpow(long long a, long long b) {
long long r = 1, t = a;
while (b) {
if (b & 1) r = (r * t) % MOD;
b >>= 1;
t = (t * t) % MOD;
}
return r;
}
vector<int> G[MAXN << 1];
int dep[MAXN], f[MAXN][30], n, q;
int dis[MAXN];
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
f[x][0] = fa;
for (int i = 1; (1 << i) <= dep[x]; i++) f[x][i] = f[f[x][i - 1]][i - 1];
for (auto it : G[x]) {
if (it != fa) dis[it] = dis[x] + 1, dfs(it, x);
}
}
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 21; i >= 0; i--) {
if (dep[x] - (1 << i) >= dep[y]) x = f[x][i];
}
if (x == y) return x;
for (int i = 21; i >= 0; i--) {
if (f[x][i] == f[y][i]) continue;
x = f[x][i], y = f[y][i];
}
return f[x][0];
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int ui, vi;
scanf("%d %d", &ui, &vi);
G[ui].push_back(vi);
G[vi].push_back(ui);
}
dfs(1, 0);
cin >> q;
while (q--) {
int x, y, u, v, k;
scanf("%d %d %d %d %d", &x, &y, &u, &v, &k);
int num = dis[x] + dis[y] - 2 * dis[LCA(x, y)] + 1;
int uv = dis[u] + dis[v] - 2 * dis[LCA(u, v)];
int ux = dis[u] + dis[x] - 2 * dis[LCA(u, x)];
int uy = dis[u] + dis[y] - 2 * dis[LCA(u, y)];
int vx = dis[v] + dis[x] - 2 * dis[LCA(v, x)];
int vy = dis[v] + dis[y] - 2 * dis[LCA(v, y)];
if ((uv & 1) == (k & 1)) {
if (uv <= k)
printf("YES\n");
else {
if (!(num & 1) && (ux + 1 + vy <= k || (uy + 1 + vx <= k)))
printf("YES\n");
else
printf("NO\n");
}
} else {
if (!(num & 1))
printf("NO\n");
else {
if (ux + 1 + vy <= k || uy + 1 + vx <= k)
printf("YES\n");
else
printf("NO\n");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, f[100100][30], dep[100100];
int cnt, bg[100100], ne[200100], to[200100];
void add(int x, int y) {
cnt++;
ne[cnt] = bg[x];
to[cnt] = y;
bg[x] = cnt;
}
void dfs(int x, int fa) {
f[x][0] = fa;
dep[x] = dep[fa] + 1;
for (int i = bg[x]; i; i = ne[i]) {
int y = to[i];
if (y != fa) {
dfs(y, x);
}
}
}
void ycl() {
for (int j = 1; j <= 25; j++) {
for (int i = 1; i <= n; i++) {
f[i][j] = f[f[i][j - 1]][j - 1];
}
}
}
int get_le(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int sum = 0;
for (int i = 25; i >= 0; i--) {
if (dep[f[x][i]] >= dep[y]) {
sum += (1 << i);
x = f[x][i];
}
}
if (x == y) {
return sum;
}
for (int i = 25; i >= 0; i--) {
if (f[x][i] != f[y][i]) {
x = f[x][i], y = f[y][i];
sum += (1 << i) * 2;
}
}
return sum + 2;
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0);
ycl();
cin >> m;
for (int i = 1; i <= m; i++) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int q1, q2, q3;
q1 = get_le(a, b);
q2 = get_le(a, x) + get_le(b, y) + 1;
q3 = get_le(b, x) + get_le(a, y) + 1;
if ((q1 <= k && q1 % 2 == k % 2) || (q2 <= k && q2 % 2 == k % 2) ||
(q3 <= k && q3 % 2 == k % 2)) {
puts("YES");
} else {
puts("NO");
}
}
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 1e18 + 7, mod = 998244353, MAXN = 1e5, SQ = 450,
pp = 1e5 + 3;
const long double EPS = 1e-9, PI = acos(-1);
using namespace std;
namespace in_out {
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> a) {
for (auto i : a) out << i << " ";
return out;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (auto& i : a) in >> i;
return in;
}
} // namespace in_out
using namespace in_out;
vector<vector<int>> g, up;
vector<int> deep;
int clca, clen;
int x, y, a, b, k;
void dfs(int v, int p = -1, int d = 0) {
if (p != -1) {
up[0][v] = p;
for (int i = 1; i < 25; i++) up[i][v] = up[i - 1][up[i - 1][v]];
}
deep[v] = d;
for (auto& i : g[v])
if (i != p) dfs(i, v, d + 1);
}
int get_lca(int v, int u) {
if (deep[v] < deep[u]) swap(v, u);
int h = deep[v] - deep[u];
for (int i = 24; i >= 0; i--)
if (h >= (1 << i)) v = up[i][v], h -= (1 << i);
for (int i = 24; i >= 0; i--) {
if (up[i][v] == up[i][u]) continue;
v = up[i][v];
u = up[i][u];
}
if (v != u) return up[0][v];
return v;
}
int dist(int v, int u, int lca) { return deep[v] + deep[u] - 2 * deep[lca]; }
signed main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
g.resize(n);
deep.resize(n);
up.resize(25, vector<int>(n));
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
dfs(0);
int q;
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
int d1 = dist(a, b, get_lca(a, b));
int d2 = dist(a, x, get_lca(a, x)) + dist(b, y, get_lca(b, y)) + 1;
int d3 = dist(b, x, get_lca(b, x)) + dist(a, y, get_lca(a, y)) + 1;
if ((d1 <= k && d1 % 2 == k % 2) || (d2 <= k && d2 % 2 == k % 2) ||
(d3 <= k && d3 % 2 == k % 2))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v;
int N;
int pa[100005][18];
int h[100006];
int chk[100006];
void dfs(int x) {
chk[x] = 1;
for (int y : v[x])
if (!chk[y]) {
pa[y][0] = x;
h[y] = h[x] + 1;
dfs(y);
}
}
long long dis(int x, int y) {
if (h[x] > h[y]) swap(x, y);
int k = h[y] - h[x];
long long res = k;
for (int i = 0; i < 18; i++)
if ((k >> i) & 1) y = pa[y][i];
if (x == y) return res;
for (int i = 17; i >= 0; i--)
if (pa[x][i] != pa[y][i]) {
x = pa[x][i];
y = pa[y][i];
res += 2 << i;
}
return res + 2;
}
int main() {
scanf("%d", &N);
v.resize(N + 1);
for (int i = 1; i < N; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
pa[1][0] = 1;
for (int j = 1; j <= 17; j++)
for (int i = 1; i <= N; i++) pa[i][j] = pa[pa[i][j - 1]][j - 1];
int Q;
scanf("%d", &Q);
while (Q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
long long len;
len = dis(a, b);
if (k >= len && (k - len) % 2 == 0) {
puts("YES");
continue;
}
len = dis(a, x) + 1 + dis(y, b);
if (k >= len && (k - len) % 2 == 0) {
puts("YES");
continue;
}
len = dis(a, y) + 1 + dis(x, b);
if (k >= len && (k - len) % 2 == 0) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ri() {
int x;
if (scanf(" %d", &x) == EOF) return -1;
return x;
}
long long int rl() {
long long int x;
if (cin >> x) return x;
return -1;
}
string rs() {
string s;
if (cin >> s) return s;
return "";
}
struct Minimum {
int x;
static const int INF = (1 << 29);
Minimum(int x) : x(x) {}
Minimum() : x(INF) {}
static Minimum identity() { return Minimum(INF); }
static Minimum make(const int& x) { return Minimum(x); }
static Minimum combine(Minimum a, Minimum b) {
return Minimum(min(a.x, b.x));
}
void print() { printf("{Minimum = %lld}", x); }
};
template <typename Data, typename Input>
class SegmentTree {
private:
int n;
vector<Data> dv;
public:
SegmentTree(const vector<Input>& input) {
n = input.size();
int vectorSize = 1;
while (vectorSize < n) {
vectorSize *= 2;
}
vectorSize *= 2;
dv = vector<Data>(vectorSize, Data::identity());
build(input, 0, 0, n);
}
void update(int x, Input& val) { update(x, val, 0, 0, n); }
void update(int left, int right, Input& val) { assert(false); }
Data query(int left, int right) {
assert(left >= 0 && right <= n);
return query(0, 0, n, left, right);
}
void print() {
printf("Tree size for n = %d is %d\n", n, dv.size());
for (auto& d : dv) {
d.print();
cout << " ";
}
cout << endl;
}
private:
Data query(int root, int tl, int tr, int l, int r) {
if (l >= r) {
return Data::identity();
}
if (l == tl && r == tr) {
return dv[root];
}
int tm = (tl + tr + 1) / 2;
Data left = query(2 * root + 1, tl, tm, l, min(r, tm));
Data right = query(2 * root + 2, tm, tr, max(tm, l), r);
return Data::combine(left, right);
}
void update(int x, Input& val, int root, int tl, int tr) {
if (tl == tr - 1) {
dv[root] = Data::make(val);
return;
}
int tm = (tl + tr + 1) / 2;
if (x < tm)
update(x, val, 2 * root + 1, tl, tm);
else
update(x, val, 2 * root + 2, tm, tr);
dv[root] = Data::combine(dv[2 * root + 1], dv[2 * root + 2]);
}
Data build(const vector<Input>& values, int root, int tl, int tr) {
if (tl == tr - 1) {
return dv[root] = Data::make(values[tl]);
}
int tm = (tl + tr + 1) / 2;
Data left = build(values, 2 * root + 1, tl, tm);
Data right = build(values, 2 * root + 2, tm, tr);
return dv[root] = Data::combine(left, right);
}
};
struct Tree {
int n;
SegmentTree<Minimum, int> lcaTree;
vector<vector<int> > edges;
vector<int> firstPos;
vector<int> heights;
Tree(int n) : n(n), lcaTree(vector<int>(1, 1)), edges(n), firstPos(n, -1) {}
void readInput() {
for (int i = 0; i < n; ++i)
if (i) {
int u = ri() - 1;
int v = ri() - 1;
edges[u].push_back(v);
edges[v].push_back(u);
}
}
void solveQueries() {
int q = ri();
for (int i = 0; i < q; ++i) {
int nu = ri() - 1;
int nv = ri() - 1;
int a = ri() - 1;
int b = ri() - 1;
int K = ri();
solveQuery(nu, nv, a, b, K);
}
}
int d(int u, int v) {
int fu = firstPos[u], fv = firstPos[v];
if (fu > fv) swap(fu, fv);
int hu = heights[fu], hv = heights[fv];
int hc = lcaTree.query(fu, fv + 1).x;
int ret = (hu - hc) + (hv - hc);
return ret;
}
void solveQuery(int nu, int nv, int a, int b, int K) {
int p1 = d(a, b);
int p2 = d(a, nu) + 1 + d(nv, b);
int p3 = d(a, nv) + 1 + d(nu, b);
vector<int> temp = {p1, p2, p3};
assert(temp.size() == 3);
vector<int> D(2, 1000000009);
for (auto x : temp) {
if (x < D[x % 2]) D[x % 2] = x;
}
bool possible = (K >= D[K % 2]);
string ret = possible ? "YES" : "NO";
cout << ret << endl;
}
void precompute() {
doit(0, -1, 0, heights);
lcaTree = {heights};
}
void doit(int u, int parent, int h, vector<int>& heights) {
if (firstPos[u] < 0) firstPos[u] = heights.size();
heights.push_back(h);
for (auto v : edges[u])
if (v != parent) {
doit(v, u, h + 1, heights);
heights.push_back(h);
}
}
};
struct SingleCase {
int n;
bool solveCase() {
n = ri();
if (n < 0) return false;
Tree tree(n);
tree.readInput();
tree.precompute();
tree.solveQueries();
return true;
}
};
int main() {
while (SingleCase().solveCase()) {
};
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 5;
const int pmax = 17;
vector<int> l[nmax];
int tata[nmax], lca[nmax][30], d[nmax];
void dfs(int nod, int t) {
lca[nod][0] = t;
d[nod] = d[t] + 1;
for (int fiu : l[nod])
if (fiu != t) dfs(fiu, nod);
}
void build_lca(int n) {
for (int i = 1; i <= pmax; i++)
for (int j = 1; j <= n; j++) lca[j][i] = lca[lca[j][i - 1]][i - 1];
}
int find_lca(int x, int y) {
int l = 0;
if (d[x] < d[y]) swap(x, y);
int dd = d[x] - d[y];
while (dd) {
int z = dd & (-dd);
int xe = (int)log2(z);
x = lca[x][xe];
dd -= z;
l += z;
}
if (x == y) return l;
l += 2;
for (int i = pmax; i >= 0; i--)
if (lca[x][i] != lca[y][i]) {
x = lca[x][i];
y = lca[y][i];
l += (1 << (i + 1));
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, u, v, q, x, y, k;
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
l[u].push_back(v);
l[v].push_back(u);
}
dfs(1, 0);
build_lca(n);
cin >> q;
while (q--) {
int mn = INT_MAX;
cin >> x >> y >> u >> v >> k;
int lcadir = find_lca(u, v);
int lcaxy = find_lca(u, x) + find_lca(y, v) + 1;
int lcayx = find_lca(u, y) + find_lca(x, v) + 1;
if ((lcadir & 1) == (k & 1)) mn = min(mn, lcadir);
if ((lcaxy & 1) == (k & 1)) mn = min(mn, lcaxy);
if ((lcayx & 1) == (k & 1)) mn = min(mn, lcayx);
cout << ((mn <= k) ? "YES" : "NO") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> aray[100001];
vector<int> euler;
int dist[100001];
void dfs(int root, int count) {
dist[root] = count;
euler.push_back(root);
for (int i = 0; i < aray[root].size(); i++) {
int val = aray[root][i];
if (dist[val] == -1) {
dfs(val, count + 1);
euler.push_back(root);
}
}
return;
}
bool valid(int a, int b) {
if (a > b) return false;
if (((a - b) % 2) == 0) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int t = n - 1, x, y;
while (t--) {
cin >> x >> y;
aray[x].push_back(y);
aray[y].push_back(x);
}
for (int i = 1; i <= n; i++) dist[i] = -1;
dfs(1, 0);
int first[n + 1];
for (int i = euler.size() - 1; i >= 0; i--) first[euler[i]] = i;
int m = euler.size();
int s = sqrt(m);
int box = ceil((double)m / s);
int num[box];
for (int i = 0; i < box; i++) {
num[i] = 1000000000;
for (int j = i * s; j < min(m, (i + 1) * s); j++)
num[i] = min(num[i], dist[euler[j]]);
}
int q;
cin >> q;
while (q--) {
int arr[4], k;
for (int i = 0; i < 4; i++) cin >> arr[i];
cin >> k;
int count = 0;
bool ans = false;
vector<int> dia;
for (int i = 0; i < 2; i++) {
for (int j = 2; j < 4; j++) {
int fir = first[arr[i]], sec = first[arr[j]];
int temp = min(fir, sec), tmep = max(fir, sec);
fir = temp;
sec = tmep;
int bfir = fir / s, bsec = sec / s;
int val = 100000000;
if (bfir == bsec) {
for (int i = fir; i <= sec; i++) val = min(val, dist[euler[i]]);
} else {
for (int i = bfir + 1; i < bsec; i++) val = min(val, num[i]);
for (int i = fir; i < bfir * s + s; i++)
val = min(val, dist[euler[i]]);
for (int i = s * bsec; i <= sec; i++) val = min(val, dist[euler[i]]);
}
int distance = dist[arr[i]] + dist[arr[j]] - 2 * val;
dia.push_back(distance);
}
}
if (valid(dia[0] + dia[3] + 1, k)) ans = true;
if (valid(dia[1] + dia[2] + 1, k)) ans = true;
int fir = first[arr[2]], sec = first[arr[3]];
int temp = min(fir, sec), tmep = max(fir, sec);
fir = temp;
sec = tmep;
int bfir = fir / s, bsec = sec / s;
int val = 10000000;
if (bfir == bsec) {
for (int i = fir; i <= sec; i++) val = min(val, dist[euler[i]]);
} else {
for (int i = bfir + 1; i < bsec; i++) val = min(val, num[i]);
for (int i = fir; i < bfir * s + s; i++) val = min(val, dist[euler[i]]);
for (int i = s * bsec; i <= sec; i++) val = min(val, dist[euler[i]]);
}
int distance = dist[arr[2]] + dist[arr[3]] - 2 * val;
if (valid(distance, k)) ans = true;
if ((distance <= k) && ((distance - k) % 2) == 0) ans = true;
if (ans)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long N = 1e6 + 5;
const long long logN = 22;
vector<long long> adj[N];
long long par[N][logN], lvl[N];
void dfs(long long f, long long p) {
lvl[f] = lvl[p] + 1;
par[f][0] = p;
for (long long i = 1; i < logN; i++) {
par[f][i] = par[par[f][i - 1]][i - 1];
}
for (auto z : adj[f])
if (z - p) dfs(z, f);
}
long long lca(long long u, long long v) {
if (lvl[v] < lvl[u]) swap(u, v);
for (long long i = logN - 1; i >= 0; i--) {
if (lvl[par[v][i]] >= lvl[u]) v = par[v][i];
}
if (v == u) return v;
for (long long i = logN - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) v = par[v][i], u = par[u][i];
}
return par[v][0];
}
long long dist(long long u, long long v) {
long long l = lca(u, v);
return -2 * lvl[l] + lvl[u] + lvl[v];
}
long long gcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
bool find_any_solution(long long a, long long b, long long c, long long& x0,
long long& y0, long long& g) {
g = gcd(abs(a), abs(b), x0, y0);
if (c % g) {
return false;
}
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
const long long inf = 1e13;
bool poss(long long al, long long c, long long k) {
long long x0, y0, g;
bool go = find_any_solution(2, c, k - al, x0, y0, g);
if (!go) return 0;
long long a, b;
a = 2;
b = c;
assert(x0 * a + y0 * b == k - al);
a = 2 / g;
b = c / g;
if (x0 >= 0 && y0 >= 0) return 1;
if (x0 < 0 && y0 < 0) return 0;
if (x0 < 0) {
long long i = (-x0 + b - 1) / b;
x0 += i * b;
y0 -= i * a;
if (x0 >= 0 && y0 >= 0) return 1;
return 0;
}
swap(x0, y0);
swap(a, b);
if (x0 < 0) {
long long i = (-x0 + b - 1) / b;
x0 += i * b;
y0 -= i * a;
if (x0 >= 0 && y0 >= 0) return 1;
return 0;
}
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(25);
long long n, q, a, b, c;
cin >> n;
for (long long i = 1; i < n; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
lvl[1] = -1;
dfs(1, 1);
cin >> q;
while (q--) {
long long x, y, k;
cin >> x >> y >> a >> b >> k;
long long al1 = dist(a, b);
long long al2 = dist(a, x) + 1 + dist(y, b);
long long al3 = dist(a, y) + 1 + dist(x, b);
al3 = min(al3, al2);
if (al1 <= k && al1 % 2 == k % 2)
cout << "YES\n";
else if (al3 <= k && al3 % 2 == k % 2)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long power(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1) {
return a;
} else if (b & 1) {
return (a % mod * power((a % mod * a % mod) % mod, b / 2) % mod) % mod;
} else {
return power((a % mod * a % mod) % mod, b / 2) % mod;
}
}
const int maxn = 100010;
vector<int> dp(maxn), adj[maxn], vis(maxn), first(maxn), segtree, euler;
int n, a, b, qu, x, y, k;
void dfs(int i, int h) {
vis[i] = 1;
dp[i] = h;
first[i] = euler.size();
euler.push_back(i);
for (int j : adj[i]) {
if (!vis[j]) {
dfs(j, h + 1);
euler.push_back(i);
}
}
}
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] = (dp[l] < dp[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 dp[left] < dp[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, (int)euler.size() - 1, left, right);
}
void solve() {
cin >> n;
for (long long i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, 1);
euler.push_back(1);
int m = euler.size();
segtree.resize(4 * m + 10);
build(1, 0, m - 1);
cin >> qu;
while (qu--) {
cin >> x >> y >> a >> b >> k;
int t1 = lca(a, b);
int without = abs(dp[a] + dp[b] - 2 * dp[t1]);
int t2 = lca(a, x), t3 = lca(a, y), t4 = lca(b, x), t5 = lca(b, y);
int with =
min(abs(dp[a] + dp[x] - 2 * dp[t2]) + abs(dp[y] + dp[b] - 2 * dp[t5]),
abs(dp[a] + dp[y] - 2 * dp[t3]) + abs(dp[x] + dp[b] - 2 * dp[t4])) +
1;
int ans = INT_MAX;
bool isok = 0;
if (without % 2 == k % 2) {
ans = without;
if (ans <= k) {
isok = 1;
cout << "YES" << endl;
}
}
if (with % 2 == k % 2) {
ans = with;
if (!isok && ans <= k) {
isok = 1;
cout << "YES" << endl;
}
}
if (!isok) {
cout << "NO" << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
int n, q;
int d[100005], lg[100005], f[100005][25];
std::vector<int> v[100005];
void dfs(int x, int fa) {
f[x][0] = fa;
d[x] = d[fa] + 1;
for (int i = 1; i <= lg[d[x]]; ++i) f[x][i] = f[f[x][i - 1]][i - 1];
for (int i : v[x])
if (i != fa) dfs(i, x);
}
inline int lca(int x, int y) {
if (d[x] < d[y]) std::swap(x, y);
while (d[x] > d[y]) x = f[x][lg[d[x] - d[y]]];
if (x == y) return x;
for (int i = lg[d[x]]; ~i; --i)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
inline int dis(int x, int y) { return d[x] + d[y] - (d[lca(x, y)] << 1); }
int main() {
scanf("%d", &n);
for (int i = 1, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
dfs(1, 0);
scanf("%d", &q);
for (int i = 0, x, y, a, b, k, Dis; i < q; ++i) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
Dis = dis(a, b);
if (Dis <= k && (Dis & 1) == (k & 1)) {
puts("YES");
continue;
}
Dis = dis(a, x) + dis(b, y) + 1;
if (Dis <= k && (Dis & 1) == (k & 1)) {
puts("YES");
continue;
}
Dis = dis(a, y) + dis(b, x) + 1;
if (Dis <= k && (Dis & 1) == (k & 1)) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 1e9;
const long long INF = 1e15;
template <typename A0>
void print(A0 a0) {
std::cout << a0 << '\n';
}
template <typename A0, typename... ARGS>
void print(A0 a0, ARGS... rest) {
std::cout << a0 << ' ';
print(rest...);
}
int dx[] = {0, 0, -1, 1}, dy[] = {1, -1, 0, 0};
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
vector<vector<int> > e(n);
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
u--, v--;
e[u].push_back(v);
e[v].push_back(u);
}
vector<int> parent(n), depth(n);
depth[0] = 0;
function<void(int, int)> dfs = [&](int here, int p) {
parent[here] = p;
for (auto next : e[here])
if (next != p) {
depth[next] = depth[here] + 1;
dfs(next, here);
}
};
dfs(0, 0);
vector<vector<int> > sparse;
for (int k = 0; (1 << k) < n; k++) {
if (k == 0) {
sparse.emplace_back((parent).begin(), (parent).end());
continue;
}
vector<int> temp(n);
for (int i = 0; i < (n); ++i) temp[i] = sparse[k - 1][sparse[k - 1][i]];
sparse.emplace_back((temp).begin(), (temp).end());
}
auto dist = [&](int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
int up = depth[v] - depth[u];
for (int k = 0; up >= (1 << k); k++) {
if (up & (1 << k)) v = sparse[k][v];
}
if (u == v) {
return up;
}
int up2 = 0;
for (int k = sparse.size() - 1; k >= 0; k--) {
if (sparse[k][u] != sparse[k][v]) {
u = sparse[k][u];
v = sparse[k][v];
up2 += 2 * (1 << k);
}
}
return up + up2 + 2;
};
int q;
cin >> q;
while (q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--, y--, a--, b--;
int one = dist(a, b);
int two = min(dist(a, x) + dist(y, b) + 1, dist(a, y) + 1 + dist(x, b));
bool yes = 0;
if (k >= one && (k - one) % 2 == 0) yes = 1;
if (k >= two && (k - two) % 2 == 0) yes = 1;
if (yes)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
vector<int> a[N];
int tin[N], tout[N], ti;
const int m = 19;
int p[N][m];
int d[N];
void dfs(int x, int pp) {
tin[x] = ++ti;
d[x] = d[pp] + 1;
p[x][0] = pp;
for (int i = 1; i < m; ++i) p[x][i] = p[p[x][i - 1]][i - 1];
for (int i = 0; i < a[x].size(); ++i) {
int h = a[x][i];
if (h == pp) continue;
dfs(h, x);
}
tout[x] = ti;
}
bool isp(int x, int y) { return (tin[x] <= tin[y] && tout[y] <= tout[x]); }
int lca(int x, int y) {
if (isp(x, y)) return x;
if (isp(y, x)) return y;
for (int i = m - 1; i >= 0; --i) {
if (!isp(p[x][i], y)) x = p[x][i];
}
return p[x][0];
}
int dist(int x, int y) {
int z = lca(x, y);
return d[x] + d[y] - 2 * d[z];
}
bool stg() {
int a, b, x, y, k;
scanf("%d%d%d%d%d", &a, &b, &x, &y, &k);
int kk = k;
kk -= dist(x, y);
if (kk >= 0 && kk % 2 == 0) return true;
kk = k;
kk -= dist(x, a);
kk--;
kk -= dist(b, y);
if (kk >= 0 && kk % 2 == 0) return true;
kk = k;
kk -= dist(x, b);
kk--;
kk -= dist(a, y);
if (kk >= 0 && kk % 2 == 0) return true;
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
dfs(1, 1);
int qq;
scanf("%d", &qq);
while (qq--) {
if (stg())
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 112345;
int n, q, x, y, a, b, k, fa[maxn][20], dep[maxn];
vector<int> G[maxn];
void dfs(int u, int f) {
fa[u][0] = f;
dep[u] = dep[f] + 1;
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v == f) continue;
dfs(v, u);
}
}
inline int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 0; i < 20; ++i)
if ((dep[x] - dep[y]) >> i & 1) x = fa[x][i];
if (x == y) return x;
for (int i = 19; i >= 0; --i)
if (fa[x][i] != fa[y][i]) {
x = fa[x][i];
y = fa[y][i];
}
return fa[x][0];
}
inline int getdis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i < 20; ++i)
for (int j = 1; j <= n; ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int x1 = getdis(a, b);
int x2 = 1 + getdis(a, x) + getdis(b, y);
int x3 = 1 + getdis(a, y) + getdis(b, x);
if (x1 <= k && x1 % 2 == k % 2)
puts("YES");
else if (x2 <= k && x2 % 2 == k % 2)
puts("YES");
else if (x3 <= k && x3 % 2 == k % 2)
puts("YES");
else
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
int pa[200005][20];
vector<int> g[200005];
int sz[200005];
int dep[200005];
void dfs(int now, int pre) {
pa[now][0] = pre;
for (auto i : g[now]) {
if (i == pre) {
continue;
}
dep[i] = dep[now] + 1;
dfs(i, now);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) {
swap(x, y);
}
int left = dep[x] - dep[y];
for (int i = 19; i >= 0; i--) {
if (left >= (1 << i)) {
x = pa[x][i];
left -= (1 << i);
}
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (pa[x][i] != pa[y][i]) {
x = pa[x][i];
y = pa[y][i];
}
}
return pa[x][0];
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int add1, add2;
cin >> add1 >> add2;
g[add1].push_back(add2);
g[add2].push_back(add1);
}
dfs(1, 1);
for (int i = 1; i < 19 + 1; i++) {
for (int j = 1; j < n + 1; j++) {
pa[j][i] = pa[pa[j][i - 1]][i - 1];
}
}
int t;
cin >> t;
while (t--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (dis(a, b) <= k && (k - dis(a, b)) % 2 == 0) {
cout << "YES\n";
} else if (dis(a, x) + dis(y, b) + 1 <= k &&
(k - dis(a, x) - dis(y, b)) % 2 == 1) {
cout << "YES\n";
} else if (dis(a, y) + dis(x, b) + 1 <= k &&
(k - dis(a, y) - dis(x, b)) % 2 == 1) {
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);
}
array<vector<int>, maxl> step;
step.fill(vector<int>(n));
vector<int> tin(n), tout(n), depth(n, -1);
int time = 0;
function<void(int, int)> dfs = [&](int v, int p) {
step[0][v] = p;
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);
for (int l = 0; l < maxl - 1; l++)
for (int v = 0; v < n; v++) step[l + 1][v] = step[l][step[l][v]];
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[i][u], v)) u = step[i][u];
return step[0][u];
};
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";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.