text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
int a[17];
int main() {
int n, k;
scanf("%d%d", &n, &k);
while (n--) {
int tot = 0, x;
for (int i = 0; i < k; ++i) scanf("%d", &x), tot += (x << i);
++a[tot];
}
for (int i = 0; i < 16; ++i)
for (int j = i; j < 16; ++j)
if ((i & j) == 0 && a[i] && a[j]) return 0 * printf("YES\n");
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5 + 15;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n, k;
bool used[MaxN];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
int cur = 0;
for (int j = 0; j < k; ++j) {
int x;
cin >> x;
if (x) cur += (1 << j);
}
if (!cur) {
cout << "YES\n";
return 0;
}
for (int mask = 0; mask < (1 << k); ++mask)
if (used[mask] && !(mask & cur)) {
cout << "YES\n";
return 0;
}
used[cur] = 1;
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int freq[1 << (4)];
int ara[100005];
int main() {
int n, k, x;
while (scanf("%d %d", &n, &k) == 2) {
bool f = 0;
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
if (x) temp |= (1 << (j));
}
freq[temp]++;
f |= !(temp);
ara[i] = temp;
}
for (int i = 0; i < n && !f; i++) {
freq[ara[i]]--;
for (int j = 0; j < (1 << (k)); j++) {
if (!freq[j]) continue;
if (!(ara[i] & j)) f = 1;
}
}
if (f)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5 + 7;
const int inf = 1e9 + 7;
int a[max_n];
int n, k, c;
inline int pow(int a, int b) {
int ans = 1;
for (int i = 1; i <= b; ++i) ans *= a;
return ans;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
int ans = 0;
for (int j = k; j >= 1; --j) {
scanf("%d", &c);
if (c == 1) ans += pow(2, j - 1);
}
a[ans] += 1;
}
for (int i = 0; i <= 15; ++i)
for (int j = 0; j <= 15; ++j)
if ((i & j) == 0 && a[i] && a[j]) {
printf("YES\n");
return 0;
}
printf("NO\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int n, k;
cin >> n >> k;
long long int c[16] = {0};
for (long long int i = 0; i < n; ++i) {
long long int m = 0;
for (long long int j = 0; j < k; ++j) {
long long int val;
cin >> val;
if (val) m = (m | (1 << j));
}
c[m] = 1;
}
for (long long int i = 0; i < 16; ++i) {
for (long long int j = 0; j < 16; ++j) {
if (c[i] && c[j] && (i & j) == 0) {
cout << "YES" << endl;
exit(0);
}
}
}
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int Inf = 1e9 + 1;
const int Mod = 1e9 + 7;
const double eps = 1e-15;
set<string> S;
bool a[N][6];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
string s = "";
for (int j = 1; j <= k; ++j) {
bool a;
cin >> a;
if (a)
s += '1';
else
s += '0';
}
S.insert(s);
}
for (auto it : S) {
for (auto It : S) {
bool ok = 1;
for (int i = 0; i < k; ++i)
if (it[i] == '1' && It[i] == '1') ok = 0;
if (ok) return cout << "YES", 0;
}
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const long long mod = 1000000007;
int vis[1 << 5] = {0};
int main() {
int n, m, x;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
int st = 0;
for (int j = 0; j < m; ++j) {
scanf("%d", &x);
st += x << j;
}
vis[st] = 1;
}
int flag = 0;
m = 1 << m;
for (int i = 0; i < m && !flag; ++i) {
for (int j = 0; j < m && !flag; ++j) {
if (!vis[i] || !vis[j]) {
continue;
}
if (i & j) {
continue;
}
flag = 1;
}
}
puts(flag ? "YES" : "NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T, U> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
inline istream &operator>>(istream &in, vector<T> &v) {
for (T &x : v) in >> x;
return in;
}
void solve(ll &tc) {
ll n, k;
cin >> n >> k;
vector<bool> ok(1ll << k, 0);
for (ll i = 0; i < n; i++) {
ll mask = 0;
for (ll j = 0; j < k; j++) {
ll x;
cin >> x;
if (x) {
mask |= (1ll << (k - 1 - j));
}
}
ok[mask] = 1;
}
for (ll i = 0; i < (1ll << k); i++) {
if (!ok[i]) continue;
for (ll j = 0; j < (1ll << k); j++) {
if (!ok[j]) continue;
for (ll bit = 0; bit < k; bit++) {
if ((i & (1ll << bit)) and (j & (1ll << bit))) {
break;
}
if (bit == k - 1) {
cout << "YES\n";
return;
}
}
}
}
cout << "NO\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll rep = 1;
while (rep--) {
ll tc = 1;
for (ll i = 1; i <= tc; i++) {
if (0) cerr << "Case #" << i << "\n";
solve(i);
}
if (1) break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[20], n, k;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
memset(a, 0, sizeof(a));
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0, y; j < k; j++) {
cin >> y;
x = x << 1 | y;
}
a[x]++;
}
for (int i = 0; i < (1 << k); i++)
for (int j = 0; j <= i; j++)
if (!(i & j) && a[i] && a[j]) return 0 * puts("YES");
return 0 * puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
bool flag[100];
int ans[100], cnt;
int main() {
int n, k, a;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int x = 0;
for (int j = 1; j <= k; j++) {
scanf("%d", &a);
x += (a << (k - j));
}
if (flag[x] != 1) {
ans[++cnt] = x;
flag[x] = 1;
}
}
bool f = 0;
for (int i = 1; i <= cnt; i++)
for (int j = 1; j <= cnt; j++)
if (!(ans[i] & ans[j])) {
puts("YES");
f = 1;
return 0;
}
if (f == 0) puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
vector<int> v[4];
bool g(int i, int j, int k) {
vector<int> a = v[i], b = v[j], c = v[k];
vector<int> d;
set_intersection(b.begin(), b.end(), a.begin(), a.end(), back_inserter(d));
a.clear();
set_intersection(c.begin(), c.end(), d.begin(), d.end(), back_inserter(a));
if (a.size() != 0) return 1;
return 0;
}
bool f(int i, int j) {
vector<int> a = v[i], b = v[j];
vector<int> c;
set_intersection(b.begin(), b.end(), a.begin(), a.end(), back_inserter(c));
if (c.size() != 0) return 1;
return 0;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
int x;
for (int j = 0; j < k; ++j) {
scanf("%d", &x);
if (x == 0) v[j].push_back(i);
}
}
if (k == 1) {
if (v[0].size() != 0) {
cout << "YES" << endl;
return 0;
;
}
cout << "NO" << endl;
return 0;
;
}
vector<int> inter = v[0];
for (int i = 0; i < k; ++i) {
if (v[i].size() == 0) {
cout << "NO" << endl;
return 0;
;
}
vector<int> flag;
set_intersection(inter.begin(), inter.end(), v[i].begin(), v[i].end(),
back_inserter(flag));
inter = flag;
}
if (k == 2 or inter.size() != 0) {
cout << "YES" << endl;
return 0;
;
}
if (k == 3) {
if (f(0, 1)) {
cout << "YES" << endl;
return 0;
;
}
if (f(0, 2)) {
cout << "YES" << endl;
return 0;
;
}
if (f(2, 1)) {
cout << "YES" << endl;
return 0;
;
}
cout << "NO" << endl;
return 0;
;
}
if (f(0, 1) and f(2, 3)) {
cout << "YES" << endl;
return 0;
;
}
if (f(0, 2) and f(3, 1)) {
cout << "YES" << endl;
return 0;
;
}
if (f(0, 3) and f(2, 1)) {
cout << "YES" << endl;
return 0;
;
}
if (g(0, 1, 2)) {
cout << "YES" << endl;
return 0;
;
}
if (g(3, 1, 2)) {
cout << "YES" << endl;
return 0;
;
}
if (g(0, 3, 2)) {
cout << "YES" << endl;
return 0;
;
}
if (g(0, 3, 1)) {
cout << "YES" << endl;
return 0;
;
}
cout << "NO" << endl;
return 0;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int cntr[20] = {0};
int main() {
int n, k;
cin >> n >> k;
int i, j, x;
for (i = 0; i < n; i++) {
int num = 0;
for (j = 0; j < k; j++) {
cin >> x;
num = 2 * num + x;
}
cntr[num]++;
}
if (cntr[0] > 0) {
cout << "YES" << endl;
return 0;
} else if (cntr[1] > 0 &&
(cntr[2] > 0 || cntr[4] > 0 || cntr[6] > 0 || cntr[8] > 0 ||
cntr[10] > 0 || cntr[12] > 0 || cntr[14] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[2] > 0 && (cntr[5] > 0 || cntr[12] > 0 || cntr[13] > 0 ||
cntr[8] > 0 || cntr[4] > 0 || cntr[9] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[3] > 0 && (cntr[4] > 0 || cntr[12] > 0 || cntr[8] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[4] > 0 &&
(cntr[8] > 0 || cntr[9] > 0 || cntr[10] > 0 || cntr[11] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[5] > 0 && (cntr[10] > 0 || cntr[8] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[6] > 0 && (cntr[8] > 0 || cntr[9] > 0)) {
cout << "YES" << endl;
return 0;
} else if (cntr[7] > 0 && cntr[8] > 0) {
cout << "YES" << endl;
return 0;
} else {
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int k;
map<string, long long int> mp;
int main() {
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
string s = "";
for (long long int j = 1; j <= k; j++) {
char c;
cin >> c;
s += c;
}
mp[s]++;
}
for (auto x : mp) {
string s = x.first;
bool f = 1;
for (auto c : s)
if (c == '1') f = 0;
if (f) {
cout << "YES" << endl;
return 0;
}
}
vector<string> pp;
for (auto x : mp) pp.push_back(x.first);
for (long long int i = 0; i < pp.size(); i++) {
for (long long int j = i; j < pp.size(); j++) {
if (i == j) continue;
bitset<4> foo(pp[i]);
bitset<4> goo(pp[j]);
bitset<4> res = foo & goo;
if (res.to_ulong() == 0) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = (int)(1e9 + 1e6);
const long long LINF = (long long)(4e18);
const double EPS = 1e-9;
mt19937 ggen;
const int MOD = 1000000007;
int add(int a, int b, int m = MOD) {
int res = a + b;
if (res >= m) res -= m;
return res;
}
int sub(int a, int b, int m = MOD) {
int res = a - b;
if (res < 0) res += m;
return res;
}
int mul(int a, int b, int m = MOD) { return (long long)a * b % m; }
const int MAXN = 105000;
int k, n;
int mas[MAXN];
int full;
int c[MAXN];
void init() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < k; ++j) {
int q;
scanf("%d", &q);
mas[i] <<= 1;
mas[i] |= q;
}
}
}
bool check_mask(int mask) {
int cnt[4] = {0, 0, 0, 0};
int pr = 0;
for (int i = 0; i < (1 << k); ++i) {
if (mask & (1 << i)) {
if (!c[i]) {
return false;
}
++pr;
for (int j = 0; j < k; ++j) {
if (i & (1 << j)) {
++cnt[j];
}
}
}
}
for (int i = 0; i < k; ++i) {
if (cnt[i] * 2 > pr) {
return false;
}
}
return true;
}
void solve() {
init();
full = (1 << k) - 1;
for (int i = 1; i <= n; ++i) {
++c[mas[i]];
}
for (int mask = 1; mask <= (1 << full); ++mask) {
if (check_mask(mask)) {
printf("YES\n");
return;
}
}
printf("NO\n");
}
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
ggen = mt19937(1337);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const double eps = 1e-10;
const int MAXN = 1e7 + 6;
const int MOD = 1e9 + 7;
bool ODD(int O) { return (O % 2 != 0); }
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int n, k;
vector<int> vec[20], vc[100200], ans[20];
int c_bm = 0;
vector<int> com;
bool vis[17];
void bitms(int i = 0) {
if (i == k) {
for (int j = 0; j < int(com.size()); j++) vec[c_bm].push_back(com[j]);
++c_bm;
return;
}
com.push_back(1);
bitms(i + 1);
com.pop_back();
com.push_back(0);
bitms(i + 1);
com.pop_back();
}
int chke(vector<int> a) {
for (int i = 0; i < int((pow(2, k))); i++) {
bool f = true;
for (int j = 0; j < int(vec[i].size()); j++) {
if (vec[i][j] != a[j]) {
f = false;
}
}
if (f && !vis[i]) {
vis[i] = 1;
return i;
}
}
return -1;
}
int main() {
cin >> n >> k;
int cnt = 0;
bitms();
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(k); j++) {
int x;
cin >> x;
vc[i].push_back(x);
}
if (~chke(vc[i])) {
for (int j = 0; j < int(k); j++) {
ans[cnt].push_back(vc[i][j]);
}
++cnt;
}
}
for (int i = 0; i < int(cnt); i++) {
for (int j = i; j < cnt; j++) {
bool f = true;
for (int l = 0; l < int(k); l++) {
if (ans[i][l] + ans[j][l] > 1) f = false;
}
if (f) {
puts("YES");
return 0;
}
}
}
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
int n, k;
int vis[(1 << 4) + 5];
int main() {
int x;
while (~scanf("%d%d", &n, &k)) {
memset((vis), (0), sizeof(vis));
for (int i = 1; i <= n; i++) {
int state = 0;
for (int j = 1; j <= k; j++) {
scanf("%d", &x);
state += (1 << (j - 1)) * x;
}
vis[state] = 1;
}
int flag = 0;
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
if (vis[i] == 0 || vis[j] == 0) continue;
if ((i & j) == 0) {
flag = 1;
break;
}
}
if (flag) break;
}
if (flag)
puts("YES");
else
puts("NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, cnt, b[20];
bool vis[20];
int main() {
cin >> N >> K;
for (int i = 1; i <= N; i++) {
int x = 0, a;
for (int j = 1; j <= K; j++) {
scanf("%d", &a);
x = x * 2 + a;
}
if (!vis[x]) b[++cnt] = x;
vis[x] = 1;
}
if (vis[0]) {
printf("YES");
return 0;
}
for (int i = 1; i <= cnt; i++)
for (int j = i + 1; j <= cnt; j++) {
if (b[i] & b[j]) continue;
printf("YES");
return 0;
}
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
const int inf = INT_MAX;
const int MAX = 1e3 + 8;
const long long MOD = 1e9 + 7;
const int TOT_PRIMES = 1e6 + 9;
const int MAX_A = 71;
const int LN = 20;
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[32];
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
int res = 0;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
res = x + res * 2;
}
a[res] = 1;
}
int f = 0;
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if ((!(i & j)) && a[i] && a[j]) f = 1;
}
}
if (f)
cout << "YES";
else
cout << "NO";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[17], num, hold;
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
num = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &hold);
if (hold) num = num | (1 << j);
}
a[num] = 1;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = 0; j < (1 << k); j++) {
if ((!(i & j)) && a[i] && a[j]) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long powM(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = powM(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s[100];
set<string> set;
for (long long i = 0; i <= n - 1; i++) {
char a[k];
for (long long j = 0; j <= k - 1; j++) {
cin >> a[j];
}
string str;
for (long long j = 0; j <= k - 1; j++) str += a[j];
if (!set.count(str)) {
set.insert(str);
}
}
int flag = 0;
for (auto u : set) {
for (auto v : set) {
for (long long i = 0; i <= k - 1; i++) {
if (u[i] == '1' && v[i] == '1') {
break;
}
if (i == k - 1 && !(u[i] == '1' && v[i] == '1')) {
flag = 1;
break;
}
}
if (flag == 1) break;
}
if (flag == 1) break;
}
if (flag == 1)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, k;
int a[maxn];
bool ok[20];
void ReadInput() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
a[i] = 0;
int x;
for (int j = 0; j < k; ++j) {
cin >> x;
a[i] += (x << j);
}
}
}
void Solve() {
for (int i = 0; i < n; ++i)
if (a[i] == 0) {
cout << "YES\n";
return;
}
fill(begin(ok), end(ok), false);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (1 << k); ++j) {
if (!ok[j]) continue;
bool flag = true;
for (int p = 0; p < k; ++p)
if ((a[i] >> p & 1) + (j >> p & 1) == 2) flag = false;
if (flag) {
cout << "YES\n";
return;
}
}
ok[a[i]] = true;
}
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ReadInput();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(k);
set<vector<long long> > s;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < k; j++) cin >> a[j];
s.insert(a);
}
if (s.size() == 1) {
auto t = *s.begin();
bool flag = true;
for (long long i = 0; i < k; i++) {
if (t[i]) flag = false;
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
for (auto t : s) {
for (auto p : s) {
if (t != p) {
bool flag = true;
for (long long i = 0; i < k; i++) {
if (t[i] && p[i]) flag = false;
}
if (flag) {
cout << "YES" << endl;
return 0;
}
}
}
}
cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool vis[16];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1, y; i <= n; i++) {
y = 0;
for (int j = 1, x; j <= k; j++) {
scanf("%d", &x);
y = (y << 1) + x;
}
vis[y] = 1;
}
for (int i = 0; i <= 15; i++)
for (int j = 0; j <= 15; j++)
if (vis[i] && vis[j] && (i & j) == 0) {
printf("yes");
return 0;
}
printf("no");
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 1000000;
const long long mod = 1e9 + 7;
using namespace std;
int a[20];
vector<int> b;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool rin(T &res) {
res = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
res = (res << 1) + (res << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
res *= f;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
rin(n);
rin(k);
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < k; j++) {
sum *= 2;
int t;
rin(t);
sum += t;
}
a[sum]++;
}
for (int i = 0; i <= (1 << k); i++)
if (a[i]) b.push_back(i);
if (b[0] == 0) {
cout << "YES"
<< "\n";
return 0;
}
for (int i = 0; i < b.size() - 1; i++) {
for (int j = i + 1; j < b.size(); j++) {
int t = b[i] & b[j];
if (!t) {
cout << "YES"
<< "\n";
return 0;
}
}
}
cout << "NO"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Ha[30];
int N, K;
int main() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) {
int s = 0;
for (int j = 1; j <= K; j++) {
int x;
scanf("%d", &x);
s = (s << 1) + x;
}
Ha[s]++;
}
for (int s = 1; s < (1 << (1 << K)); s++) {
int sum[4] = {0}, cnt = 0;
bool can = true;
for (int i = 0; i < (1 << K); i++) {
if ((s >> i) & 1) {
cnt++;
if (!Ha[i]) can = false;
for (int t = 0; t < 4; t++) sum[t] += (i >> t) & 1;
}
}
if (!can) continue;
bool ok = true;
for (int i = 0; i < 4; i++) {
if (sum[i] <= cnt / 2)
;
else
ok = false;
}
if (ok) return puts("YES"), 0;
}
puts("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(vector<long long> v) {
long long n = v.size();
for (long long i = 0; i < n; i++) cout << v[i] << " ";
cout << '\n';
}
long long power(long long a, long long b) {
long long res = 1;
while (b != 0) {
if (b & 1) res *= a;
a = a * a;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, k;
cin >> n >> k;
vector<long long> v;
map<long long, long long> mp1;
for (long long i = 0; i < n; i++) {
long long x = 0;
for (long long j = 0; j < k; j++) {
long long y;
cin >> y;
x += y * power(2, j);
}
v.push_back(x);
mp1[x]++;
}
map<long long, vector<long long> > mp;
for (long long i = 0; i < 16; i++) {
for (long long j = 0; j < 16; j++) {
if ((i & j) == 0) {
mp[i].push_back(j);
}
}
}
long long f = 0;
for (long long i = 0; i < n; i++) {
vector<long long> v1 = mp[v[i]];
long long n1 = v1.size();
for (long long j = 0; j < n1; j++) {
if (mp1[v1[j]] != 0) {
f = 1;
break;
}
}
if (f) break;
}
if (f) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 0x3f3f3f3f3f3f3f3fll;
double hp[40005];
long long int n, m, k, q;
long long int mx;
vector<int> row[40005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<bool> number(16, false);
int limit = pow(2, k) - 1;
for (int i = 0; i < n; i++) {
m = 1;
int val = 0;
for (int j = 0; j < k; j++) {
int a;
cin >> a;
val += m * a;
m *= 2;
}
number[val] = true;
}
m = 0;
for (int i = 1; i < limit; i++) {
for (int j = 1; j < limit; j++) {
if ((i & j) == 0 && number[i] && number[j]) {
m = 1;
break;
}
}
if (m == 1) break;
}
if (m == 1 || number[0]) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXB = 1e7;
char buf[MAXB], *cp = buf;
inline void rd(int &x) {
x = 0;
int f = 1;
while (*cp < '0' || '9' < *cp) {
if (*cp == '-') f = -1;
cp++;
}
while ('0' <= *cp && *cp <= '9') x = (x << 3) + (x << 1) + *cp - 48, cp++;
x *= f;
}
int n, k;
int cnt[1 << 5];
int main() {
fread(buf, 1, MAXB, stdin);
rd(n);
rd(k);
while (n--) {
int t = 0;
for (int i = 0; i < k; i++) {
int x;
rd(x);
t += x * (1 << i);
}
cnt[t]++;
if (!t) {
return puts("YES"), 0;
}
}
for (int i = 0; i < (1 << k); i++)
for (int j = 0; j < (1 << k); j++)
if (cnt[i] && cnt[j] && ((i & j) == 0)) return puts("YES"), 0;
return puts("NO"), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k;
int a[N];
bool vis[1000];
int b[10];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) scanf("%d", &b[j]);
a[i] = b[1] * 1 + b[2] * 2 + b[3] * 4 + b[4] * 8;
vis[a[i]] = 1;
}
int flag = 0;
for (int i = 0; i <= 15; i++) {
for (int j = 0; j <= 15; j++) {
if (!(i & j) && vis[i] && vis[j]) {
flag = 1;
break;
}
}
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
bool chk(int k, bool* v) {
if (*v) return 1;
for (int u = (1 << k) - 1, s = u; s; s--)
if (v[s])
for (int t = u - s; t; t = (t - 1) & (u - s))
if (v[t]) return 1;
return 0;
}
int main() {
int n, k;
bool v[16] = {0};
scanf("%d%d", &n, &k);
while (n--) {
int x, s = 0;
for (int i = 0; i < k; i++) scanf("%d", &x), s |= x << i;
v[s] = 1;
}
puts(chk(k, v) ? "YES" : "NO");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool d[1 << 10];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int tmp = 0;
for (int j = 1; j <= k; j++) {
int t;
scanf("%d", &t);
tmp = (tmp << 1) + t;
}
d[tmp] = true;
}
for (int i = 0; i <= 16; i++)
for (int j = 0; j <= 16; j++) {
if (d[i] && d[j] && (i & j) == 0) {
printf("YES");
return 0;
}
}
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < m; j++) {
int y;
cin >> y;
x = x * 2 + y;
}
a.push_back(x);
};
for (int state = 0; state < (1 << m); state++) {
int p = -1;
for (int j = 0; j < n; j++) {
if (a[j] == state) {
p = j;
break;
}
}
if (p == -1) continue;
if (state == 0) {
cout << "YES" << '\n';
return;
}
for (int j = 0; j < n; j++) {
if (j != p && (a[j] & state) == 0) {
;
cout << "YES" << '\n';
return;
}
}
}
cout << "NO" << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using vc = vector<T>;
template <typename T, typename X>
using pr = pair<T, X>;
const long long int MOD = 1e9 + 7;
const long double PI = 3.14159265;
long long int powerWithMod(long long int base, long long int exponent,
long long int modulus = LLONG_MAX) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent >>= 1;
base = (base * base) % modulus;
}
return result;
}
long long int modInverse(long long int a, long long int m = MOD) {
return powerWithMod(a, m - 2, m);
}
int n, k, x, y;
map<int, int> a;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
x = 0;
for (int i = 0; i < k; i++) {
cin >> y;
x <<= 1;
x += y;
}
a[x]++;
}
if (a[0] > 0) {
cout << "YES\n";
return 0;
}
for (int i = 0; i < k; i++) {
if (a[1 << i] == 0) continue;
for (int j = 1; j < (1 << k); j++) {
if (j & (1 << i)) continue;
if (a[j]) {
cout << "YES\n";
return 0;
}
}
}
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
if (a[(1 << i) + (1 << j)] == 0) continue;
for (int l = 1; l < (1 << k); l++) {
if (l & ((1 << i) + (1 << j))) continue;
if (a[l]) {
cout << "YES\n";
return 0;
}
}
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<vector<int>> st;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
vector<int> v;
int x;
for (int j = 1; j <= k; j++) {
cin >> x;
v.push_back(x);
}
st.insert(v);
}
vector<vector<int>> vec(st.begin(), st.end());
n = st.size();
for (int mask = 1; mask < (1 << n); mask++) {
vector<int> sum(k);
for (int j = 0; j < n; j++) {
if (!(mask & (1 << j))) continue;
vector<int> v = vec[j];
for (int x = 0; x < k; x++) sum[x] += v[x];
}
int sz = __builtin_popcount(mask);
bool ok = 1;
for (int i = 0; i < k; i++) {
if (sum[i] <= sz / 2)
;
else
ok = 0;
}
if (ok) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
}
|
#include <bits/stdc++.h>
const int P = 29;
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k, cnt;
int a[20];
int main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) {
int x = 0, base = 1;
for (int j = 1; j <= k; j++) {
int p = read();
x = x * base + p;
base *= 2;
}
bool flag = 0;
for (int j = 1; j <= cnt; j++)
if (a[j] == x) flag = 1;
if (!flag) a[++cnt] = x;
}
for (int i = 1; i <= cnt; i++)
for (int j = 1; j <= cnt; j++)
if ((a[i] & a[j]) == 0) {
cout << "YES" << endl;
return 0;
}
cout << "NO";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, k, cnt[20], x;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int s = 0;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
s = s * 2 + x;
}
cnt[s]++;
}
for (int i = 0; i < (1 << k); i++)
for (int j = 0; j < (1 << k); j++)
if (cnt[i] > 0 && cnt[j] > 0 && ((i & j) == 0)) {
puts("YES");
return 0;
}
puts("NO");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
int n, k;
bool vis[maxn];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int res = 0;
for (int j = 1; j <= k; j++) {
int x;
scanf("%d", &x), res = res << 1 | x;
}
vis[res] = 1;
}
for (int i = 0; i <= 15; i++)
for (int j = 0; j <= 15; j++)
if (vis[i] && vis[j] && (i & j) == 0) return printf("YES"), 0;
printf("NO");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MX = 100001;
vector<long long> check(MX, 1), divisor(MX, 2);
void prime() {
long long i, j;
for (i = 3; i < MX; i += 2) {
if (check[i]) {
divisor[i] = i;
for (j = i * i; j < MX; j += 2 * i) divisor[j] = i, check[j] = 0;
}
}
}
long long task(long long case_no) {
long long n, k;
cin >> n >> k;
vector<string> s;
while (n--) {
long long tmp;
string t;
for (long long i = 0; i < k; ++i) cin >> tmp, t += 48 + tmp;
s.push_back(t);
}
long long mask = 1 << k;
long long i;
for (i = 0; i < mask; ++i) {
map<long long, long long> pos;
long long y = i, j;
for (j = 0; j < k; ++j) {
if ((1 << j) & i) pos[j] = 1;
}
long long p;
for (j = 0; j < s.size(); ++j) {
for (p = 0; p < k; ++p) {
if (pos[p] && s[j][p] == '1')
continue;
else if (!pos[p] && s[j][p] == '0')
continue;
else
break;
}
if (p == k) break;
}
if (j != s.size()) {
for (j = 0; j < s.size(); ++j) {
for (p = 0; p < k; ++p) {
if (pos[p] && s[j][p] == '1') break;
}
if (p == k) break;
}
if (j != s.size()) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
int main() {
int t = 1, i = 0;
while (t--) {
task(++i);
}
return 0;
}
|
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long int chec(long long int a, long long int b) {
char t[10], t1[10];
long long int s = 0, s1 = 0;
while (a != 0) {
t[s++] = a % 2 + '0';
a /= 2;
}
t[s] = '\0';
while (b != 0) {
t1[s1++] = b % 2 + '0';
b /= 2;
}
t1[s1] = '\0';
long long int k = min(s, s1);
for (long long int i = 0; i < k; i++) {
if (t[i] == '1' && t1[i] == '1') return -1;
}
return 1;
}
int main() {
long long int i, j, n, k, s, x;
while (cin >> n >> k) {
vector<long long int> v;
map<long long int, long long int> mp;
for (i = 1; i <= n; i++) {
s = 0;
for (j = 1; j <= k; j++) {
cin >> x;
s = s + (x << (j - 1));
}
if (mp[s] == 0) v.push_back(s);
mp[s] = 1;
}
bool f = 0;
sort(v.begin(), v.end());
if (v[0] == 0) f = 1;
for (i = 0; i < v.size(); i++) {
for (j = 0; j < v.size(); j++) {
if (chec(v[i], v[j]) == 1) {
f = 1;
}
}
}
if (f == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
bool *tasks;
cin >> n >> k;
tasks = new bool[1 << k]{false};
int tmp1, tmp2;
for (int i = 0; i < n; i++) {
tmp2 = 0;
for (int j = 0; j < k; j++) {
cin >> tmp1;
tmp2 += (1 << j) * tmp1;
}
tasks[tmp2] = true;
}
if (tasks[0]) {
cout << "YES" << endl;
return 0;
}
for (int i = 0; i < (1 << k); i++) {
for (int j = i + 1; j < (1 << k); j++) {
if (tasks[i] && tasks[j] && ((i | j) == (i + j))) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct stree {
int n;
vector<vector<int> > t, d;
vector<int> L, R;
stree(){};
stree(vector<int> a, vector<int> b) {
n = 1;
while (n < a.size()) n *= 2;
t.resize(n + n);
d.resize(n + n);
L.resize(n + n);
R.resize(n + n);
for (int i = 0; i < n; ++i) {
t[i + n].push_back(i < a.size() ? a[i] : 0);
d[i + n].push_back(i < a.size() ? b[i] : 0);
L[i + n] = R[i + n] = i;
}
for (int i = n - 1; i > 0; --i) {
L[i] = L[i + i];
R[i] = R[i + i + 1];
int p, q, k;
p = q = 0;
k = t[i + i].size();
bool fl;
while (p < k || q < k) {
if (p == k)
fl = true;
else if (q == k)
fl = false;
else
fl = (d[i + i + 1][q] < d[i + i][p]);
if (fl) {
t[i].push_back(t[i + i + 1][q]);
d[i].push_back(d[i + i + 1][q++]);
} else {
t[i].push_back(t[i + i][p]);
d[i].push_back(d[i + i][p++]);
}
}
for (int j = 1; j < t[i].size(); ++j) t[i][j] = min(t[i][j], t[i][j - 1]);
}
}
long long num(int v, int l, int r, int dep) {
if (L[v] > r || l > R[v]) return 1e9 + 5;
if (L[v] == l && R[v] == r) {
int j = upper_bound(d[v].begin(), d[v].end(), dep) - d[v].begin();
return (j ? t[v][j - 1] : 1e9 + 5);
} else {
int tm = (L[v] + R[v]) / 2;
return min(num(v + v, l, min(r, tm), dep),
num(v + v + 1, max(l, tm + 1), r, dep));
}
}
};
int n, r, x, y, k, q, last;
vector<vector<int> > g;
vector<int> a, aa, bb, u, in, ou, de;
void dfs(int v, int dep) {
u[v] = 1;
aa.push_back(a[v]);
bb.push_back(dep);
de[v] = dep;
in[v] = aa.size() - 1;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!u[to]) dfs(to, dep + 1);
}
ou[v] = aa.size() - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> r;
--r;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
g.resize(n);
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
de.resize(n);
in.resize(n);
ou.resize(n);
u.assign(n, 0);
dfs(r, 0);
stree t(aa, bb);
last = 0;
cin >> q;
while (q--) {
cin >> x >> k;
x = (x + last) % n;
k = (k + last) % n;
last = t.num(1, in[x], ou[x], de[x] + k);
cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
long long qpow(long long a, long long b) {
long long res = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) res = res * a % mod;
return res;
}
const int inf = 0x3f3f3f3f;
const int maxn = 3e5 + 50;
vector<int> to[maxn];
int a[maxn], dep[maxn], l[maxn], r[maxn], id[maxn], cc;
void dfs(int pos, int fa) {
l[pos] = ++cc;
id[cc] = pos;
for (int v : to[pos])
if (v != fa) {
dep[v] = dep[pos] + 1;
dfs(v, pos);
}
r[pos] = cc;
}
vector<pair<int, int> > has[maxn << 2];
void build(int rt, int l, int r) {
has[rt].resize(r - l + 1);
for (int i = l; i <= r; ++i) {
has[rt][i - l] = pair<int, int>(dep[id[i]], a[id[i]]);
}
sort(has[rt].begin(), has[rt].end());
for (int i = 1; i < has[rt].size(); ++i)
has[rt][i].second = min(has[rt][i].second, has[rt][i - 1].second);
if (l != r) {
int mid = (l + r) >> 1;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
}
}
int query(int rt, int l, int r, int L, int R, int d) {
if (L <= l and r <= R) {
if (has[rt][0].first > d) return inf;
int pos =
lower_bound(has[rt].begin(), has[rt].end(), pair<int, int>(d + 1, -1)) -
has[rt].begin() - 1;
return has[rt][pos].second;
} else {
int mid = (l + r) >> 1;
int res = inf;
if (L <= mid) res = min(res, query((rt << 1), l, mid, L, R, d));
if (R > mid) res = min(res, query((rt << 1 | 1), mid + 1, r, L, R, d));
return res;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, rt;
cin >> n >> rt;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
to[u].push_back(v);
to[v].push_back(u);
}
dep[rt] = 1;
dfs(rt, 0);
build(1, 1, n);
int q;
cin >> q;
int la = 0;
while (q--) {
int x, k;
cin >> x >> k;
x = (x + la) % n + 1, k = (k + la) % n;
la = query(1, 1, n, l[x], r[x], dep[x] + k);
cout << la << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
vector<pair<int, int>> v, st[4 * N];
int in[N], out[N], val[N], dep[N];
vector<int> adj[N];
void dfs(int u, int p, int d) {
dep[u] = d;
in[u] = v.size();
v.emplace_back(dep[u], val[u]);
for (int c : adj[u]) {
if (c == p) continue;
dfs(c, u, d + 1);
}
out[u] = v.size() - 1;
}
void build(int p, int l, int r) {
if (l == r) {
st[p] = {v[l]};
} else {
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
merge(st[p * 2].begin(), st[p * 2].end(), st[p * 2 + 1].begin(),
st[p * 2 + 1].end(), back_inserter(st[p]));
for (int i = 1; i < st[p].size(); ++i)
st[p][i].second = min(st[p][i].second, st[p][i - 1].second);
}
}
int query(int p, int l, int r, int i, int j, int mxDep) {
if (r < i || l > j || i > j) return 2e9;
if (l >= i && r <= j) {
auto it =
upper_bound((st[p]).begin(), (st[p]).end(), make_pair(mxDep, (int)2e9));
if (it == st[p].begin()) return 2e9;
return (--it)->second;
}
int mid = (l + r) / 2;
int p1 = query(p * 2, l, mid, i, j, mxDep);
int p2 = query(p * 2 + 1, mid + 1, r, i, j, mxDep);
return min(p1, p2);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 1; i < n; ++i) {
int u, c;
cin >> u >> c;
adj[u].push_back(c);
adj[c].push_back(u);
}
dfs(r, -1, 0);
build(1, 0, n - 1);
int q, last = 0;
cin >> q;
while (q--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(1, 0, n - 1, in[x], out[x], dep[x] + k);
cout << last << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int inf = 0x3f3f3f3f;
struct node {
int val;
int ch[2];
} dat[maxn << 6];
int a[maxn];
vector<int> g[maxn];
int dep[maxn], rt[maxn];
int sz = 0;
int n, r;
void pushup(int rt) {
dat[rt].val = min(dat[dat[rt].ch[0]].val, dat[dat[rt].ch[1]].val);
}
void update(int d, int val, int l, int r, int &rt) {
rt = ++sz;
dat[rt].ch[0] = dat[rt].ch[1] = 0;
dat[rt].val = inf;
if (l == r) {
dat[rt].val = val;
return;
}
int mid = (l + r) >> 1;
if (d <= mid) {
update(d, val, l, mid, dat[rt].ch[0]);
} else {
update(d, val, mid + 1, r, dat[rt].ch[1]);
}
pushup(rt);
}
int merge(int x, int y) {
if (x == 0) {
return y;
}
if (y == 0) {
return x;
}
int res = ++sz;
dat[res].ch[0] = merge(dat[x].ch[0], dat[y].ch[0]);
dat[res].ch[1] = merge(dat[x].ch[1], dat[y].ch[1]);
dat[res].val = min(dat[x].val, dat[y].val);
return res;
}
void dfs(int u, int p, int d) {
dep[u] = d;
update(dep[u], a[u], 1, n, rt[u]);
for (size_t i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == p) {
continue;
}
dfs(v, u, d + 1);
rt[u] = merge(rt[u], rt[v]);
}
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return dat[rt].val;
}
int mid = (l + r) >> 1;
int res = inf;
if (L <= mid) {
res = min(res, query(L, R, l, mid, dat[rt].ch[0]));
}
if (R > mid) {
res = min(res, query(L, R, mid + 1, r, dat[rt].ch[1]));
}
return res;
}
int main(void) {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dat[0].val = inf;
dat[0].ch[0] = dat[0].ch[1] = 0;
dfs(r, r, 1);
int m;
scanf("%d", &m);
int last = 0;
while (m--) {
int p, q;
scanf("%d%d", &p, &q);
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(dep[x], dep[x] + k, 1, n, rt[x]);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void _F(const char *name, T arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
const char *name = strchr(names, ',');
cerr.write(names, name - names) << " = " << arg1 << '\n';
_F(name + 2, args...);
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
in >> q.first >> q.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
out << q.first << " " << q.second;
return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first + p2.first, p1.second + p2.second};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
return {p1.first - p2.first, p1.second - p2.second};
}
template <typename T1, typename T2>
bool operator<(pair<T1, T2> p1, pair<T1, T2> p2) {
return p1 < p2;
}
template <typename T>
void Unique(vector<T> &v) {
sort((v).begin(), (v).end()),
v.resize(distance(v.begin(), unique((v).begin(), (v).end())));
}
const int N = 2e5 + 1;
std::vector<int> g[N];
int tin[N], tout[N], h[N];
int val[N * 2], t, a[N];
vector<pair<int, int> > seg[8 * N];
void dfs(int v, int p) {
tin[v] = (++t);
val[t] = v;
for (auto u : g[v]) {
if (u != p) {
h[u] = h[v] + 1;
dfs(u, v);
}
}
tout[v] = (++t);
val[t] = v;
}
struct SEGTREE {
void merge(vector<pair<int, int> > &l, vector<pair<int, int> > &r,
vector<pair<int, int> > &v) {
int i = 0, j = 0;
while (i < (int)((l).size()) && j < (int)((r).size())) {
if (l[i].first < r[j].first)
v.push_back(l[i]), i++;
else
v.push_back(r[j]), j++;
}
while (i < (int)((l).size())) v.push_back(l[i]), i++;
while (j < (int)((r).size())) v.push_back(r[j]), j++;
for (int i = 1; i < (int)((v).size()); i++)
v[i].second = min(v[i].second, v[i - 1].second);
}
void build(int s, int e, int v) {
if (s == e) {
seg[v].push_back(make_pair(h[val[s]], a[val[s]]));
} else {
int m = (s + e) >> 1;
build(s, m, 2 * v), build(m + 1, e, 2 * v + 1);
merge(seg[2 * v], seg[2 * v + 1], seg[v]);
}
}
int query(int s, int e, int v, int l, int r, int x) {
if (s > r || l > e || s > e) return (int)(2e9);
if (l <= s && r >= e) {
int j = (int)(upper_bound((seg[v]).begin(), (seg[v]).end(),
make_pair(x + 1, -(int)(2e9))) -
begin(seg[v])) -
1;
if (j == -1) return (int)(2e9);
return seg[v][j].second;
}
int m = (s + e) >> 1;
return min(query(s, m, 2 * v, l, r, x),
query(m + 1, e, 2 * v + 1, l, r, x));
}
} sg;
void solve(int &test) {
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
dfs(r, -1);
sg.build(1, n * 2, 1);
int q, ans = 0;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x = (x + ans) % n + 1;
y = (y + ans) % n;
ans = sg.query(1, n * 2, 1, tin[x], tout[x], h[x] + y);
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
start = clock();
cout << fixed << setprecision(20);
for (int i = 1; i <= t; ++i) {
solve(i);
}
cerr << (double(clock() - start) / double(CLOCKS_PER_SEC));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 100 * 1000 + 16;
int const M = 1000 * 1000 * 1000 + 7;
int n, root;
int e, dist[N], tour[N], tin[N], tout[N];
int a[N];
vector<int> g[N];
vector<int> fl[1 << 18];
vector<int> fr[1 << 18];
vector<pair<int, int>> t[1 << 18];
void dfs(int u, int p) {
dist[u] = dist[p] + 1;
tin[u] = e;
tour[e++] = u;
for (int v : g[u])
if (v != p) dfs(v, u);
tout[u] = e - 1;
}
void build(int i, int l, int r) {
if (l == r) {
t[i].emplace_back(dist[tour[l]], a[tour[l]]);
return;
}
int m = (l + r) >> 1;
build(i << 1, l, m);
build(i << 1 | 1, m + 1, r);
int len = r - l + 1;
t[i].resize(len);
merge(t[i << 1].begin(), t[i << 1].end(), t[i << 1 | 1].begin(),
t[i << 1 | 1].end(), t[i].begin());
for (int j = 1; j < len; ++j)
t[i][j].second = min(t[i][j].second, t[i][j - 1].second);
int idx;
int len_left = m - l + 1;
int len_right = len - len_left;
idx = 0;
fl[i].resize(len, -1);
for (int j = 0; j < len; ++j) {
int x = t[i][j].first;
while (idx < len_left && t[i << 1][idx].first <= x) ++idx;
fl[i][j] = idx - 1;
}
idx = 0;
fr[i].resize(len, -1);
for (int j = 0; j < len; ++j) {
int x = t[i][j].first;
while (idx < len_right && t[i << 1 | 1][idx].first <= x) ++idx;
fr[i][j] = idx - 1;
}
}
int ql, qr;
int query(int i, int L, int R, int k) {
if (ql <= L && R <= qr) return t[i][k].second;
int m = (L + R) >> 1;
int ans = M;
if (ql <= m && fl[i][k] >= 0) ans = query(i << 1, L, m, fl[i][k]);
if (m < qr && fr[i][k] >= 0)
ans = min(ans, query(i << 1 | 1, m + 1, R, fr[i][k]));
return ans;
}
int query(int u, int k) {
ql = tin[u];
qr = tout[u];
int idx =
lower_bound(t[1].begin(), t[1].end(), make_pair(k + dist[u] + 1, 0)) -
t[1].begin();
return query(1, 0, n - 1, idx - 1);
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> n >> root;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
dfs(root, 0);
build(1, 0, n - 1);
int m;
cin >> m;
int last = 0;
while (m--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(x, k);
cout << last << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class Val, class Cmp>
class DynamicRMQ {
int n;
Val init;
vector<Val> dat;
Cmp cmp;
inline Val query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return init;
if (a <= l && r <= b)
return dat[k];
else {
Val vl, vr;
vl = query(a, b, k << 1, l, (l + r) >> 1);
vr = query(a, b, (k << 1) | 1, (l + r) >> 1, r);
return cmp(vl, vr) ? vl : vr;
}
}
public:
DynamicRMQ() {}
DynamicRMQ(int n_, Val init_) : n(1), init(init_) {
for (; n < n_; n <<= 1)
;
dat = vector<Val>(n << 1, init);
}
void update(int k, Val a) {
k += n;
dat[k] = a;
while (k > 1) {
k >>= 1;
dat[k] =
cmp(dat[k << 1], dat[(k << 1) | 1]) ? dat[k << 1] : dat[(k << 1) | 1];
}
}
Val query(int a, int b) { return query(a, b, 1, 0, n); }
};
const int N_MAX = 100005, LOG = 18;
int N, R, A[N_MAX];
int e2v[N_MAX], v2e[N_MAX];
int euler_l[N_MAX], euler_r[N_MAX];
int id, depth[N_MAX], ancestor[LOG][N_MAX], min_a[LOG][N_MAX], bfs_id[N_MAX];
vector<int> G[N_MAX];
vector<pair<int, int> > ordered[N_MAX + N_MAX];
DynamicRMQ<int, less<int> > rmq[LOG];
void f(int u, int p, int d) {
e2v[id] = u;
euler_l[u] = v2e[u] = id;
ordered[d].emplace_back(id++, 0);
depth[u] = d;
ancestor[0][u] = p != -1 ? p : u;
for (int(j) = (0); (j) < (int)(LOG); ++(j))
(min_a[j][u]) = min((min_a[j][u]), (A[u]));
(min_a[0][ancestor[0][u]]) = min((min_a[0][ancestor[0][u]]), (A[u]));
for (auto &(v) : (G[u]))
if (p != v) {
f(v, u, d + 1);
}
euler_r[u] = id;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> R;
--R;
for (int(i) = (0); (i) < (int)(N); ++(i)) cin >> A[i];
for (int(i) = (0); (i) < (int)(N - 1); ++(i)) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int(i) = (0); (i) < (int)(LOG); ++(i)) {
rmq[i] = DynamicRMQ<int, less<int> >(N, 1 << 30);
for (int(j) = (0); (j) < (int)(N); ++(j)) min_a[i][j] = 1 << 30;
}
f(R, -1, 0);
id = 0;
for (int(i) = (0); (i) < (int)(N); ++(i))
for (auto &(p) : (ordered[i])) {
bfs_id[e2v[p.first]] = p.second = id++;
}
for (int(i) = (0); (i) < (int)(LOG - 1); ++(i)) {
for (int(j) = (0); (j) < (int)(N); ++(j)) {
ancestor[i + 1][j] = ancestor[i][ancestor[i][j]];
(min_a[i + 1][j]) = min((min_a[i + 1][j]), (min_a[i][j]));
(min_a[i + 1][ancestor[i][j]]) =
min((min_a[i + 1][ancestor[i][j]]), (min_a[i][j]));
}
for (int(j) = (0); (j) < (int)(N); ++(j))
rmq[i].update(bfs_id[j], min_a[i][j]);
}
int M, ans = 0;
cin >> M;
while (M--) {
int p, q, X, K;
cin >> p >> q;
X = (p + ans) % N;
K = (q + ans) % N;
ans = A[X];
int dep = depth[X];
for (int(i) = (0); (i) < (int)(LOG - 1); ++(i))
if (K >> i & 1) {
auto l = lower_bound((ordered[dep]).begin(), (ordered[dep]).end(),
make_pair(euler_l[X], 0));
auto r = lower_bound((ordered[dep]).begin(), (ordered[dep]).end(),
make_pair(euler_r[X], 0));
while (l != r) {
--r;
(ans) = min((ans), (rmq[i].query(l->second, r->second + 1)));
}
dep += 1 << i;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5;
const int INF = 0x3f3f3f3f;
using namespace std;
int rt[MAXN + 5];
struct SegmentTree {
struct Node {
int ls, rs, mn;
} s[MAXN * 60 + 5];
int tot;
SegmentTree() {}
void upd(int p) {
int lm = s[p].ls ? s[s[p].ls].mn : INF, rm = s[p].rs ? s[s[p].rs].mn : INF;
s[p].mn = min(lm, rm);
}
void insert(int &p, int l, int r, int u, int val) {
if (!p) p = ++tot, s[p].mn = INF;
if (l == r) {
s[p].mn = val;
return;
}
int mid = (l + r) >> 1;
if (u <= mid) {
insert(s[p].ls, l, mid, u, val);
} else {
insert(s[p].rs, mid + 1, r, u, val);
}
upd(p);
}
int query(int p, int l, int r, int x, int y) {
if (!p) return INF;
if (x <= l && y >= r) return s[p].mn;
int mid = (l + r) >> 1, ret = INF;
if (x <= mid) ret = query(s[p].ls, l, mid, x, y);
if (y > mid) ret = min(ret, query(s[p].rs, mid + 1, r, x, y));
return ret;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int p = ++tot;
s[p].mn = min(s[x].mn, s[y].mn);
s[p].ls = merge(s[x].ls, s[y].ls);
s[p].rs = merge(s[x].rs, s[y].rs);
return p;
}
} Sgt;
int n, a[MAXN + 5], depth[MAXN + 5], tree_rt;
namespace tree {
vector<int> adj[MAXN + 5];
void addEdge(int u, int v) { adj[u].push_back(v), adj[v].push_back(u); }
void dfs(int u, int fa) {
Sgt.insert(rt[u], 1, n, depth[u], a[u]);
for (int v : adj[u]) {
if (v == fa) continue;
depth[v] = depth[u] + 1, dfs(v, u);
rt[u] = Sgt.merge(rt[u], rt[v]);
}
}
} // namespace tree
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> tree_rt;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
tree::addEdge(u, v);
}
depth[tree_rt] = 1, tree::dfs(tree_rt, 0);
}
int last_ans, m;
int main() {
init();
cin >> m;
while (m--) {
int u, k;
cin >> u >> k;
u = (u + last_ans) % n + 1, k = (k + last_ans) % n;
last_ans = Sgt.query(rt[u], 1, n, depth[u], min(depth[u] + k, n));
cout << last_ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1 &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1 &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <int MOD>
struct ModInt {
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) : x(sig) {}
ModInt(signed long long sig) : x(sig % MOD) {}
int get() const { return (int)x; }
ModInt pow(long long p) {
ModInt res = 1, a = *this;
while (p) {
if (p & 1) res *= a;
a *= a;
p >>= 1;
}
return res;
}
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return (*this) *= that.pow(MOD - 2); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
bool operator<(ModInt that) const { return x < that.x; }
friend ostream &operator<<(ostream &os, ModInt a) {
os << a.x;
return os;
}
};
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
struct node {
vector<pair<int, int> > a;
vector<int> st;
};
const int N = 100001, inf = 1e9;
int a[N];
int dep[N], ndep;
node st[N * 2];
vector<int> g[N];
int in[N], out[N], ct;
void dfs(int i, int p) {
dep[i] = dep[p] + 1;
Max(ndep, dep[i]);
in[i] = ++ct;
for (auto &e : g[i])
if (e != p) {
dfs(e, i);
}
out[i] = ct;
}
int que(int i, int l, int r) {
l = lower_bound(st[i].a.begin(), st[i].a.end(), pair<int, int>{l, 0}) -
st[i].a.begin();
r = upper_bound(st[i].a.begin(), st[i].a.end(), pair<int, int>{r, inf}) -
st[i].a.begin();
int ans = inf;
for (l += st[i].a.size(), r += st[i].a.size(); l < r; l >>= 1, r >>= 1) {
if (l & 1) Min(ans, st[i].st[l++]);
if (r & 1) Min(ans, st[i].st[--r]);
}
return ans;
}
void solve() {
int n, r, x, y, m;
cin >> n >> r;
for (int i = 1; i <= (n); ++i) cin >> a[i];
for (int it = 0; it < (n - 1); ++it) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r, 0);
ndep++;
for (int i = 1; i <= (n); ++i) {
int d = dep[i];
pair<int, int> v = {in[i], a[i]};
for (d += ndep; d; d >>= 1) {
st[d].a.push_back(v);
}
}
for (int d = 1; d <= (ndep * 2 - 1); ++d) {
sort(st[d].a.begin(), st[d].a.end());
int n = st[d].a.size();
st[d].st.assign(n * 2, inf);
for (int i = 0; i < (n); ++i) st[d].st[i + n] = st[d].a[i].second;
for (int i = n - 1; i >= (1); --i)
st[d].st[i] = min(st[d].st[i << 1], st[d].st[i << 1 | 1]);
}
cin >> m;
int ans = 0;
while (m--) {
cin >> x >> y;
x = (x + ans) % n + 1;
y = (y + ans) % n;
int l = dep[x], r = l + y;
Min(r, ndep - 1);
int tl = in[x], tr = out[x];
ans = inf;
for (l += ndep, r += ndep + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) Min(ans, que(l++, tl, tr));
if (r & 1) Min(ans, que(--r, tl, tr));
}
cout << ans << '\n';
}
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100, L = 19, INF = (int)1e9 + 5;
int n, a[N];
vector<int> tree[N], layer[N];
int anc[L][N], rmq[L][N], dpt[N], st[N], en[N], rev[N], timer;
void df0(int u = 1, int par = 0, int depth = 1) {
st[u] = ++timer;
rev[timer] = u;
dpt[u] = depth;
anc[0][u] = par;
layer[depth].emplace_back(timer);
for (const int& v : tree[u])
if (v != par) df0(v, u, depth + 1);
en[u] = timer;
}
void init_dp() {
for (int j = 1; j < L; j++)
for (int i = 1; i <= n; i++) {
int pops = anc[j - 1][i];
anc[j][i] = (pops > 0 ? anc[j - 1][pops] : 0);
}
for (int i = 1; i <= n; i++) rmq[0][i] = a[i];
for (int i = 1; i <= n; i++) {
if (anc[0][i] > 0) {
int& t = rmq[0][anc[0][i]];
t = min(t, a[i]);
}
}
for (int j = 1; j < L; j++) {
for (int i = 1; i <= n; i++) rmq[j][i] = rmq[j - 1][i];
for (int i = 1; i <= n; i++) {
int dad = anc[j - 1][i];
if (dad > 0) rmq[j][dad] = min(rmq[j][dad], rmq[j - 1][i]);
}
}
}
struct SimpleTree {
static constexpr int ID = INF;
static int compress(const int& lc, const int& rc) { return min(lc, rc); }
int n;
vector<int> tree;
void build(const int& j, const vector<int>& t) {
n = t.size();
tree.resize(n + n);
for (int i = n - 1; i >= 0; i--) {
int v = rev[t[i]];
tree[i + n] = rmq[j][v];
}
for (int i = n - 1; i > 0; i--)
tree[i] = compress(tree[i + i], tree[i + i + 1]);
}
void modify(int i, const int& u) {
i += n;
tree[i] = u;
for (int p = i >> 1; i > 1; i >>= 1, p >>= 1)
tree[p] = compress(tree[i], tree[i ^ 1]);
}
int query(int l, int r) {
int lx = ID, rx = ID;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) lx = compress(lx, tree[l++]);
if (r & 1) rx = compress(tree[--r], rx);
}
return compress(lx, rx);
}
};
SimpleTree T[L][N];
int query(int v, int k) {
int answer = a[v];
int depth = dpt[v];
for (int j = L - 1, b = 1 << j; j >= 0; j--, b >>= 1)
if (k & b) {
if (depth > n or layer[depth].empty()) break;
int lx, rx;
int lo = 0, hi = layer[depth].size() - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (layer[depth][mid] >= st[v])
hi = mid;
else
lo = mid + 1;
}
lx = lo;
lo = 0, hi = layer[depth].size() - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (layer[depth][mid] > en[v])
hi = mid;
else
lo = mid + 1;
}
rx = lo;
int q = T[j][depth].query(lx, rx);
answer = min(answer, q);
depth += b;
}
return answer;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int r;
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int u, v, i = 1; i < n; i++) {
cin >> u >> v;
tree[u].emplace_back(v);
tree[v].emplace_back(u);
}
timer = 0;
df0(r);
dpt[0] = 0, st[0] = 0, en[0] = timer;
init_dp();
for (int depth = 1; depth <= n; depth++)
if (not layer[depth].empty()) layer[depth].emplace_back(n + 1);
for (int j = 0; j < L; j++)
for (int depth = 1; depth <= n; depth++) {
if (not layer[depth].empty()) {
T[j][depth].build(j, layer[depth]);
}
}
int m, answer = 0;
cin >> m;
while (m--) {
int p, q;
cin >> p >> q;
int v = 1 + (p + answer) % n, k = (q + answer) % n;
answer = query(v, k);
cout << answer << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int n, m, r, a[MAX], ls[MAX << 6], rs[MAX << 6], val[MAX << 6], d[MAX], rt[MAX],
cnt;
struct P {
int to, nxt;
} e[MAX << 1];
int head[MAX], tot;
void init() {
memset(head, -1, sizeof(head));
memset(val, 0, sizeof(val));
memset(rt, 0, sizeof(rt));
memset(ls, 0, sizeof(ls));
memset(rs, 0, sizeof(rs));
tot = 0;
cnt = 0;
val[0] = INF;
}
void adde(int u, int v) {
e[tot].to = v;
e[tot].nxt = head[u];
head[u] = tot++;
}
void update(int &x, int l, int r, int p, int v) {
x = ++cnt;
if (l == r) {
val[x] = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(ls[x], l, mid, p, v);
else
update(rs[x], mid + 1, r, p, v);
val[x] = min(val[ls[x]], val[rs[x]]);
}
int merge_(int u, int v) {
if (!u) return v;
if (!v) return u;
int x = ++cnt;
ls[x] = merge_(ls[u], ls[v]);
rs[x] = merge_(rs[u], rs[v]);
if (ls[x] || rs[x])
val[x] = min(val[ls[x]], val[rs[x]]);
else
val[x] = min(val[u], val[v]);
return x;
}
int query(int x, int l, int r, int L, int R) {
if (!x) return INF;
if (l == L && r == R) return val[x];
int mid = (l + r) >> 1;
if (R <= mid) return query(ls[x], l, mid, L, R);
if (L > mid) return query(rs[x], mid + 1, r, L, R);
return min(query(ls[x], l, mid, L, mid),
query(rs[x], mid + 1, r, mid + 1, R));
}
void dfs(int u, int fa) {
update(rt[u], 1, 100000, d[u], a[u]);
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
d[v] = d[u] + 1;
dfs(v, u);
rt[u] = merge_(rt[u], rt[v]);
}
}
int main() {
int x, y;
while (~scanf("%d%d", &n, &r)) {
init();
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
adde(x, y);
adde(y, x);
}
d[r] = 1;
dfs(r, 0);
scanf("%d", &m);
int last = 0;
while (m--) {
scanf("%d%d", &x, &y);
x = (x + last) % n + 1;
y = (y + last) % n;
printf("%d\n",
last = query(rt[x], 1, 100000, d[x], min(100000, d[x] + y)));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class FID {
int n;
vector<bool> data;
vector<int> ra, se0, se1;
public:
FID(int n_) : n(n_), data(n), ra(n + 1) {}
void set(int i) { data[i] = true; }
void build() {
for (int i = 0; i < n; i++) {
ra[i + 1] = ra[i] + data[i];
}
for (int i = 0; i < n; i++) {
(data[i] ? se1 : se0).push_back(i);
}
}
int rank(int i, bool b) const { return b ? ra[i] : i - ra[i]; }
int rank(int l, int r, bool b) const { return rank(r, b) - rank(l, b); }
int select(int x, bool b) const { return (b ? se1 : se0)[x]; }
int select(int l, int x, bool b) const { return select(x + rank(l, b), b); }
};
template <typename T>
class wavelet_matrix {
T h;
int n;
vector<FID> data;
vector<int> mid;
T get_h(T val) {
T res = 1;
while ((1LL << res) <= val) ++res;
return res;
}
public:
wavelet_matrix(const vector<T>& data_)
: h(get_h(*max_element(data_.begin(), data_.end()))),
n(data_.size()),
mid(h) {
data.assign(h, n);
vector<T> ar1(data_), ar2(n);
for (T b = 0; b < h; b++) {
int p = 0;
for (int i = 0; i < n; i++) {
if ((ar1[i] & ((T)1 << (h - 1 - b))) == 0) {
ar2[p++] = ar1[i];
}
}
mid[b] = p;
for (int i = 0; i < n; i++) {
if (ar1[i] & ((T)1 << (h - 1 - b))) {
data[b].set(i);
ar2[p++] = ar1[i];
}
}
data[b].build();
ar1.swap(ar2);
}
}
int rank(int p, T val) { return rank(0, p, val); }
int rank(int l, int r, T val) {
if (val >> h) return 0;
for (T b = 0; b < h; b++) {
if (val & ((T)1 << (h - 1 - b))) {
l = data[b].rank(l, true) + mid[b];
r = data[b].rank(r, true) + mid[b];
} else {
l = data[b].rank(l, false);
r = data[b].rank(r, false);
}
}
return r - l;
}
int rank_less_than(int l, int r, T ub) {
if (ub >> h) return r - l;
int res = 0;
for (T b = 0; b < h; b++) {
bool d = (ub >> (h - 1 - b)) & 1;
int lcnt = data[b].rank(l, d);
int rcnt = data[b].rank(r, d);
if (d) res += (r - l) - (rcnt - lcnt);
l = lcnt;
r = rcnt;
if (d) {
l += mid[b];
r += mid[b];
}
}
return res;
}
int rank_range(int l, int r, T lb, T ub) {
return rank_less_than(l, r, ub) - rank_less_than(l, r, lb);
}
int select(int x, T val) {
static int left[h];
int l = 0, r = n;
for (T b = 0; b < h; b++) {
left[b] = l;
if (val & ((T)1 << (h - 1 - b))) {
l = data[b].rank(l, true) + mid[b];
r = data[b].rank(r, true) + mid[b];
} else {
l = data[b].rank(l, false);
r = data[b].rank(r, false);
}
}
for (int b = h - 1; b >= 0; b--) {
x = data[b].select(left[b], x, (bool)((val >> (h - 1 - b)) & 1)) -
left[b];
}
return x;
}
int select(int l, int r, int x, T val) {
return select(x + rank(l, val), val);
}
T kth_element(int l, int r, int k) {
T res = 0;
for (T b = 0; b < h; b++) {
int cnt = data[b].rank(l, r, false);
res <<= 1;
if (k >= cnt) {
l = data[b].rank(l, true) + mid[b];
r = data[b].rank(r, true) + mid[b];
k -= cnt;
res |= 1;
} else {
l = data[b].rank(l, false);
r = data[b].rank(r, false);
}
}
return res;
}
};
struct RMQ {
using type = int;
static type id() { return INT_MAX; }
static type op(const type& l, const type& r) { return min(l, r); }
};
template <typename M>
class segment_tree {
using T = typename M::type;
const int n;
vector<T> data;
public:
segment_tree(int n_) : n(1 << (int)ceil(log2(n_))), data(n << 1, M::id()) {}
void init(const vector<T>& data_) {
for (int i = 0; i < (int)data_.size(); i++) data[i + n] = data_[i];
for (int i = n - 1; i >= 0; i--)
data[i] = M::op(data[i << 1], data[(i << 1) | 1]);
}
T find(int l, int r) const {
l += n;
r += n + 1;
T res1 = M::id(), res2 = M::id();
while (l < r) {
if (l & 1) res1 = M::op(res1, data[l++]);
if (r & 1) res2 = M::op(data[--r], res2);
l >>= 1;
r >>= 1;
}
return M::op(res1, res2);
}
};
const int BS = 17;
const int MAX = 1e5;
vector<int> G[MAX];
int depth[MAX];
int lv[MAX];
int rv[MAX];
int it;
int et[MAX];
int par[BS][MAX];
int a[MAX];
int mn[BS][MAX];
vector<int> ets[MAX];
vector<segment_tree<RMQ>> segs[BS];
void euler_tour(int v, int prev) {
par[0][v] = prev;
mn[0][v] = a[v];
depth[v] = prev != -1 ? depth[prev] + 1 : 0;
ets[depth[v]].push_back(v);
lv[v] = it;
et[it++] = v;
for (auto to : G[v])
if (to != prev) {
euler_tour(to, v);
}
rv[v] = it;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, rt;
cin >> n >> rt;
rt--;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
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);
}
euler_tour(rt, -1);
vector<int> etd(n);
for (int i = 0; i < n; i++) {
etd[i] = depth[et[i]];
}
wavelet_matrix<int> wm(etd);
for (int i = 1; i < BS; i++) {
for (int j = 0; j < n; j++) {
mn[i][j] = mn[i - 1][j];
par[i][j] = -1;
}
for (int j = 0; j < n; j++) {
if (par[i - 1][j] != -1) {
par[i][j] = par[i - 1][par[i - 1][j]];
mn[i][par[i - 1][j]] = min(mn[i][par[i - 1][j]], mn[i - 1][j]);
}
}
}
for (int i = 0; i < BS; i++) {
for (int j = 0; j < n; j++) {
if (ets[j].empty()) break;
int len = ets[j].size();
segs[i].emplace_back(len);
vector<int> base(len);
for (int k = 0; k < len; k++) {
base[k] = mn[i][ets[j][k]];
}
segs[i].back().init(base);
}
}
int m, last = 0;
cin >> m;
while (m--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n, k = (q + last) % n + 1;
int res = INT_MAX;
int td = depth[x];
int b = 0;
while (k) {
if (k & 1) {
int l = wm.rank(lv[x], td), r = wm.rank(rv[x], td);
if (l == r) break;
res = min(res, segs[b][td].find(l, r - 1));
td += 1 << b;
}
b++;
k >>= 1;
}
printf("%d\n", (last = res));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, rt, t[100010], sum[8000010], l[8000010], r[8000010], cnt;
int dep[100010], a[100010], fa[100010];
vector<int> vc[100010];
void ins(int &p, int lf, int rg, int w, int x) {
if (!p) {
p = ++cnt;
}
if (lf == rg) {
sum[p] = x;
return;
}
sum[p] = min(sum[p], x);
int mid = (lf + rg) >> 1;
if (w <= mid) {
ins(l[p], lf, mid, w, x);
}
if (mid < w) {
ins(r[p], mid + 1, rg, w, x);
}
}
int merge(int x, int y) {
if (!x || !y) {
return x + y;
}
int p = ++cnt;
sum[p] = min(sum[x], sum[y]);
l[p] = merge(l[x], l[y]);
r[p] = merge(r[x], r[y]);
return p;
}
int query(int o, int lf, int rg, int ll, int rr) {
if (!o) {
return 0x3f3f3f3f;
}
if (ll <= lf && rg <= rr) {
return sum[o];
}
int ans = 0x3f3f3f3f;
int mid = (lf + rg) >> 1;
if (ll <= mid) {
ans = min(ans, query(l[o], lf, mid, ll, rr));
}
if (mid < rr) {
ans = min(ans, query(r[o], mid + 1, rg, ll, rr));
}
return ans;
}
void dfs(int u) {
ins(t[u], 1, n, dep[u], a[u]);
for (auto v : vc[u]) {
if (v == fa[u]) {
continue;
}
dep[v] = dep[u] + 1;
fa[v] = u;
dfs(v);
t[u] = merge(t[u], t[v]);
}
}
int main() {
memset(sum, 0x3f, sizeof(sum));
cin >> n >> rt;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
vc[x].push_back(y);
vc[y].push_back(x);
}
dep[rt] = 1;
dfs(rt);
int q, las = 0;
cin >> q;
for (int i = 1; i <= q; i++) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + las) % n + 1, k = (k + las) % n;
cout << (las = query(t[x], 1, n, dep[x], min(dep[x] + k, n))) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int cnt = 0, f = 1;
char ch = 0;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') f = -1;
}
while (isdigit(ch))
cnt = (cnt << 3) + (cnt << 1) + (ch - '0'), ch = getchar();
return cnt * f;
}
const int inf = 0x3fffffff;
const int maxn = 2e5 + 50;
vector<int> q[maxn];
vector<int> graph[maxn];
int cnt, dep[maxn], in[maxn], out[maxn];
int n, m, root, rt[maxn], nume, mx;
int lasta;
int a[maxn];
struct node {
int ls, rs, val;
} tree[maxn * 30];
void build(int& x, int l, int r) {
x = ++cnt;
tree[x].val = inf;
if (l == r) return;
int mid = (l + r) / 2;
build(tree[x].ls, l, mid);
build(tree[x].rs, mid + 1, r);
}
void insert(int& x, int last, int l, int r, int pos, int val) {
x = ++cnt;
tree[x] = tree[last];
tree[x].val = min(tree[x].val, val);
if (l == r) return;
int mid = (l + r) / 2;
if (pos <= mid)
insert(tree[x].ls, tree[last].ls, l, mid, pos, val);
else
insert(tree[x].rs, tree[last].rs, mid + 1, r, pos, val);
}
int query(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return tree[x].val;
int mid = (l + r) / 2;
int ans = inf;
if (L <= mid) ans = min(ans, query(tree[x].ls, l, mid, L, R));
if (R > mid) ans = min(ans, query(tree[x].rs, mid + 1, r, L, R));
return ans;
}
void dfs(int u, int fa) {
in[u] = ++nume;
q[dep[u]].push_back(u);
mx = max(mx, dep[u]);
for (int i = 0; i < graph[u].size(); i++) {
int v = graph[u][i];
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
}
out[u] = nume;
}
int main() {
n = read();
root = read();
build(rt[0], 1, n);
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int u, v;
u = read(), v = read();
graph[u].push_back(v);
graph[v].push_back(u);
}
dep[root] = 1;
dfs(root, 0);
for (int i = 1; i <= mx; i++) {
rt[i] = rt[i - 1];
for (int j = 0; j < q[i].size(); j++) {
insert(rt[i], rt[i], 1, n, in[q[i][j]], a[q[i][j]]);
}
}
m = read();
while (m--) {
int u = (read() + lasta) % n + 1;
int k = (read() + lasta) % n;
lasta = query(rt[min(mx, dep[u] + k)], 1, n, in[u], out[u]);
cout << lasta << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100001;
const int inf = 0x7fffffff;
int n, q, a[maxn], x, y, mp[maxn];
int d[maxn], md, pl[maxn], pr[maxn], tot;
vector<int> v[maxn];
int l, r, ans;
struct p {
int l, r;
long long val;
} tr[maxn * 25];
int rt[maxn], cnt;
int build(int no, int l, int r) {
no = ++cnt;
if (l == r) return tr[no].val = inf, no;
int m = l + r >> 1;
tr[no].l = build(no, l, m);
tr[no].r = build(no, m + 1, r);
tr[no].val = inf;
return no;
}
int clone(int no) {
tr[++cnt] = tr[no];
return cnt;
}
int update(int no, int l, int r, int x, int val) {
no = clone(no);
if (l == r) return tr[no].val = val, no;
int m = l + r >> 1;
if (x <= m)
tr[no].l = update(tr[no].l, l, m, x, val);
else
tr[no].r = update(tr[no].r, m + 1, r, x, val);
tr[no].val = min(tr[tr[no].l].val, tr[tr[no].r].val);
return no;
}
long long ask(int no, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return tr[no].val;
int m = l + r >> 1;
long long ans = inf;
if (m >= ll) ans = min(ans, ask(tr[no].l, l, m, ll, rr));
if (m + 1 <= rr) ans = min(ans, ask(tr[no].r, m + 1, r, ll, rr));
return ans;
}
void dfs(int f, int x) {
pl[x] = ++tot;
d[x] = d[f] + 1, md = max(md, d[x]);
for (auto i : v[x])
if (i != f) dfs(x, i);
pr[x] = tot;
}
struct pp {
int f, x;
} e;
void bfs(int r) {
queue<pp> qu;
qu.push({0, r});
while (qu.size()) {
e = qu.front(), qu.pop();
if (!mp[d[e.x]])
mp[d[e.x]] = 1,
rt[d[e.x]] = update(rt[d[e.x] - 1], 1, n, pl[e.x], a[e.x]);
else
rt[d[e.x]] = update(rt[d[e.x]], 1, n, pl[e.x], a[e.x]);
for (auto i : v[e.x])
if (i != e.f) qu.push({e.x, i});
}
}
signed main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
rt[0] = build(0, 1, n);
for (int i = 1; i < n; i++)
scanf("%d%d", &x, &y), v[x].push_back(y), v[y].push_back(x);
dfs(0, r);
bfs(r);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
l = (l + ans) % n + 1;
r = (r + ans) % n;
ans = ask(rt[min(d[l] + r, md)], 1, n, pl[l], pr[l]);
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int oper(const int &a, const int &b) { return min(a, b); }
struct Node {
int v;
Node *l, *r;
Node(int v) : v(v), l(NULL), r(NULL) {}
Node(Node *l, Node *r) : l(l), r(r) {
if (!l)
v = r->v;
else if (!r)
v = l->v;
else
v = oper(l->v, r->v);
}
};
Node *build(int tl, int tr) {
if (tl + 1 == tr) return new Node(1000100100);
int tm = (tl + tr) >> 1;
return new Node(build(tl, tm), build(tm, tr));
}
Node *update(int pos, int new_val, Node *t, int tl, int tr) {
if (tl + 1 == tr) return new Node(new_val);
int tm = (tl + tr) >> 1;
if (pos < tm)
return new Node(update(pos, new_val, t->l, tl, tm), t->r);
else
return new Node(t->l, update(pos, new_val, t->r, tm, tr));
}
int get(int l, int r, Node *t, int tl, int tr) {
if (l == tl && tr == r) return t->v;
int tm = (tl + tr) >> 1;
if (r <= tm)
return get(l, r, t->l, tl, tm);
else if (l >= tm)
return get(l, r, t->r, tm, tr);
return oper(get(l, tm, t->l, tl, tm), get(tm, r, t->r, tm, tr));
}
vector<int> g[100010];
int v[100010], id[100010], nvl[100010], auxid;
pair<int, int> subTree[100010];
map<int, vector<int>> nodesOfNvl;
void dfs(int node, int prev, int prof) {
id[node] = auxid++;
nvl[node] = prof;
nodesOfNvl[prof].push_back(node);
for (auto it = g[node].begin(); it != g[node].end(); it++)
if (*it != prev) dfs(*it, node, prof + 1);
subTree[node] = make_pair(id[node], auxid);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, r;
cin >> n >> r;
r--;
for (int i = (0); i < (n); i++) cin >> v[i];
for (int i = (0); i < (n - 1); i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(r, r, 0);
assert(auxid == n);
vector<Node *> roots(nodesOfNvl.size() + 1, NULL);
int nextPos = 1;
roots[0] = build(0, n);
for (auto it = nodesOfNvl.begin(); it != nodesOfNvl.end(); it++) {
for (auto ite = it->second.begin(); ite != it->second.end(); ite++) {
if (roots[nextPos] == NULL)
roots[nextPos] = update(id[*ite], v[*ite], roots[nextPos - 1], 0, n);
else
roots[nextPos] = update(id[*ite], v[*ite], roots[nextPos], 0, n);
}
nextPos++;
}
int m, last = 0;
cin >> m;
for (int Q = (0); Q < (m); Q++) {
int p, q, x, k;
cin >> p >> q;
x = (p + last) % n;
k = (q + last) % n;
last = get(subTree[x].first, subTree[x].second,
roots[min((int)roots.size() - 1, nvl[x] + 1 + k)], 0, n);
cout << last << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30), N = 200000;
int cnt, n, r, Q, deep[N], dfn[N], size[N], a[N], root[N << 2], len, last;
struct node {
int lson, rson, Min = INF;
} t[10000000];
vector<int> V[N];
void dfs(int x, int fat) {
dfn[x] = ++cnt;
deep[x] = deep[fat] + 1;
size[x] = 1;
for (int i = 0, s = V[x].size(); i < s; i++)
if (V[x][i] != fat) dfs(V[x][i], x), size[x] += size[V[x][i]];
}
void InInsert(int i, int l, int r, int Dfn, int val) {
t[i].Min = min(t[i].Min, val);
if (l == r) return;
int mid = (l + r) >> 1;
if (mid >= Dfn) {
if (!t[i].lson) t[i].lson = ++len;
InInsert(t[i].lson, l, mid, Dfn, val);
} else {
if (!t[i].rson) t[i].rson = ++len;
InInsert(t[i].rson, mid + 1, r, Dfn, val);
}
}
void OutInsert(int i, int l, int r, int dep, int Dfn, int val) {
if (!root[i]) root[i] = ++len;
InInsert(root[i], 1, n, Dfn, val);
if (l == r) return;
int mid = (l + r) >> 1;
if (mid >= dep)
OutInsert(i << 1, l, mid, dep, Dfn, val);
else
OutInsert(i << 1 | 1, mid + 1, r, dep, Dfn, val);
}
int InQuery(int i, int l, int r, int dfnb, int dfne) {
if (!i) return INF;
if (l >= dfnb && r <= dfne) return t[i].Min;
int mid = (l + r) >> 1, ans = INF;
if (mid >= dfnb) ans = min(ans, InQuery(t[i].lson, l, mid, dfnb, dfne));
if (mid < dfne) ans = min(ans, InQuery(t[i].rson, mid + 1, r, dfnb, dfne));
return ans;
}
int OutQuery(int i, int l, int r, int depb, int depe, int dfnb, int dfne) {
if (l >= depb && r <= depe) return InQuery(root[i], 1, n, dfnb, dfne);
int mid = (l + r) >> 1, ans = INF;
if (mid >= depb)
ans = min(ans, OutQuery(i << 1, l, mid, depb, depe, dfnb, dfne));
if (mid < depe)
ans = min(ans, OutQuery(i << 1 | 1, mid + 1, r, depb, depe, dfnb, dfne));
return ans;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
V[u].push_back(v);
V[v].push_back(u);
}
dfs(r, 0);
for (int i = 1; i <= n; i++) OutInsert(1, 1, n, deep[i], dfn[i], a[i]);
scanf("%d", &Q);
while (Q--) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + last) % n + 1;
k = (k + last) % n;
last = OutQuery(1, 1, n, deep[x], min(deep[x] + k, n), dfn[x],
dfn[x] + size[x] - 1);
printf("%d\n", last);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int pr[MAX];
int ht[MAX];
int tin[MAX];
int tout[MAX];
int rev[MAX];
vector<int> adj[MAX];
vector<int> val[MAX * 4];
vector<int> vech[MAX * 4];
int tim;
void dfs(int s, int p) {
tin[s] = (++tim);
rev[tim] = s;
for (int i = 0; i < adj[s].size(); i++) {
int u = adj[s][i];
if (u != p) {
ht[u] = ht[s] + 1;
dfs(u, s);
}
}
tout[s] = tim;
}
void merge(int pos) {
int ptr1 = 0;
int ptr2 = 0;
int lft = 2 * pos;
int rgt = pos + pos + 1;
while (ptr1 < val[lft].size() && ptr2 < val[rgt].size()) {
if (vech[lft][ptr1] == vech[rgt][ptr2]) {
vech[pos].push_back(vech[lft][ptr1]);
val[pos].push_back(min(val[lft][ptr1], val[rgt][ptr2]));
ptr1++;
ptr2++;
} else if (vech[lft][ptr1] < vech[rgt][ptr2]) {
vech[pos].push_back(vech[lft][ptr1]);
val[pos].push_back(val[lft][ptr1]);
ptr1++;
} else {
vech[pos].push_back(vech[rgt][ptr2]);
val[pos].push_back(val[rgt][ptr2]);
ptr2++;
}
}
for (int i = ptr1; i < val[lft].size(); i++) {
vech[pos].push_back(vech[lft][i]);
val[pos].push_back(val[lft][i]);
}
for (int i = ptr2; i < val[rgt].size(); i++) {
vech[pos].push_back(vech[rgt][i]);
val[pos].push_back(val[rgt][i]);
}
for (int i = 1; i < val[pos].size(); i++) {
val[pos][i] = min(val[pos][i - 1], val[pos][i]);
}
}
void build(int pos, int l, int r) {
if (l == r) {
int s = rev[l];
vech[pos].push_back(ht[s]);
val[pos].push_back(pr[s]);
return;
}
int mid = (l + r) / 2;
build(pos + pos, l, mid);
build(pos + pos + 1, mid + 1, r);
merge(pos);
}
int query(int pos, int l, int r, int ql, int qr, int y) {
if (ql > r || qr < l) {
return 1e9 + 5;
}
if (l >= ql && r <= qr) {
int x = upper_bound(vech[pos].begin(), vech[pos].end(), y) -
vech[pos].begin() - 1;
if (x < 0) {
return 1e9 + 5;
} else {
return val[pos][x];
}
}
int mid = (l + r) / 2;
int a = query(pos + pos, l, mid, ql, qr, y);
int b = query(pos + pos + 1, mid + 1, r, ql, qr, y);
return min(a, b);
}
int main() {
int n, r;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &pr[i]);
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(r, 0);
build(1, 1, n);
int q;
scanf("%d", &q);
int last = 0;
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d %d", &x, &y);
x = ((x + last) % n) + 1;
y = ((y + last) % n);
last = query(1, 1, n, tin[x], tout[x], min(ht[x] + y, n));
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt, starts[1000005], endd[1000005], tim[1000005], h[1000005], arr[1000005];
vector<int> v[1000005];
vector<pair<int, int> > seg[4000016];
vector<pair<int, int> >::iterator it;
void build(int node, int start, int end) {
if (start > end) return;
if (start == end) {
seg[node].push_back(make_pair(h[tim[start]], arr[tim[start]]));
return;
}
int mid = (start + end) / 2;
build(node << 1, start, mid);
build(node << 1 | 1, mid + 1, end);
seg[node].resize(seg[node << 1].size() + seg[node << 1 | 1].size());
merge(seg[node << 1].begin(), seg[node << 1].end(),
seg[node << 1 | 1].begin(), seg[node << 1 | 1].end(),
seg[node].begin());
for (int i = 1; i < seg[node].size(); i++) {
seg[node][i].second = min(seg[node][i].second, seg[node][i - 1].second);
}
}
int query(int node, int start, int end, int l, int r, int k) {
if (start > end || r < start || end < l) return 2e9;
if (l <= start && end <= r) {
it = upper_bound(seg[node].begin(), seg[node].end(),
make_pair(k, 2000000000));
if (it == seg[node].begin()) return 2000000000;
it--;
return (*it).second;
}
int mid = (start + end) / 2;
return min(query(node << 1, start, mid, l, r, k),
query(node << 1 | 1, mid + 1, end, l, r, k));
}
void dfs(int node, int par, int lev) {
tim[++cnt] = node;
starts[node] = cnt;
h[node] = lev;
for (int i = 0; i < v[node].size(); i++)
if (v[node][i] != par) dfs(v[node][i], node, lev + 1);
endd[node] = cnt;
}
int main() {
int n, root, last = 0, m, a, b, p, q, x, k;
scanf("%d%d", &n, &root);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(root, 0, 1);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d%d", &p, &q);
x = (p + last) % n + 1, k = (q + last) % n;
printf("%d\n", last = query(1, 1, n, starts[x], endd[x], h[x] + k));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct Node {
int data;
Node *l, *r;
void clear() {
data = INT_MAX;
l = r = nullptr;
}
};
Node *root[N];
Node node[N * 50];
int cnt, a[N], s[N], e[N], dd[N], md;
vector<int> g[N], dep[N];
Node *newNode() {
node[cnt++].clear();
return node + cnt - 1;
}
void dfs(int u, int f, int d) {
dd[u] = d;
md = max(md, d);
s[u] = ++cnt;
dep[d].push_back(u);
for (auto v : g[u]) {
if (v != f) {
dfs(v, u, d + 1);
}
}
e[u] = cnt;
}
void add(Node *pre, Node *&now, int l, int r, int loc, int data) {
Node *tNode = newNode();
if (l == r) {
tNode->data = data;
} else {
int mid = (l + r) >> 1;
if (loc <= mid) {
tNode->r = pre->r;
add(pre->l, tNode->l, l, mid, loc, data);
} else {
tNode->l = pre->l;
add(pre->r, tNode->r, mid + 1, r, loc, data);
}
tNode->data = min(tNode->l->data, tNode->r->data);
}
now = tNode;
}
int query(Node *now, int l, int r, int ll, int rr) {
if (l == ll && r == rr) {
return now->data;
}
int mid = (l + r) >> 1;
if (rr <= mid) {
return query(now->l, l, mid, ll, rr);
} else if (ll > mid) {
return query(now->r, mid + 1, r, ll, rr);
}
return min(query(now->l, l, mid, ll, mid),
query(now->r, mid + 1, r, mid + 1, rr));
}
int main() {
int n, r;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; ++i) {
root[i] = nullptr;
scanf("%d", &a[i]);
}
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(r, r, 1);
cnt = 0;
root[0] = newNode();
root[0]->l = root[0]->r = root[0];
for (int i = 1; i <= md; ++i) {
for (auto u : dep[i]) {
add(root[i] ? root[i] : root[i - 1], root[i], 1, n, s[u], a[u]);
}
}
int m, res = 0;
scanf("%d", &m);
while (m--) {
int x, k;
scanf("%d %d", &x, &k);
x = (x + res) % n + 1;
k = (k + res) % n;
res = query(root[min(md, dd[x] + k)], 1, n, s[x], e[x]);
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int Head[N], Next[N << 1], Adj[N << 1], tot = 0;
int dfn[N], Time = 0, size[N], deep[N];
int a[N], tmp[N], to[N];
int rt[N], ls[N * 30], rs[N * 30], val[N * 30], cnt = 0;
vector<int> v[N];
int D;
inline int read() {
int x = 0;
char e = getchar();
for (; e < '0' || e > '9'; e = getchar())
;
for (; e >= '0' && e <= '9'; e = getchar())
x = (x << 1) + (x << 3) + (e ^ 48);
return x;
}
inline void addedge(int u, int v) {
Next[++tot] = Head[u];
Head[u] = tot;
Adj[tot] = v;
Next[++tot] = Head[v];
Head[v] = tot;
Adj[tot] = u;
}
inline int Min(int a, int b) { return a < b ? a : b; }
inline int Max(int a, int b) { return a > b ? a : b; }
inline void dfs(int x, int f) {
size[x] = 1, dfn[x] = ++Time;
D = Max(D, deep[x]);
v[deep[x]].push_back(x);
for (int e = Head[x]; e; e = Next[e])
if (Adj[e] != f) {
deep[Adj[e]] = deep[x] + 1;
dfs(Adj[e], x);
size[x] += size[Adj[e]];
}
}
inline void build(int& root, int l, int r) {
root = ++cnt, val[root] = 1 << 30;
if (l == r) return;
build(ls[root], l, ((l + r) >> 1));
build(rs[root], ((l + r) >> 1) + 1, r);
}
inline void insert(int& root, int last, int l, int r, int x, int to) {
root = ++cnt, ls[root] = ls[last], rs[root] = rs[last],
val[root] = Min(val[last], to);
if (l == r) return;
if (x <= ((l + r) >> 1))
insert(ls[root], ls[last], l, ((l + r) >> 1), x, to);
else
insert(rs[root], rs[last], ((l + r) >> 1) + 1, r, x, to);
}
inline int query(int root, int l, int r, int L, int R) {
if (r < L || l > R) return 1 << 30;
if (L <= l && r <= R) return val[root];
return Min(query(ls[root], l, ((l + r) >> 1), L, R),
query(rs[root], ((l + r) >> 1) + 1, r, L, R));
}
int main() {
int n = read(), r = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
addedge(u, v);
}
deep[r] = 1;
dfs(r, -1);
build(rt[0], 1, n);
int cnt = 0;
for (int i = 1; i <= D; i++)
for (int j = 0; j < v[i].size(); j++) tmp[++cnt] = v[i][j];
for (int i = 1; i <= n; i++) {
insert(rt[i], rt[i - 1], 1, n, dfn[tmp[i]], a[tmp[i]]);
if (deep[tmp[i]] != deep[tmp[i + 1]]) to[deep[tmp[i]]] = i;
}
int ans = 0;
int q = read();
while (q--) {
int x = (read() + ans) % n + 1, k = (read() + ans) % n;
k = Min(deep[x] + k, D);
printf("%d\n", ans = query(rt[to[k]], 1, n, dfn[x], dfn[x] + size[x] - 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct nod {
vector<pair<int, int> > p;
} s[400005];
int n, a[100005], first, second, l[100005], r[100005], R, h[100005], p[100005],
k;
vector<int> g[100005];
void Gen(int nod, int d) {
if (h[nod]) return;
h[nod] = d;
p[++k] = nod;
l[nod] = k;
for (int i : g[nod]) Gen(i, d + 1);
r[nod] = k;
}
int Qry(int nod, int l, int r, int lt, int rt, int h) {
if (l > rt || r < lt) return 1000000005;
if (l >= lt && r <= rt) {
if (s[nod].p[0].first > h) return 1000000005;
int bl = 0, br = s[nod].p.size() - 1;
while (bl != br) {
int mid = (bl + br + 1) / 2;
if (s[nod].p[mid].first <= h)
bl = mid;
else
br = mid - 1;
}
return s[nod].p[bl].second;
}
int mid = (l + r) / 2;
return min(Qry(2 * nod, l, mid, lt, rt, h),
Qry(2 * nod + 1, mid + 1, r, lt, rt, h));
}
void GenSeg(int nod, int l, int r) {
for (int i = l; i <= r; i++) s[nod].p.push_back({h[p[i]], a[p[i]]});
sort(s[nod].p.begin(), s[nod].p.end());
for (int i = 1; i < s[nod].p.size(); i++)
s[nod].p[i].second = min(s[nod].p[i].second, s[nod].p[i - 1].second);
if (l == r) return;
int mid = (l + r) / 2;
GenSeg(2 * nod, l, mid);
GenSeg(2 * nod + 1, mid + 1, r);
}
int q, last;
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> R;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> first >> second;
g[first].push_back(second);
g[second].push_back(first);
}
Gen(R, 1);
GenSeg(1, 1, n);
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> first >> second;
first = (first + last) % n + 1;
second = (second + last) % n;
last = Qry(1, 1, n, l[first], r[first], h[first] + second);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int limite = 100005;
const int base = 100;
const int infinito = 1000000005;
void minimiza(int &a, int b) { a = min(a, b); }
int n, r;
vector<int> g[limite];
int a[limite];
int profundidad[limite];
int altura[limite];
int alcanzables[limite];
vector<int> lista[limite];
void eliminapadre(int u, int p, int prof) {
profundidad[u] = prof;
altura[u] = 1;
vector<int> &ar = g[u];
vector<int> nextar;
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
if (v != p) {
nextar.push_back(v);
eliminapadre(v, u, prof + 1);
altura[u] = max(altura[u], altura[v] + 1);
}
}
ar = nextar;
}
void obtiene(int uini, int u) {
vector<int> &lisini = lista[uini];
if (u == uini or int(lista[u].size()) == 0) {
minimiza(lisini[profundidad[u] - profundidad[uini]], a[u]);
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) obtiene(uini, ar[i]);
return;
}
vector<int> &lis = lista[u];
for (int i = 0, j = profundidad[u] - profundidad[uini]; i < int(lis.size());
i++, j++)
minimiza(lisini[j], lis[i]);
}
void genera(int u) {
alcanzables[u] = 1;
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
genera(v);
alcanzables[u] += alcanzables[v];
}
if (alcanzables[u] > base) {
alcanzables[u] = 1;
vector<int> &lis = lista[u];
lis = vector<int>(altura[u], infinito);
obtiene(u, u);
for (int i = 1; i < int(lis.size()); i++) minimiza(lis[i], lis[i - 1]);
}
}
int calcula(int u, int k) {
vector<int> &lis = lista[u];
if (int(lis.size()) > 0) return lis[min(int(lis.size()) - 1, k)];
int sol = a[u];
if (k == 0) return sol;
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) minimiza(sol, calcula(ar[i], k - 1));
return sol;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
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);
}
eliminapadre(r, 0, 0);
genera(r);
int casos;
scanf("%d", &casos);
int last = 0;
for (int cas = 0; cas < casos; cas++) {
int p, q;
scanf("%d%d", &p, &q);
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = calcula(x, k);
printf("%d\n", last);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int rt[N], h[N], nex[N << 1], to[N << 1], cur;
const int inf = 2e9;
void add_edge(int x, int y) {
to[++cur] = y;
nex[cur] = h[x];
h[x] = cur;
}
struct segmenttree {
struct node {
int lc, rc, mn;
} s[N * 40];
int tot;
segmenttree() {}
void pushup(int rt) {
int lm = s[rt].lc ? s[s[rt].lc].mn : inf;
int rm = s[rt].rc ? s[s[rt].rc].mn : inf;
s[rt].mn = min(lm, rm);
}
void update(int &rt, int l, int r, int pos, int val) {
if (!rt) rt = ++tot;
if (l == r) {
s[rt].mn = val;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
update(s[rt].lc, l, mid, pos, val);
else
update(s[rt].rc, mid + 1, r, pos, val);
pushup(rt);
}
int query(int rt, int l, int r, int L, int R) {
if (!rt) return inf;
if (L <= l && R >= r) return s[rt].mn;
int mid = l + r >> 1, ret = inf;
if (L <= mid) ret = query(s[rt].lc, l, mid, L, R);
if (R > mid) ret = min(ret, query(s[rt].rc, mid + 1, r, L, R));
return ret;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int rt = ++tot;
s[rt].mn = min(s[x].mn, s[y].mn);
s[rt].lc = merge(s[x].lc, s[y].lc);
s[rt].rc = merge(s[x].rc, s[y].rc);
return rt;
}
} tr;
int n, treert, val[N], dep[N];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
tr.update(rt[u], 1, n, dep[u], val[u]);
for (int i = h[u]; i; i = nex[i]) {
int v = to[i];
if (v == fa) continue;
dfs(v, u);
rt[u] = tr.merge(rt[u], rt[v]);
}
}
int main() {
scanf("%d%d", &n, &treert);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
int q;
dfs(treert, 0);
scanf("%d", &q);
int lans = 0;
for (int i = 1; i <= q; i++) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + lans) % n + 1;
k = (k + lans) % n;
lans = tr.query(rt[x], 1, n, dep[x], min(dep[x] + k, n));
printf("%d\n", lans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10;
const int MOD = (int)1e9 + 7;
struct edge {
int to, nxt;
} ed[MAXN * 2];
int head[MAXN], cnt;
void addedge(int u, int v) {
ed[cnt].to = v;
ed[cnt].nxt = head[u];
head[u] = cnt++;
}
int dis[MAXN], d[MAXN];
int a[MAXN], dfsn[MAXN], dfx, frm[MAXN], to[MAXN], ra[MAXN];
vector<long long> ve;
void dfs(int u) {
dfsn[u] = ++dfx;
frm[u] = dfsn[u];
d[dfx] = dis[u];
ra[dfx] = a[u];
for (int i = head[u]; i != -1; i = ed[i].nxt) {
int v = ed[i].to;
if (!dis[v]) {
dis[v] = dis[u] + 1;
dfs(v);
}
}
to[u] = dfx;
}
int mi[325][MAXN];
int belong[MAXN], L[MAXN], R[MAXN];
void up(int &x, int y) {
if (y == 0) return;
if (x == 0 || x > y) x = y;
}
int query(int l, int r, int x) {
int re = 0;
if (belong[l] == belong[r]) {
for (int i = l; i <= r; i++) {
if (d[i] <= x) up(re, ra[i]);
}
} else {
for (int i = l; i <= R[belong[l]]; i++) {
if (d[i] <= x) up(re, ra[i]);
}
for (int i = L[belong[r]]; i <= r; i++) {
if (d[i] <= x) up(re, ra[i]);
}
for (int i = belong[l] + 1; i < belong[r]; i++) {
up(re, mi[i][x]);
}
}
return re;
}
int main() {
memset(head, -1, sizeof(head));
int n, rt;
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
dis[rt] = 1;
dfs(rt);
int len = (int)sqrt(n) + 1, num = (n + len - 1) / len;
for (int i = 1; i <= n; i++) {
belong[i] = (i + len - 1) / len;
up(mi[belong[i]][d[i]], ra[i]);
}
for (int i = 1; i <= num; i++)
L[i] = (i - 1) * len + 1, R[i] = min(i * len, n);
for (int i = 1; i <= num; i++)
for (int j = 2; j <= n; j++) up(mi[i][j], mi[i][j - 1]);
int q;
scanf("%d", &q);
int lst = 0;
while (q--) {
int k, x;
scanf("%d%d", &x, &k);
k = (k + lst) % n;
x = (x + lst) % n + 1;
printf("%d\n", lst = query(frm[x], to[x], min(n, k + dis[x])));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 40 * N;
int n, rt, a[N], d[N], m, x, y, tin[N], tout[N], timer, sz, l[M], r[M], t[M],
root[N];
vector<int> g[N], q[N];
inline int vcopy(int v) {
sz++;
l[sz] = l[v];
r[sz] = r[v];
t[sz] = t[v];
return sz;
}
void dfs(int v, int pr = -1, int depth = 0) {
tin[v] = ++timer;
d[v] = depth;
q[depth].push_back(v);
for (auto to : g[v]) {
if (to != pr) {
dfs(to, v, depth + 1);
}
}
tout[v] = timer;
}
void update(int v, int l, int r, int pos, int val) {
if (l == r) {
t[v] = val;
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
::l[v] = vcopy(::l[v]);
update(::l[v], l, mid, pos, val);
} else {
::r[v] = vcopy(::r[v]);
update(::r[v], mid + 1, r, pos, val);
}
t[v] = min(t[::l[v]], t[::r[v]]);
}
int get(int v, int l, int r, int tl, int tr) {
if (!v || l > r || l > tr || tl > r) {
return 2e9;
}
if (tl <= l && r <= tr) {
return t[v];
}
int mid = (r + l) >> 1;
return min(get(::l[v], l, mid, tl, tr), get(::r[v], mid + 1, r, tl, tr));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> rt;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(rt);
t[0] = 2e9;
for (int i = 0; i < n; i++) {
root[i + 1] = vcopy(root[i]);
for (auto it : q[i]) {
update(root[i + 1], 1, n, tin[it], a[it]);
}
}
cin >> m;
int last = 0;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
x = (x + last) % n + 1, y = (y + last) % n + 1;
cout << (last = get(root[min(n, d[x] + y)], 1, n, tin[x], tout[x])) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const int maxn = (int)1e5 + 5;
const int logn = 21;
const int sqrtn = 3e2 + 5;
int n, root, val[maxn], depth[maxn];
int be[maxn], en[maxn], trw, ree[maxn];
vector<int> minn[4 * maxn], road[maxn];
vector<pair<int, int> > seg[4 * maxn];
vector<pair<int, int> >::iterator it;
void dfs(int cur, int pr) {
be[cur] = ++trw;
ree[trw] = cur;
for (int i = 0; i < road[cur].size(); i++)
if (road[cur][i] != pr) {
depth[road[cur][i]] = depth[cur] + 1;
dfs(road[cur][i], cur);
}
en[cur] = trw;
}
void init(int cur, int l, int r) {
if (l == r) {
int tmp = ree[l];
seg[cur].push_back(make_pair(depth[tmp], val[tmp]));
minn[cur].push_back(val[tmp]);
return;
}
init(cur * 2, l, (l / 2 + r / 2 + (l % 2 && r % 2)));
init(cur * 2 + 1, (l / 2 + r / 2 + (l % 2 && r % 2)) + 1, r);
int s1 = 0, s2 = 0;
while (s1 < seg[cur * 2].size() || s2 < seg[cur * 2 + 1].size()) {
if (s2 == seg[cur * 2 + 1].size()) {
seg[cur].push_back(seg[cur * 2][s1]);
minn[cur].push_back(seg[cur * 2][s1++].second);
continue;
}
if (s1 == seg[cur * 2].size()) {
seg[cur].push_back(seg[cur * 2 + 1][s2]);
minn[cur].push_back(seg[cur * 2 + 1][s2++].second);
continue;
}
if (seg[2 * cur][s1] < seg[2 * cur + 1][s2]) {
seg[cur].push_back(seg[cur * 2][s1]);
minn[cur].push_back(seg[cur * 2][s1++].second);
continue;
}
seg[cur].push_back(seg[cur * 2 + 1][s2]);
minn[cur].push_back(seg[cur * 2 + 1][s2++].second);
}
for (int i = 1; i < minn[cur].size(); i++)
minn[cur][i] = min(minn[cur][i], minn[cur][i - 1]);
}
int find(int cur, int l, int r, int tg_l, int tg_r, int maxx) {
if (l > tg_r || r < tg_l) return INF;
if (l >= tg_l && r <= tg_r) {
it = lower_bound(seg[cur].begin(), seg[cur].end(), make_pair(maxx + 1, 0));
if (it == seg[cur].begin()) return INF;
return minn[cur][it - seg[cur].begin() - 1];
}
int a =
find(cur * 2, l, (l / 2 + r / 2 + (l % 2 && r % 2)), tg_l, tg_r, maxx);
int b = find(cur * 2 + 1, (l / 2 + r / 2 + (l % 2 && r % 2)) + 1, r, tg_l,
tg_r, maxx);
return min(a, b);
}
int main() {
cin >> n >> root;
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
int a, b;
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
road[a].push_back(b);
road[b].push_back(a);
}
depth[root] = 1;
dfs(root, 0);
init(1, 1, n);
int que, last = 0, x, k;
cin >> que;
while (que--) {
scanf("%d %d", &x, &k);
x = ((x + last) % n) + 1;
k = (k + last) % n;
last = find(1, 1, n, be[x], en[x], k + depth[x]);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast,no-stack-protector")
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
template <typename T>
vector<T> &operator<<(vector<T> &__container, T x) {
__container.push_back(x);
return __container;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &__container) {
for (T _ : __container) out << _ << ' ';
return out;
}
const int MAXN = 2e5 + 7;
int n, r, dep[MAXN], q, w[MAXN];
vector<int> G[MAXN];
struct SegmentTree {
int root[MAXN], ls[MAXN << 5], rs[MAXN << 5], minn[MAXN << 5], tot;
void modify(int l, int r, int pos, int x, int &rt) {
rt = ++tot;
minn[rt] = x;
if (l + 1 == r) return;
int mid = (l + r) >> 1;
if (pos < mid)
modify(l, mid, pos, x, ls[rt]);
else
modify(mid, r, pos, x, rs[rt]);
}
int merge(int u, int v, int l, int r) {
if (!u or !v) return u ^ v;
if (l + 1 == r) {
int rt = ++tot;
minn[rt] = min(minn[u], minn[v]);
return rt;
}
int rt = ++tot;
minn[rt] = 0x3f3f3f3f;
int mid = (l + r) >> 1;
ls[rt] = merge(ls[u], ls[v], l, mid);
rs[rt] = merge(rs[u], rs[v], mid, r);
if (ls[rt])
((minn[rt]) = (minn[rt]) < (minn[ls[rt]]) ? (minn[rt]) : (minn[ls[rt]]));
if (rs[rt])
((minn[rt]) = (minn[rt]) < (minn[rs[rt]]) ? (minn[rt]) : (minn[rs[rt]]));
return rt;
}
int qmin(int rt, int l, int r, int L, int R) {
if (L >= r or l >= R or !rt) return 0x3f3f3f3f;
if (L <= l and r <= R) return minn[rt];
int mid = (l + r) >> 1;
return min(qmin(ls[rt], l, mid, L, R), qmin(rs[rt], mid, r, L, R));
}
} ST;
void dfs(int u, int par) {
dep[u] = dep[par] + 1;
ST.modify(1, n + 1, dep[u], w[u], ST.root[u]);
for (int v : G[u]) {
if (v == par) continue;
dfs(v, u);
ST.root[u] = ST.merge(ST.root[u], ST.root[v], 1, n + 1);
}
}
void solve() {
scanf("%d", &n);
scanf("%d", &r);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
G[u] << v;
G[v] << u;
}
dfs(r, 0);
scanf("%d", &q);
int lastans = 0;
while (q--) {
int x, k;
scanf("%d", &x);
scanf("%d", &k);
x = (x + lastans) % n + 1;
k = (k + lastans) % n;
((k) = (k) < (n - dep[x]) ? (k) : (n - dep[x]));
printf("%d\n",
lastans = ST.qmin(ST.root[x], 1, n + 1, dep[x], dep[x] + k + 1));
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 100000 + 5;
const int inf = numeric_limits<int>::max();
struct input {
input() : visited(false) {}
int key;
bool visited;
};
input vertices[MAX_SIZE];
vector<vector<pair<int, int> > > values(4 * MAX_SIZE);
vector<vector<int> > mins(4 * MAX_SIZE);
int level[MAX_SIZE], tree[MAX_SIZE], in[MAX_SIZE], out[MAX_SIZE];
int timer;
vector<vector<int> > edges(MAX_SIZE);
void dfs(int node, int parent, int root_dist) {
if (vertices[node].visited) return;
vertices[node].visited = true;
timer++;
in[node] = timer;
level[timer] = root_dist;
tree[timer] = vertices[node].key;
for (int i = 0; i < edges[node].size(); i++)
if (edges[node][i] != parent) dfs(edges[node].at(i), node, root_dist + 1);
out[node] = timer;
}
void buildTree(int node, int left, int right) {
if (left == right) {
values[node].emplace_back(level[left], tree[left]);
mins[node].push_back(tree[left]);
return;
}
int mid = (left + right) / 2;
buildTree(node * 2, left, mid);
buildTree(node * 2 + 1, mid + 1, right);
values[node].resize(values[node * 2].size() + values[node * 2 + 1].size());
merge(values[node * 2].begin(), values[node * 2].end(),
values[node * 2 + 1].begin(), values[node * 2 + 1].end(),
values[node].begin());
int min = values[node].front().second;
for (auto i : values[node]) {
min = i.second < min ? i.second : min;
mins[node].push_back(min);
}
}
int query(int node, int left, int right, int i, int j, int x) {
if (i > right || j < left) return inf;
if (i <= left && j >= right) {
int idx = upper_bound(values[node].begin(), values[node].end(),
pair<int, int>(x, inf)) -
values[node].begin();
if (!idx) return inf;
idx--;
return mins[node][idx];
}
int mid = (left + right) / 2;
return min(query(node * 2, left, mid, i, j, x),
query(node * 2 + 1, mid + 1, right, i, j, x));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int vertex_count, root_index;
cin >> vertex_count >> root_index;
for (int i = 1; i <= vertex_count; i++) cin >> vertices[i].key;
for (int i = 1; i < vertex_count; i++) {
int from, to;
cin >> from >> to;
edges[to].push_back(from);
edges[from].push_back(to);
}
dfs(root_index, 0, 0);
buildTree(1, 1, vertex_count);
int query_count, last = 0;
cin >> query_count;
for (int i = 0; i < query_count; i++) {
int p, q;
cin >> p >> q;
int x = ((p + last) % vertex_count) + 1;
int k = (q + last) % vertex_count;
last = query(1, 1, vertex_count, in[x], out[x], level[in[x]] + k);
cout << last << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(time(0));
vector<long long> con[100010], st(100010, 0), en(100010, 0), v(100010, 0),
val(100010, 0), d(100010, 0);
pair<long long, long long> t[20][100010];
long long cur = 0;
void dfs(long long node, long long par, long long dep) {
st[node] = ++cur;
d[cur] = dep;
for (auto i : con[node])
if (i != par) dfs(i, node, dep + 1);
en[node] = cur;
}
void build(long long c, long long l, long long r) {
if (l == r)
t[c][l] = {d[l], val[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (t[c + 1][i].first < t[c + 1][j].first)
t[c][k++] = t[c + 1][i++];
else
t[c][k++] = t[c + 1][j++];
}
while (i <= mid) t[c][k++] = t[c + 1][i++];
while (j <= r) t[c][k++] = t[c + 1][j++];
for (i = l + 1; i <= r; i++)
t[c][i].second = min(t[c][i].second, t[c][i - 1].second);
}
}
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r < l1 || r1 < l) return 1000000007;
if (l1 <= l && r <= r1) {
pair<long long, long long> temp = {k, 1000000007};
long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - t[c];
if (w == l) return 1000000007;
return t[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, r, m, l, x, k;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) cin >> v[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(r, -1, 0);
for (long long i = 1; i <= n; i++) val[st[i]] = v[i];
build(1, 1, cur);
cin >> m;
l = 0;
while (m--) {
cin >> x >> k;
x = (x + l) % n + 1;
k = (k + l) % n;
l = query(1, 1, cur, st[x], en[x], k + d[st[x]]);
cout << l << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, r, q, a[100005];
int dep[100005], dfn[100005], size[100005], maxdep, total, dfntotal;
int head[100005], cnt;
int root[100005];
struct data {
int next, to;
data(int next = 0, int to = 0) : next(next), to(to) {}
} edge[100005 << 1];
struct segment {
int l, r, v;
segment(int l = 0, int r = 0, int v = 0x3f3f3f3f) : l(l), r(r), v(v) {}
} t[100005 << 5];
int read() {
char c = getchar();
int x = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x;
}
void connect(int u, int v) {
edge[++cnt] = data(head[u], v);
head[u] = cnt;
}
void append(int l, int r, int p, int c, int& u, int v) {
t[u = ++total] = t[v];
t[u].v = min(t[u].v, c);
if (l == r) return;
int mid = (l + r) >> 1;
if (p <= mid)
append(l, mid, p, c, t[u].l, t[v].l);
else
append(mid + 1, r, p, c, t[u].r, t[v].r);
}
int query(int l, int r, int p, int q, int u) {
if (!u) return 0x3f3f3f3f;
if (p <= l && r <= q) return t[u].v;
int mid = (l + r) >> 1, res = 0x3f3f3f3f;
if (p <= mid) res = min(res, query(l, mid, p, q, t[u].l));
if (q > mid) res = min(res, query(mid + 1, r, p, q, t[u].r));
return res;
}
void DFS(int u, int pre) {
dfn[u] = ++dfntotal;
dep[u] = dep[pre] + 1;
size[u] = 1;
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == pre) continue;
DFS(v, u);
size[u] += size[v];
}
}
void BFS() {
queue<int> q;
q.push(r);
int last = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
append(1, n, dfn[u], a[u], root[dep[u]], last);
maxdep = max(maxdep, dep[u]);
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (dep[v] < dep[u]) continue;
q.push(v);
}
last = root[dep[u]];
}
}
int main() {
n = read();
r = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
connect(u, v);
connect(v, u);
}
DFS(r, 0);
BFS();
int last = 0;
q = read();
while (q--) {
int x = (read() + last) % n + 1, k = (read() + last) % n;
printf("%d\n", last = query(1, n, dfn[x], dfn[x] + size[x] - 1,
root[min(dep[x] + k, maxdep)]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int n, rt, q, a[N], root[N], id, dep[N];
vector<int> es[N];
struct Tree {
int l, r, v;
Tree() {
l = r = 0;
v = INF;
}
} tr[N * 100];
int add(int x, int l, int r, int d, int v) {
int now = ++id;
tr[now].v = min(v, tr[x].v);
if (l == r) return now;
int mid = (l + r) / 2;
if (d <= mid)
tr[now].l = add(tr[now].l, l, mid, d, v);
else
tr[now].r = add(tr[now].r, mid + 1, r, d, v);
return now;
}
int merge(int x, int y, int l, int r) {
if (x == 0 || y == 0) return x | y;
int now = ++id, mid = (l + r) / 2;
tr[now].v = min(tr[x].v, tr[y].v);
tr[now].l = merge(tr[x].l, tr[y].l, l, mid);
tr[now].r = merge(tr[x].r, tr[y].r, mid + 1, r);
return now;
}
int query(int x, int l, int r, int le, int ri) {
if (le <= l && ri >= r) return tr[x].v;
int mid = (l + r) / 2, ret = INF;
if (le <= mid) ret = min(ret, query(tr[x].l, l, mid, le, ri));
if (ri > mid) ret = min(ret, query(tr[x].r, mid + 1, r, le, ri));
return ret;
}
void dfs(int u, int fa) {
root[u] = add(root[u], 1, n, dep[u], a[u]);
for (auto v : es[u])
if (v != fa) {
dep[v] = dep[u] + 1;
dfs(v, u);
root[u] = merge(root[u], root[v], 1, n);
}
}
void solve() {
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
es[u].push_back(v);
es[v].push_back(u);
}
dep[rt] = 1;
dfs(rt, 0);
scanf("%d", &q);
int last = 0;
for (int _ = 0; _ < q; _++) {
int x, y;
scanf("%d%d", &x, &y);
x = (x + last) % n + 1;
y = (y + last) % n;
int le = dep[x], ri = min(dep[x] + y, n);
printf("%d\n", last = query(root[x], 1, n, le, ri));
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int ans, n, r, q, v[N], de[N], st[N], ed[N], dfsclock;
int tot, a[N << 1], ne[N << 1], fi[N];
const int xb = N - 5;
vector<pair<int, int>> f[N << 1];
inline void add(int x, int y) {
a[++tot] = y;
ne[tot] = fi[x];
fi[x] = tot;
}
inline void dfs(int x, int fa) {
st[x] = ++dfsclock;
de[x] = de[fa] + 1;
for (int i = xb + dfsclock; i; i >>= 1)
f[i].push_back(make_pair(de[x], v[x]));
for (int i = fi[x]; i; i = ne[i])
if (a[i] != fa) dfs(a[i], x);
ed[x] = dfsclock;
}
inline int calc(vector<pair<int, int>>& c, int de) {
if (!c.size() || c[0].first > de) return 1e9;
return (upper_bound(c.begin(), c.end(), make_pair(de + 1, -1)) - 1)->second;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", v + i);
for (int i = 1, x, y; i < n; ++i) scanf("%d%d", &x, &y), add(x, y), add(y, x);
dfs(r, 0);
for (int i = 1; i <= xb + n; ++i)
if (f[i].size()) {
sort(f[i].begin(), f[i].end());
for (int j = 1; j < (int)f[i].size(); ++j)
f[i][j].second = min(f[i][j].second, f[i][j - 1].second);
}
scanf("%d", &q);
for (int i = 1, x, y; i <= q; ++i) {
scanf("%d%d", &x, &y);
x = (x + ans) % n + 1;
y = (y + ans) % n;
int delim = de[x] + y;
ans = 1e9;
for (int l = xb + st[x] - 1, r = xb + ed[x] + 1; l ^ r ^ 1;
l >>= 1, r >>= 1) {
if (~l & 1) ans = min(ans, calc(f[l ^ 1], delim));
if (r & 1) ans = min(ans, calc(f[r ^ 1], delim));
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[100005];
vector<int> adj[100005];
vector<pair<int, int> > tree[4 * 100005];
vector<int> PrefixMin[4 * 100005];
int Time = 0;
int St[100005];
int En[100005];
int P[100005];
int D[100005];
void dfs(int u, int p) {
St[u] = ++Time;
D[u] = D[p] + 1;
P[Time] = u;
for (int i = 0; i < adj[u].size(); i++) {
int w = adj[u][i];
if (w != p) dfs(w, u);
}
En[u] = Time;
}
void build(int node, int lo, int hi) {
if (lo == hi) {
tree[node].push_back(make_pair(D[P[lo]], A[P[lo]]));
PrefixMin[node].push_back(INT_MAX);
PrefixMin[node].push_back(A[P[lo]]);
return;
}
build(2 * node, lo, (lo + hi) / 2);
build(2 * node + 1, (lo + hi) / 2 + 1, hi);
merge(tree[2 * node].begin(), tree[2 * node].end(),
tree[2 * node + 1].begin(), tree[2 * node + 1].end(),
back_inserter(tree[node]));
int MIN = INT_MAX;
PrefixMin[node].push_back(MIN);
for (int i = 0; i < tree[node].size(); i++)
PrefixMin[node].push_back(MIN = min(MIN, tree[node][i].second));
}
int query(int node, int lo, int hi, int i, int j, int val) {
if (hi < i || lo > j) return INT_MAX;
if (i <= lo && hi <= j) {
int pos = upper_bound(tree[node].begin(), tree[node].end(),
make_pair(val, INT_MAX)) -
tree[node].begin();
return PrefixMin[node][pos];
}
return min(query(2 * node, lo, (lo + hi) / 2, i, j, val),
query(2 * node + 1, (lo + hi) / 2 + 1, hi, i, j, val));
}
int main() {
int n, Root;
scanf("%d %d", &n, &Root);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(Root, 0);
build(1, 1, n);
int q;
scanf("%d", &q);
int Last = 0;
for (int i = 1; i <= q; i++) {
int p, x;
scanf("%d %d", &p, &x);
p = (p + Last) % n + 1;
x = (x + Last) % n;
Last = query(1, 1, n, St[p], En[p], D[p] + x);
printf("%d\n", Last);
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(time(0));
vector<long long> v(100010), val(100010), con[100010], st(100010, 0),
en(100010, 0), d(100010, 0);
pair<long long, long long> t[20][100010];
long long cur = 0;
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r1 < l || l1 > r) return 1000000007;
if (l >= l1 && r <= r1) {
pair<long long, long long> temp = {k, 1000000007};
long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - t[c];
if (w == l) return 1000000007;
return t[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
void dfs(long long node, long long par, long long dep) {
st[node] = ++cur;
d[st[node]] = dep;
for (auto i : con[node]) {
if (i != par) dfs(i, node, dep + 1);
}
en[node] = cur;
}
void build(long long c, long long l, long long r) {
if (l == r)
t[c][l] = {d[l], val[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (t[c + 1][i].first < t[c + 1][j].first)
t[c][k++] = t[c + 1][i++];
else
t[c][k++] = t[c + 1][j++];
}
while (i <= mid) t[c][k++] = t[c + 1][i++];
while (j <= r) t[c][k++] = t[c + 1][j++];
for (i = l + 1; i <= r; i++)
t[c][i].second = min(t[c][i].second, t[c][i - 1].second);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, r, m, l, x, k;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) cin >> v[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(r, -1, 0);
for (long long i = 1; i <= n; i++) val[st[i]] = v[i];
build(1, 1, cur);
cin >> m;
l = 0;
while (m--) {
cin >> x >> k;
x = (x + l) % n + 1;
k = (k + l) % n;
l = query(1, 1, cur, st[x], en[x], k + d[st[x]]);
cout << l << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18L;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 5;
const int N = 2e7;
const int Mod = 1e9 + 7;
vector<int> g[maxn];
int dep[maxn], root[maxn], n, a[maxn], r, m;
int mn[N], ls[N], rs[N], cnt;
int newnode() {
++cnt;
ls[cnt] = rs[cnt] = 0;
return cnt;
}
void Insert(int &x, int L, int R, int pos, int v) {
x = newnode();
mn[x] = v;
if (L == R) return;
int mid = (L + R) >> 1;
if (mid >= pos)
Insert(ls[x], L, mid, pos, v);
else
Insert(rs[x], mid + 1, R, pos, v);
}
int Merge(int x, int y, int L, int R) {
if (!x) return y;
if (!y) return x;
int now = newnode();
mn[now] = min(mn[x], mn[y]);
if (L == R) return now;
int mid = (L + R) >> 1;
ls[now] = Merge(ls[x], ls[y], L, mid);
rs[now] = Merge(rs[x], rs[y], mid + 1, R);
return now;
}
int query(int x, int L, int R, int pos) {
if (R <= pos) return mn[x];
if (!x) return inf;
int mid = (L + R) >> 1;
if (mid >= pos) return query(ls[x], L, mid, pos);
return min(query(ls[x], L, mid, pos), query(rs[x], mid + 1, R, pos));
}
void dfs(int u, int fa) {
Insert(root[u], 1, n, dep[u], a[u]);
for (int i = 0; i < ((int)(g[u]).size()); i++) {
int v = g[u][i];
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
root[u] = Merge(root[u], root[v], 1, n);
}
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
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);
}
dep[r] = 1;
mn[0] = inf;
dfs(r, r);
scanf("%d", &m);
int ans = 0;
while (m--) {
int p, q;
scanf("%d%d", &p, &q);
p = (p + ans) % n + 1;
q = (q + ans) % n;
ans = query(root[p], 1, n, min(dep[p] + q, n));
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
struct Tree {
int Min;
Tree *lt, *rt;
Tree() : lt(nullptr), rt(nullptr) { Min = 1e9 + 7; }
};
vector<Tree*> root;
int id[N];
vector<int> G[N];
int dep[N];
int a[N];
int n;
void init() {
root.clear();
for (int i = 0; i < N; i++) G[i].clear();
}
Tree* new_node() { return new Tree; }
void push_up(Tree* r) {
int lval = (r->lt == nullptr ? 1e9 + 7 : r->lt->Min);
int rval = (r->rt == nullptr ? 1e9 + 7 : r->rt->Min);
r->Min = min(lval, rval);
}
void update(Tree* rr, int l, int r, int x, int val) {
if (l == r) {
rr->Min = min(val, rr->Min);
return;
}
int mid = (l + r) / 2;
if (x <= mid) {
if (rr->lt == nullptr) rr->lt = new_node();
update(rr->lt, l, mid, x, val);
} else {
if (rr->rt == nullptr) rr->rt = new_node();
update(rr->rt, mid + 1, r, x, val);
}
push_up(rr);
}
Tree* merge(Tree* lhs, Tree* rhs) {
if (lhs == nullptr && rhs == nullptr)
return nullptr;
else if (rhs == nullptr)
return lhs;
else if (lhs == nullptr)
return rhs;
else {
Tree* cur_r = new_node();
cur_r->Min = min(rhs->Min, lhs->Min);
cur_r->lt = merge(lhs->lt, rhs->lt);
cur_r->rt = merge(lhs->rt, rhs->rt);
return cur_r;
}
}
void dfs(int u, int fa, int d) {
Tree* rt = new_node();
root.push_back(rt);
id[u] = root.size() - 1;
dep[u] = d;
update(rt, 1, n, dep[u], a[u]);
for (auto v : G[u]) {
if (v == fa) continue;
dfs(v, u, d + 1);
root[id[u]] = merge(root[id[u]], root[id[v]]);
}
}
int query(Tree* rr, int l, int r, int ql, int qr) {
if (rr == nullptr) return 1e9 + 8;
if (l == ql && r == qr) return rr->Min;
int mid = (l + r) / 2;
if (qr <= mid)
return query(rr->lt, l, mid, ql, qr);
else if (ql > mid)
return query(rr->rt, mid + 1, r, ql, qr);
else
return min(query(rr->lt, l, mid, ql, mid),
query(rr->rt, mid + 1, r, mid + 1, qr));
}
void debug(Tree* rr, int l, int r) {
if (rr == nullptr) return;
if (l == r) {
cout << "dep : " << r << " " << rr->Min;
return;
}
int mid = (l + r) / 2;
debug(rr->lt, l, mid);
debug(rr->rt, mid + 1, r);
}
int main() {
int rr;
scanf("%d%d", &n, &rr);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
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(rr, rr, 1);
int m;
scanf("%d", &m);
int ans = 0;
for (int i = 0; i < m; i++) {
int p, q;
scanf("%d%d", &p, &q);
int x = (p + ans) % n;
x++;
int k = (q + ans) % n;
ans = query(root[id[x]], 1, n, dep[x], min(dep[x] + k, n));
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int maxn = 1 << 17;
int n, r;
struct Segtree {
int ls[maxn << 7], rs[maxn << 7], nds;
int dt[maxn << 7];
void inline add(int a, int x, int &now, int nl = 1, int nr = n) {
if (!now) now = ++nds, dt[now] = Inf;
dt[now] = min(dt[now], x);
if (nl == nr) return;
int m = (nl + nr) >> 1;
if (m >= a)
add(a, x, ls[now], nl, m);
else
add(a, x, rs[now], m + 1, nr);
}
int inline get(int l, int r, int now, int nl = 1, int nr = n) {
if (!now || nl > r || nr < l) return Inf;
if (nl >= l && nr <= r) return dt[now];
int m = (nl + nr) >> 1;
return min(get(l, r, ls[now], nl, m), get(l, r, rs[now], m + 1, nr));
}
} seg;
struct ZkwSeg {
int rt[maxn << 1];
void inline add(int a, int t, int x) {
for (a += maxn; a; a >>= 1) seg.add(t, x, rt[a]);
}
int inline get(int l, int r, int L, int R) {
int res = Inf;
for (l += maxn, r += maxn + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, seg.get(L, R, rt[l++]));
if (r & 1) res = min(res, seg.get(L, R, rt[--r]));
}
return res;
}
} t;
int a[maxn];
vector<int> nei[maxn];
int dep[maxn];
int bg[maxn], en[maxn], tmc;
void dfs(int now, int lst, int dept) {
dep[now] = dept;
bg[now] = ++tmc;
t.add(dept, bg[now], a[now]);
for (auto &to : (nei[now])) {
if (to == lst) continue;
dfs(to, now, dept + 1);
}
en[now] = tmc;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= (n); ++i) scanf("%d", a + i);
for (int i = 1; i <= (n - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
nei[u].push_back(v);
nei[v].push_back(u);
}
dfs(r, 0, 0);
int q;
scanf("%d", &q);
int lst = 0;
while (q--) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + lst) % n + 1;
k = (k + lst) % n;
printf("%d\n", lst = t.get(dep[x], min(dep[x] + k, n), bg[x], en[x]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int M = 1 << 17;
int n, r, c, m, last;
int a[N];
vector<int> G[N];
int d[N];
int pre[N];
int post[N];
struct pm {
vector<int> depth, val;
int ask(int d) {
auto it = upper_bound((depth).begin(), (depth).end(), d);
if (it == depth.begin()) return 1000000007;
return val[it - depth.begin() - 1];
}
void merge(pm &x) {
vector<int> ndepth, nval;
int i = 0, j = 0;
while (i < depth.size() || j < x.depth.size()) {
if (i == depth.size()) {
ndepth.push_back(x.depth[j]);
nval.push_back(x.val[j++]);
} else if (j == x.depth.size()) {
ndepth.push_back(depth[i]);
nval.push_back(val[i++]);
} else if (depth[i] == x.depth[j]) {
ndepth.push_back(depth[i]);
nval.push_back(min(val[i++], x.val[j++]));
} else if (depth[i] < x.depth[j]) {
ndepth.push_back(depth[i]);
nval.push_back(val[i++]);
} else if (x.depth[j] < depth[i]) {
ndepth.push_back(x.depth[j]);
nval.push_back(x.val[j++]);
}
}
depth = ndepth;
val = nval;
for (int i = 1; i < val.size(); ++i) {
val[i] = min(val[i], val[i - 1]);
}
}
};
pm tree[2 * M];
int query(int a, int b, int d, int v = 1, int l = 0, int r = M - 1) {
if (a > b || l > b || a > r) return 1000000007;
if (a <= l && r <= b) return tree[v].ask(d);
return min(query(a, b, d, 2 * v, l, (l + r) / 2),
query(a, b, d, 2 * v + 1, (l + r) / 2 + 1, r));
}
void dfs(int v) {
pre[v] = ++c;
for (auto it : G[v]) {
if (!pre[it]) {
d[it] = d[v] + 1;
dfs(it);
}
}
post[v] = c;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> r;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
dfs(r);
for (int i = 1; i <= n; ++i) {
tree[pre[i] + M].val.push_back(a[i]);
tree[pre[i] + M].depth.push_back(d[i]);
}
for (int i = M - 1; i >= 1; --i) {
tree[i] = tree[2 * i];
tree[i].merge(tree[2 * i + 1]);
}
cin >> m;
while (m--) {
int p, q, x, k;
cin >> p >> q;
x = (p + last) % n + 1;
k = (q + last) % n;
cout << (last = query(pre[x], post[x], d[x] + k)) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Sgt {
int ls, rs, min;
} Segt[(100009) << 6];
struct Edge {
int to, next;
} edge[(100009) << 1];
int n, m, sgt_num, ans, lastans, u, v, p, q, r;
int a[(100009)], Root[(100009)], Depth[(100009)];
int head[(100009)], num_edge;
void add(int u, int v) {
edge[++num_edge].to = v;
edge[num_edge].next = head[u];
head[u] = num_edge;
}
void Update(int &now, int l, int r, int x, int v) {
if (!now) now = ++sgt_num;
Segt[now].min = 2e9;
if (l == r) {
Segt[now].min = v;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
Update(Segt[now].ls, l, mid, x, v);
else
Update(Segt[now].rs, mid + 1, r, x, v);
int ls = Segt[now].ls, rs = Segt[now].rs;
Segt[now].min = min(Segt[ls].min, Segt[rs].min);
}
int Merge(int x, int y) {
if (!x || !y) return x | y;
int tmp = ++sgt_num;
Segt[tmp].ls = Merge(Segt[x].ls, Segt[y].ls);
Segt[tmp].rs = Merge(Segt[x].rs, Segt[y].rs);
Segt[tmp].min = min(Segt[x].min, Segt[y].min);
return tmp;
}
void DFS(int x, int fa) {
Depth[x] = Depth[fa] + 1;
Update(Root[x], 1, n, Depth[x], a[x]);
for (int i = head[x]; i; i = edge[i].next)
if (edge[i].to != fa) {
DFS(edge[i].to, x);
Root[x] = Merge(Root[x], Root[edge[i].to]);
}
}
int Query(int now, int l, int r, int l1, int r1) {
if (l > r1 || r < l1) return 2e9;
if (l1 <= l && r <= r1) return Segt[now].min;
int mid = (l + r) >> 1, ls = Segt[now].ls, rs = Segt[now].rs;
return min(Query(ls, l, mid, l1, r1), Query(rs, mid + 1, r, l1, r1));
}
int main() {
Segt[0].min = 2e9;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
DFS(r, 0);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &p, &q);
p = (p + lastans) % n + 1;
q = (q + lastans) % n;
ans = Query(Root[p], 1, n, Depth[p], Depth[p] + q);
printf("%d\n", ans);
lastans = ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int l[N], d[N], sz[N], a[N];
vector<int> adj[N], st[2][4 * N];
int v1[N], v2[N];
int n, r, q;
int T = 0;
int dfs(int x, int p, int h) {
l[x] = T++;
d[x] = h;
sz[x] = 1;
v1[l[x]] = d[x];
v2[l[x]] = a[x];
for (int v : adj[x])
if (v != p) sz[x] += dfs(v, x, h + 1);
return sz[x];
}
void build(int nx = 1, int l = 0, int r = n - 1) {
if (l == r) {
st[0][nx].push_back(v1[r]);
st[1][nx].push_back(v2[r]);
return;
}
int mid = (l + r) / 2;
build(2 * nx, l, mid);
build(2 * nx + 1, mid + 1, r);
int ln = st[0][2 * nx].size();
int rn = st[0][2 * nx + 1].size();
int i = 0, j = 0;
int mini = 1e9;
while (i < ln and j < rn) {
if (st[0][2 * nx][i] < st[0][2 * nx + 1][j]) {
mini = min(mini, st[1][2 * nx][i]);
st[0][nx].push_back(st[0][2 * nx][i]);
st[1][nx].push_back(mini);
i += 1;
} else {
mini = min(mini, st[1][2 * nx + 1][j]);
st[0][nx].push_back(st[0][2 * nx + 1][j]);
st[1][nx].push_back(mini);
j += 1;
}
}
while (i < ln) {
mini = min(mini, st[1][2 * nx][i]);
st[0][nx].push_back(st[0][2 * nx][i]);
st[1][nx].push_back(mini);
i += 1;
}
while (j < rn) {
mini = min(mini, st[1][2 * nx + 1][j]);
st[0][nx].push_back(st[0][2 * nx + 1][j]);
st[1][nx].push_back(mini);
j += 1;
}
}
int query(int d, int a, int b, int nx = 1, int l = 0, int r = n - 1) {
if (b < l or a > r) return INT_MAX;
if (a <= l and r <= b) {
int lo = 0, hi = (int)st[0][nx].size() - 1;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (st[0][nx][mid] <= d)
lo = mid;
else
hi = mid - 1;
}
if (st[0][nx][lo] <= d) return st[1][nx][lo];
return INT_MAX;
}
int mid = (l + r) / 2;
int L = query(d, a, b, 2 * nx, l, mid);
int R = query(d, a, b, 2 * nx + 1, mid + 1, r);
return min(L, R);
}
int main() {
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(r, 0, 0);
build();
scanf("%d", &q);
int last = 0;
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
x = (x + last) % n + 1;
y = (y + last) % n;
printf("%d\n", (last = query(d[x] + y, l[x], l[x] + sz[x] - 1)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
vector<pair<int, int>> v, st[4 * N];
int in[N], out[N], val[N], dep[N];
vector<int> adj[N];
int timer = 0;
void dfs(int u, int p) {
if (p != -1)
dep[u] = dep[p] + 1;
else
dep[u] = 0;
in[u] = timer++;
v.emplace_back(dep[u], val[u]);
for (int c : adj[u]) {
if (c == p) continue;
dfs(c, u);
}
out[u] = timer - 1;
}
void build(int p, int l, int r) {
if (l == r) {
st[p] = {v[l]};
} else {
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
merge(st[p * 2].begin(), st[p * 2].end(), st[p * 2 + 1].begin(),
st[p * 2 + 1].end(), back_inserter(st[p]));
for (int i = 1; i < st[p].size(); ++i)
st[p][i].second = min(st[p][i].second, st[p][i - 1].second);
}
}
int query(int p, int l, int r, int i, int j, int mxDep) {
if (r < i || l > j || i > j) return 2e9;
if (l >= i && r <= j) {
auto it =
upper_bound((st[p]).begin(), (st[p]).end(), make_pair(mxDep, (int)2e9));
if (it == st[p].begin()) return 2e9;
return (--it)->second;
}
int mid = (l + r) / 2;
int p1 = query(p * 2, l, mid, i, j, mxDep);
int p2 = query(p * 2 + 1, mid + 1, r, i, j, mxDep);
return min(p1, p2);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 1; i < n; ++i) {
int u, c;
cin >> u >> c;
adj[u].push_back(c);
adj[c].push_back(u);
}
dfs(r, -1);
build(1, 0, n - 1);
int q, last = 0;
cin >> q;
while (q--) {
int x, k;
cin >> x >> k;
x = (x + last) % n + 1;
k = (k + last) % n;
last = query(1, 0, n - 1, in[x], out[x], dep[x] + k);
cout << last << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int N = 100000 + 1000;
const int M = 30 * N;
int n, r, a[N];
vector<int> e[N];
struct SegmentTree {
static const int inf = 0x3f3f3f3f;
int MIN[M], son[M][2], cnt;
inline void update(int now) {
MIN[now] = min(MIN[son[now][0]], MIN[son[now][1]]);
}
void Build(int now, int now_l, int now_r) {
if (now_l == now_r) {
MIN[now] = inf;
return;
}
Build(son[now][0] = ++cnt, now_l, ((now_l + now_r) >> 1));
Build(son[now][1] = ++cnt, ((now_l + now_r) >> 1) + 1, now_r);
update(now);
}
void Change(int x, int num, int now, int pre, int now_l, int now_r) {
if (now_l == now_r) {
MIN[now] = num;
return;
}
if (x <= ((now_l + now_r) >> 1))
son[now][1] = son[pre][1],
Change(x, num, son[now][0] = ++cnt, son[pre][0], now_l,
((now_l + now_r) >> 1));
else
son[now][0] = son[pre][0],
Change(x, num, son[now][1] = ++cnt, son[pre][1],
((now_l + now_r) >> 1) + 1, now_r);
update(now);
}
int Query(int L, int R, int now, int now_l, int now_r) {
if (now_l >= L and now_r <= R) return MIN[now];
int ans = inf;
if (L <= ((now_l + now_r) >> 1))
ans = min(ans, Query(L, R, son[now][0], now_l, ((now_l + now_r) >> 1)));
if (R > ((now_l + now_r) >> 1))
ans =
min(ans, Query(L, R, son[now][1], ((now_l + now_r) >> 1) + 1, now_r));
return ans;
}
} sgt;
int dfn[N], depth[N], dfn_to, size[N], depth_MAX;
void dfs(int now) {
depth_MAX = max(depth_MAX, depth[now]);
dfn[now] = ++dfn_to;
size[now] = 1;
for (int i = 0; i < int(e[now].size()); i++)
if (dfn[e[now][i]] == 0) {
depth[e[now][i]] = depth[now] + 1;
dfs(e[now][i]);
size[now] += size[e[now][i]];
}
}
int dl[N], front, tail, root[N];
void bfs() {
dl[tail++] = r;
int depth_now = 0;
while (tail > front) {
int now = dl[front];
int temp = root[depth_now];
if (depth[now] != depth_now) {
depth_now = depth[now];
temp = root[depth_now - 1];
}
root[depth_now] = ++sgt.cnt;
sgt.Change(dfn[now], a[now], root[depth_now], temp, 1, n);
for (int i = 0; i < int(e[now].size()); i++)
if (depth[e[now][i]] > depth[now]) dl[tail++] = e[now][i];
front++;
}
}
int main() {
n = read(), r = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int s = read(), t = read();
e[s].push_back(t);
e[t].push_back(s);
}
depth[r] = 1;
dfs(r);
sgt.Build(0, 1, n);
bfs();
int m = read(), lans = 0;
for (int i = 1; i <= m; i++) {
int x = read(), K = read();
x = ((x + lans) % n) + 1, K = (K + lans) % n;
int temp = min(depth[x] + K, depth_MAX);
lans = sgt.Query(dfn[x], dfn[x] + size[x] - 1, root[temp], 1, n);
printf("%d\n", lans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, r, q, a[MAXN], cnt, lc[MAXN * 100], rc[MAXN * 100];
int dep[MAXN], rt[MAXN], w[MAXN * 100];
vector<int> G[MAXN];
int Ins(int x, int l, int r, int p, int v) {
int t = ++cnt;
w[t] = min(w[x], v);
lc[t] = lc[x];
rc[t] = rc[x];
if (l == r) return t;
if (p <= ((l + r) >> 1))
lc[t] = Ins(lc[x], l, ((l + r) >> 1), p, v);
else
rc[t] = Ins(rc[x], ((l + r) >> 1) + 1, r, p, v);
return t;
}
int Query(int x, int l, int r, int L, int R) {
if (L > r || l > R) return 0x7f7f7f7f;
if (L <= l && r <= R) return w[x];
return min(Query(lc[x], l, ((l + r) >> 1), L, R),
Query(rc[x], ((l + r) >> 1) + 1, r, L, R));
}
int Merge(int x, int y, int l, int r) {
if (!x || !y) return x + y;
int t = ++cnt;
w[t] = min(w[x], w[y]);
lc[t] = Merge(lc[x], lc[y], l, ((l + r) >> 1));
rc[t] = Merge(rc[x], rc[y], ((l + r) >> 1) + 1, r);
return t;
}
void dfs(int u, int fa = 0) {
rt[u] = Ins(rt[u], 1, n, dep[u], a[u]);
for (auto v : G[u]) {
if (v == fa) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
rt[u] = Merge(rt[u], rt[v], 1, n);
}
}
int main() {
cin >> n >> r;
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
int u, v, last = 0;
memset(w, 0x7f, sizeof w);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dep[r] = 1;
dfs(r);
cin >> q;
while (q--) {
scanf("%d%d", &u, &v);
u = (u + last) % n + 1;
v = (v + last) % n;
int l = dep[u], r = min(dep[u] + v, n);
printf("%d\n", last = Query(rt[u], 1, n, l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 1e5 + 5;
struct node {
long long v;
node* left;
node* right;
} ns[N * 20];
long long cnt = 0;
node* create() {
(ns + cnt)->v = INF;
(ns + cnt)->left = ns;
(ns + cnt)->right = ns;
return (ns + cnt++);
}
long long query(node* v, long long tl, long long tr, long long l, long long r) {
if (l > tr || r < tl || v == ns) {
return INF;
}
if (l <= tl && tr <= r) {
return v->v;
}
long long tm = (tl + tr) / 2;
return min(query(v->left, tl, tm, l, r), query(v->right, tm + 1, tr, l, r));
}
node* update(node* v, long long tl, long long tr, long long id, long long val) {
if (id < tl || id > tr) {
return v;
}
node* ret = create();
if (tl == tr) {
ret->v = val;
return ret;
}
long long tm = (tl + tr) / 2;
ret->left = update(v->left, tl, tm, id, val);
ret->right = update(v->right, tm + 1, tr, id, val);
ret->v = min(ret->left->v, ret->right->v);
return ret;
}
long long a[N];
long long dep[N];
long long st[N], et[N], tim = 0;
vector<long long> v[N], d[N];
void dfs(long long z, long long p = 0) {
dep[z] = dep[p] + 1;
d[dep[z]].push_back(z);
st[z] = tim++;
for (long long x : v[z]) {
if (x == p) continue;
dfs(x, z);
}
et[z] = tim;
}
node* version[N];
void solve() {
long long n, r;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
}
for (long long i = 1; i < n; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(r);
version[0] = create();
for (long long i = 1; i < n + 1; i++) {
version[i] = version[i - 1];
for (long long x : d[i]) {
version[i] = update(version[i], 0, n + 4, st[x], a[x]);
}
}
long long m;
cin >> m;
long long last = 0;
for (long long i = 0; i < m; i++) {
long long p, q;
cin >> p >> q;
long long x = (p + last) % n + 1;
long long k = (q + last) % n;
long long ver = min(dep[x] + k, n);
last = query(version[ver], 0, n + 4, st[x], et[x] - 1);
cout << last << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 5;
const int inf = 1e9 + 7;
long long powmod(long long x, long long y) {
long long t;
for (t = 1; y; y >>= 1, x = x * x % mod)
if (y & 1) t = t * x % mod;
return t;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
int n, r, m, x, y, maxv, last;
int a[maxn], v[maxn];
int pl[maxn], pr[maxn], dep[maxn];
vector<int> g[maxn];
int rt[maxn], ls[maxn * 20], rs[maxn * 20], sum[maxn * 20], tot = 0;
void build(int& o, int l, int r) {
o = ++tot;
sum[o] = inf;
if (l == r) return;
int mid = l + r >> 1;
build(ls[o], l, mid);
build(rs[o], mid + 1, r);
}
void update(int& o, int last, int l, int r, int p, int v) {
o = ++tot;
ls[o] = ls[last], rs[o] = rs[last];
if (l == r) {
sum[o] = v;
return;
}
int mid = l + r >> 1;
if (p <= mid)
update(ls[o], ls[o], l, mid, p, v);
else
update(rs[o], rs[o], mid + 1, r, p, v);
sum[o] = min(sum[ls[o]], sum[rs[o]]);
return;
}
int query(int o, int l, int r, int L, int R) {
if (L <= l && r <= R) return sum[o];
int mid = l + r >> 1, ans = inf;
if (L <= mid) ans = min(ans, query(ls[o], l, mid, L, R));
if (mid < R) ans = min(ans, query(rs[o], mid + 1, r, L, R));
return ans;
}
void dfs(int u, int pre) {
pl[u] = ++tot;
dep[u] = dep[pre] + 1;
maxv = max(maxv, dep[u]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == pre) continue;
dfs(v, u);
}
pr[u] = tot;
}
int vis[maxn], mp[maxn];
void bfs() {
int tmp = 0;
queue<int> p;
p.push(r);
while (!p.empty()) {
int tp = p.front();
p.pop();
if (vis[tp])
continue;
else
vis[tp] = 1;
update(rt[tmp + 1], rt[tmp], 1, 2 * n, pl[tp], a[tp]);
mp[dep[tp]] = ++tmp;
for (int i = 0; i < g[tp].size(); i++) {
if (vis[g[tp][i]]) continue;
p.push(g[tp][i]);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> r;
for (int(i) = (1); (i) < (n + 1); (i)++) cin >> a[i];
for (int(i) = (1); (i) < (n); (i)++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r, 0);
tot = 0;
build(rt[0], 1, n << 1);
bfs();
cin >> m;
for (int(i) = (0); (i) < (m); (i)++) {
cin >> x >> y;
x = (x + last) % n + 1, y = (y + last) % n;
last = query(rt[mp[min(dep[x] + y, maxv)]], 1, n << 1, pl[x], pr[x]);
cout << last << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class Val, class Cmp>
class DynamicRMQ {
int n;
Val init;
vector<Val> dat;
Cmp cmp;
inline Val query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return init;
if (a <= l && r <= b)
return dat[k];
else {
Val vl, vr;
vl = query(a, b, k << 1, l, (l + r) >> 1);
vr = query(a, b, (k << 1) | 1, (l + r) >> 1, r);
return cmp(vl, vr) ? vl : vr;
}
}
public:
DynamicRMQ() {}
DynamicRMQ(int n_, Val init_) : n(1), init(init_) {
for (; n < n_; n <<= 1)
;
dat = vector<Val>(n << 1, init);
}
void update(int k, Val a) {
k += n;
dat[k] = a;
while (k > 1) {
k >>= 1;
dat[k] =
cmp(dat[k << 1], dat[(k << 1) | 1]) ? dat[k << 1] : dat[(k << 1) | 1];
}
}
Val query(int a, int b) { return query(a, b, 1, 0, n); }
};
const int N_MAX = 100005, LOG = 18;
int N, R, A[N_MAX];
int e2v[N_MAX], v2e[N_MAX];
int euler_l[N_MAX], euler_r[N_MAX];
int id, depth[N_MAX], ancestor[LOG][N_MAX], min_a[LOG][N_MAX], bfs_id[N_MAX];
vector<int> G[N_MAX];
vector<pair<int, int> > ordered[N_MAX + N_MAX];
DynamicRMQ<int, less<int> > rmq[LOG];
void f(int u, int p, int d) {
e2v[id] = u;
euler_l[u] = v2e[u] = id;
ordered[d].emplace_back(id++, 0);
depth[u] = d;
ancestor[0][u] = p != -1 ? p : u;
for (int(j) = (0); (j) < (int)(LOG); ++(j))
(min_a[j][u]) = min((min_a[j][u]), (A[u]));
(min_a[0][ancestor[0][u]]) = min((min_a[0][ancestor[0][u]]), (A[u]));
for (auto &(v) : (G[u]))
if (p != v) {
f(v, u, d + 1);
}
euler_r[u] = id;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> R;
--R;
for (int(i) = (0); (i) < (int)(N); ++(i)) cin >> A[i];
for (int(i) = (0); (i) < (int)(N - 1); ++(i)) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int(i) = (0); (i) < (int)(LOG); ++(i)) {
rmq[i] = DynamicRMQ<int, less<int> >(N, 1 << 30);
for (int(j) = (0); (j) < (int)(N); ++(j)) min_a[i][j] = 1 << 30;
}
f(R, -1, 0);
id = 0;
for (int(i) = (0); (i) < (int)(N); ++(i))
for (auto &(p) : (ordered[i])) {
bfs_id[e2v[p.first]] = p.second = id++;
}
for (int(i) = (0); (i) < (int)(LOG - 1); ++(i)) {
for (int(j) = (0); (j) < (int)(N); ++(j)) {
ancestor[i + 1][j] = ancestor[i][ancestor[i][j]];
(min_a[i + 1][j]) = min((min_a[i + 1][j]), (min_a[i][j]));
(min_a[i + 1][ancestor[i][j]]) =
min((min_a[i + 1][ancestor[i][j]]), (min_a[i][j]));
}
for (int(j) = (0); (j) < (int)(N); ++(j))
rmq[i].update(bfs_id[j], min_a[i][j]);
}
int M, ans = 0;
cin >> M;
while (M--) {
int p, q, X, K;
cin >> p >> q;
X = (p + ans) % N;
K = (q + ans) % N;
ans = A[X];
int dep = depth[X];
for (int(i) = (0); (i) < (int)(LOG - 1); ++(i))
if (K >> i & 1) {
auto bfs_l = lower_bound((ordered[dep]).begin(), (ordered[dep]).end(),
make_pair(euler_l[X], 0));
auto bfs_r = lower_bound((ordered[dep]).begin(), (ordered[dep]).end(),
make_pair(euler_r[X], 0));
if (bfs_l != bfs_r)
(ans) =
min((ans), (rmq[i].query(bfs_l->second, (--bfs_r)->second + 1)));
dep += 1 << i;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxl = 100005, maxg = 25;
int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -w;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 1) + (s << 3) + (ch ^ '0');
ch = getchar();
}
return s * w;
}
int n, tree_root, q, nowtim = 0, cnt = 0, tot = 0, x, y, k, treedeep = 0,
lastans;
int a[maxl], head[maxl], siz[maxl], dfn[maxl], depth[maxl], root[maxl],
maxinum_rt[maxl];
struct edge {
int nxt, to;
} e[2 * maxl];
struct Segment_tree {
int l, r, val;
} tree[maxl * maxg];
struct node {
int d1, d2, d3;
} tmp[2 * maxl];
bool cmp(node tmpx, node tmpy) { return tmpx.d1 < tmpy.d1; }
void add_edge(int u, int v) {
cnt++;
e[cnt].to = v, e[cnt].nxt = head[u], head[u] = cnt;
}
void dfs(int now, int fath) {
siz[now] = 1, dfn[now] = ++nowtim, depth[now] = depth[fath] + 1;
treedeep = max(treedeep, depth[now]);
for (int i = head[now]; i; i = e[i].nxt) {
int y = e[i].to;
if (y == fath) continue;
dfs(y, now), siz[now] += siz[y];
}
}
void pushup(int rt) {
tree[rt].val = min(tree[tree[rt].l].val, tree[tree[rt].r].val);
}
int ducati_clone(int rt) {
tot++;
tree[tot] = tree[rt];
return tot;
}
int build_tree(int l, int r, int rt) {
rt = ++tot;
if (l == r) {
tree[rt].val = 2000000009;
return rt;
}
int mid = (l + r) >> 1;
tree[rt].l = build_tree(l, mid, rt << 1);
tree[rt].r = build_tree(mid + 1, r, (rt << 1) | 1);
pushup(rt);
return rt;
}
int change(int nl, int l, int r, int rt, int kk) {
rt = ducati_clone(rt);
if (l == r) {
tree[rt].val = kk;
return rt;
}
int mid = (l + r) >> 1;
if (nl <= mid)
tree[rt].l = change(nl, l, mid, tree[rt].l, kk);
else
tree[rt].r = change(nl, mid + 1, r, tree[rt].r, kk);
pushup(rt);
return rt;
}
int query(int nl, int nr, int l, int r, int rt) {
if (nl <= l && r <= nr) return tree[rt].val;
int mid = (l + r) >> 1, minv = 2000000009;
if (nl <= mid) minv = query(nl, nr, l, mid, tree[rt].l);
if (nr > mid) minv = min(minv, query(nl, nr, mid + 1, r, tree[rt].r));
return minv;
}
int tree_query(int maxdeep, int le, int ri) {
maxdeep = min(maxdeep, treedeep);
maxdeep = maxinum_rt[maxdeep];
return query(le, ri, 1, n, root[maxdeep]);
}
signed main() {
n = read(), tree_root = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
x = read(), y = read();
add_edge(x, y), add_edge(y, x);
}
dfs(tree_root, 0);
for (int i = 1; i <= n; i++)
tmp[i].d1 = depth[i], tmp[i].d2 = dfn[i], tmp[i].d3 = a[i];
sort(tmp + 1, tmp + n + 1, cmp);
for (int i = 1; i <= n; i++)
maxinum_rt[tmp[i].d1] = max(maxinum_rt[tmp[i].d1], i);
root[0] = build_tree(1, n, root[0]);
for (int i = 1; i <= n; i++)
root[i] = change(tmp[i].d2, 1, n, root[i - 1], tmp[i].d3);
q = read();
while (q--) {
x = read(), k = read();
x = ((x + lastans) % n) + 1;
k = (k + lastans) % n;
lastans = tree_query(depth[x] + k, dfn[x], dfn[x] + siz[x] - 1);
printf("%d\n", lastans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ini[100050], fim[100050], nivel[100050], cnt, v[100050], q,
resp_anterior, root;
vector<int> grafo[100050];
struct node {
int val;
node *l, *r;
node(int x = 0) {
val = 2000000000;
l = r = NULL;
}
};
node *version[100050];
void build(node *root, int a, int b) {
if (a == b) {
root->val = 2000000000;
return;
}
root->l = new node(), root->r = new node();
build(root->l, a, ((a + b) / 2)), build(root->r, ((a + b) / 2) + 1, b);
}
void upd(node *prev, node *root, int a, int b, int i, int x) {
if (i < a || i > b) return;
if (a == b) {
root->val = x;
return;
}
if (i <= ((a + b) / 2)) {
root->r = prev->r;
if (!root->l) root->l = new node();
upd(prev->l, root->l, a, ((a + b) / 2), i, x);
} else {
root->l = prev->l;
if (!root->r) root->r = new node();
upd(prev->r, root->r, ((a + b) / 2) + 1, b, i, x);
}
root->val = min(root->l->val, root->r->val);
}
int query(node *root, int a, int b, int i, int j) {
if (j < a || i > b) return 2000000000;
if (i <= a && j >= b) return root->val;
int esq = (root->l ? query(root->l, a, ((a + b) / 2), i, j) : 2000000000),
dir = (root->r ? query(root->r, ((a + b) / 2) + 1, b, i, j) : 2000000000);
return min(esq, dir);
}
void dfs(int x, int p) {
ini[x] = ++cnt;
for (auto v : grafo[x])
if (v != p) nivel[v] = nivel[x] + 1, dfs(v, x);
fim[x] = cnt;
}
bool cmp(int a, int b) { return nivel[a] < nivel[b]; }
vector<int> fila;
int id[100050];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> v[i], fila.push_back(i);
for (int i = 1, a, b; i < n; i++) {
cin >> a >> b;
grafo[a].push_back(b);
grafo[b].push_back(a);
}
nivel[root] = 1;
dfs(root, root);
sort(fila.begin(), fila.end(), cmp);
version[0] = new node();
build(version[0], 1, cnt);
for (int i = 0; i < fila.size(); i++) {
int idx = i + 1;
version[idx] = new node();
upd(version[idx - 1], version[idx], 1, cnt, ini[fila[i]], v[fila[i]]);
id[nivel[fila[i]]] = idx;
}
cin >> q;
while (q--) {
int x, k;
cin >> x >> k;
x = ((resp_anterior + x) % n) + 1;
k = (resp_anterior + k) % n;
int nivel_v = k + nivel[x];
int vers = (nivel_v >= 100050 ? n : id[nivel_v]);
if (vers == 0 || nivel_v >= 100050) vers = n;
resp_anterior = query(version[vers], 1, cnt, ini[x], fim[x]);
cout << resp_anterior << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct nodo {
long long v;
int izq;
int der;
};
struct pst {
vector<int> roots;
vector<nodo> nodos;
int n;
};
pst init(int n) {
pst tree;
long long k = 1;
while (k < n) k *= 2;
tree.nodos.resize(2 * k);
tree.roots.push_back(1);
tree.n = k;
for (int i = 0; i < (int)(2 * k); ++i) {
tree.nodos[i].v = 1000000000;
if (i <= k) {
tree.nodos[i].izq = 2 * i;
tree.nodos[i].der = 2 * i + 1;
} else {
tree.nodos[i].izq = -1;
tree.nodos[i].der = -1;
}
}
return tree;
}
void update(pst& tree, long long p, long long v) {
vector<int> camino;
int act = tree.roots[tree.roots.size() - 1];
int l = 0, r = tree.n;
while (r - l > 1) {
camino.push_back(act);
if (p < (r + l) / 2) {
act = tree.nodos[act].izq;
r = (r + l) / 2;
} else {
act = tree.nodos[act].der;
l = (r + l) / 2;
}
}
nodo nnodo;
nnodo.v = v;
nnodo.izq = -1;
nnodo.der = -1;
tree.nodos.push_back(nnodo);
for (int i = (camino.size()) - 1; i >= 0; --i) {
nnodo = tree.nodos[camino[i]];
nnodo.v = min(nnodo.v, v);
if (p % 2) {
nnodo.der = tree.nodos.size() - 1;
} else {
nnodo.izq = tree.nodos.size() - 1;
}
tree.nodos.push_back(nnodo);
p /= 2;
}
tree.roots.push_back(tree.nodos.size() - 1);
}
long long get(pst& tree, int act, int l, int r, int a, int b) {
if (a >= l && b <= r) return tree.nodos[act].v;
if (b <= l || a >= r) return 1000000000;
int c = (a + b) / 2;
return min(get(tree, tree.nodos[act].izq, l, r, a, c),
get(tree, tree.nodos[act].der, l, r, c, b));
}
long long get(pst& tree, int l, int r, int t) {
return get(tree, tree.roots[t], l, r, 0, tree.n);
}
void dfs(int act, int p, vector<int>& rec, vector<vector<int>>& grafo) {
rec.push_back(act);
for (int i = 0; i < (int)(grafo[act].size()); ++i) {
if (grafo[act][i] != p) {
dfs(grafo[act][i], act, rec, grafo);
}
}
rec.push_back(act);
}
int main() {
int n, r;
scanf("%d %d", &n, &r);
vector<vector<int>> grafo(n);
vector<int> pesos(n);
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", &(pesos[i]));
}
for (int i = 0; i < (int)(n - 1); ++i) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
grafo[a].push_back(b);
grafo[b].push_back(a);
}
vector<int> nodos;
dfs(r - 1, -1, nodos, grafo);
vector<vector<int>> pos(n);
for (int i = 0; i < (int)(nodos.size()); ++i) {
pos[nodos[i]].push_back(i);
}
pst tree = init(nodos.size());
vector<int> dist(n, -1);
vector<int> ts;
dist[r - 1] = 0;
queue<int> bfs;
bfs.push(r - 1);
int actd = 0;
while (!bfs.empty()) {
int act = bfs.front();
if (dist[act] > actd) {
ts.push_back(tree.roots.size() - 1);
}
actd = dist[act];
for (int i = 0; i < (int)(pos[act].size()); ++i) {
update(tree, pos[act][i], pesos[act]);
}
for (int i = 0; i < (int)(grafo[act].size()); ++i) {
int next = grafo[act][i];
if (dist[next] == -1) {
bfs.push(next);
dist[next] = dist[act] + 1;
}
}
bfs.pop();
}
ts.push_back(tree.roots.size() - 1);
int m;
scanf("%d", &m);
long long last = 0;
for (int i = 0; i < (int)(m); ++i) {
long long p, q;
scanf("%I64d %I64d", &p, &q);
long long x = (p + last) % n, k = (q + last) % n;
k += dist[x];
k = min(k, (long long)ts.size() - 1);
last = get(tree, pos[x][0], pos[x][1], ts[k]);
printf("%I64d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e5 + 5;
bool vis[N];
vector<pair<int, int>> flat;
vector<vector<int>> edges(N);
vector<pair<int, int>> seg[N << 2];
long long root, n, m, k, p, last, a[N], l[N], r[N], d[N];
void build(int s, int e, int idx) {
if (s == e) {
seg[idx].push_back(flat[s]);
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * idx + 1);
build(mid + 1, e, 2 * idx + 2);
merge(seg[2 * idx + 1].begin(), seg[2 * idx + 1].end(),
seg[2 * idx + 2].begin(), seg[2 * idx + 2].end(),
back_inserter(seg[idx]));
for (int i = 1; i < seg[idx].size(); i++)
seg[idx][i].second = min(seg[idx][i].second, seg[idx][i - 1].second);
}
long long get_ans(int l, int r, int s, int e, int idx, int lvl) {
if (l > e || s > r) return 1e15;
if (s >= l && e <= r) {
int pos = upper_bound(seg[idx].begin(), seg[idx].end(),
make_pair(lvl, (int)2e9)) -
seg[idx].begin();
if (!pos) return 1e15;
return seg[idx][pos - 1].second;
}
int mid = (s + e) / 2;
return min(get_ans(l, r, s, mid, 2 * idx + 1, lvl),
get_ans(l, r, mid + 1, e, 2 * idx + 2, lvl));
}
void dfs(int node, int lvl) {
vis[node] = 1;
d[node] = lvl;
l[node] = flat.size();
flat.push_back({lvl, a[node]});
for (auto i : edges[node])
if (!vis[i]) dfs(i, lvl + 1);
r[node] = flat.size() - 1;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> p >> k;
edges[p].push_back(k);
edges[k].push_back(p);
}
dfs(root, 0);
build(0, n - 1, 0);
cin >> m;
while (m--) {
cin >> p >> k;
p = (p + last) % n + 1;
k = (k + last) % n;
last = get_ans(l[p], r[p], 0, n - 1, 0, d[p] + k);
cout << last << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int INF = 1000000007;
int n, r, q, pot = 1, cnt, ind, k, last;
int l[MAXN], dub[MAXN], tin[MAXN], tout[MAXN];
vector<int> v[MAXN];
vector<pair<int, int> > t[4 * MAXN];
void dfs(int cvor, int par) {
tin[cvor] = cnt;
cnt++;
tout[cvor] = -1;
for (int i = 0; i < v[cvor].size(); i++) {
int sus = v[cvor][i];
if (sus == par) continue;
dub[sus] = dub[cvor] + 1;
dfs(sus, cvor);
tout[cvor] = max(tout[cvor], tout[sus]);
}
t[pot + tin[cvor]].push_back(make_pair(dub[cvor], l[cvor]));
if (tout[cvor] == -1) tout[cvor] = tin[cvor];
}
void build() {
for (int i = pot - 1; i > 0; i--) {
for (int j = 0; j < t[i * 2].size(); j++) {
t[i].push_back(t[i * 2][j]);
}
for (int j = 0; j < t[i * 2 + 1].size(); j++) {
t[i].push_back(t[i * 2 + 1][j]);
}
}
for (int i = pot - 1; i > 0; i--) {
sort(t[i].begin(), t[i].end());
for (int j = 1; j < t[i].size(); j++) {
t[i][j].second = min(t[i][j].second, t[i][j - 1].second);
}
}
}
int upit(int cvor, int from, int to, int low, int high) {
if (from <= low && high <= to) {
int br = upper_bound(t[cvor].begin(), t[cvor].end(), make_pair(k, INF)) -
t[cvor].begin();
if (br == 0) return INF;
return t[cvor][br - 1].second;
}
if (to < low || high < from) return INF;
return min(upit(cvor * 2, from, to, low, (low + high) / 2),
upit(cvor * 2 + 1, from, to, (low + high) / 2 + 1, high));
}
int main() {
cin >> n >> r;
while (pot < n) pot *= 2;
for (int i = 1; i <= n; i++) {
scanf("%d", &l[i]);
}
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(r, -1);
build();
cin >> q;
for (int i = 0; i < q; i++) {
int p, q;
scanf("%d%d", &p, &q);
ind = (last + p) % n + 1;
k = (last + q) % n + dub[ind];
last = upit(1, tin[ind], tout[ind], 0, pot - 1);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
struct node {
int val, le, ri;
node() : val(1e9 + 5), le(0), ri(0) {}
};
const int N = 1e5 + 5;
int n, r, m, p, q, u, v, a[N], depth[N], root[N], tin[N], tout[N], ti = 1;
vector<int> adj[N];
bool vis[N];
vector<node> tree;
void dfs(int x) {
vis[x] = true;
tin[x] = ti++;
for (int y : adj[x]) {
if (!vis[y]) {
depth[y] = 1 + depth[x];
dfs(y);
}
}
tout[x] = ti;
}
int build(int l, int r) {
int k = ((int)(tree).size());
tree.emplace_back();
if (l < r) {
int m = (l + r) / 2;
tree[k].le = build(l, m);
tree[k].ri = build(m + 1, r);
tree[k].val = min(tree[tree[k].le].val, tree[tree[k].ri].val);
}
return k;
}
int upd(int i, int l, int r, int idx, int x) {
int k = ((int)(tree).size());
tree.emplace_back();
if (l < r) {
int m = (l + r) / 2;
if (idx <= m) {
tree[k].le = upd(tree[i].le, l, m, idx, x);
tree[k].ri = tree[i].ri;
} else {
tree[k].le = tree[i].le;
tree[k].ri = upd(tree[i].ri, m + 1, r, idx, x);
}
tree[k].val = min(tree[tree[k].le].val, tree[tree[k].ri].val);
} else {
tree[k].val = x;
}
return k;
}
int query(int i, int l, int r, int L, int R) {
if (r < L || R < l) return 1e9 + 5;
if (L <= l && r <= R) return tree[i].val;
int m = (l + r) / 2;
return min(query(tree[i].le, l, m, L, R), query(tree[i].ri, m + 1, r, L, R));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r;
for (int i = (1); i < (n + 1); i++) {
cin >> a[i];
}
for (int i = (0); i < (n - 1); i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(r);
vector<pair<int, int>> ve;
for (int i = (1); i < (n + 1); i++) {
ve.emplace_back(depth[i], i);
}
sort((ve).begin(), (ve).end());
root[0] = build(1, n);
int prevdepth = 0;
for (auto &p : ve) {
int u = p.second;
root[depth[u]] = upd(root[prevdepth], 1, n, tin[u], a[u]);
prevdepth = depth[u];
}
cin >> m;
int last = 0;
while (m--) {
cin >> p >> q;
int x = 1 + ((p + last) % n);
int k = (q + last) % n;
last = query(root[min(prevdepth, depth[x] + k)], 1, n, tin[x], tout[x] - 1);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, rr, a[100005], u, v, in0[100005], out0[100005], h[100005],
l[8 * 100005], r[8 * 100005], ans, p, q, xl, xr, k;
bool fl[100005], bb;
vector<int> g[100005], a0;
vector<pair<int, int>> st[8 * 100005];
void dfsb(int i, int height) {
fl[i] = 1;
in0[i] = a0.size();
a0.push_back(i);
h[i] = height;
for (int j = 0; j < g[i].size(); j++)
if (!fl[g[i][j]]) dfsb(g[i][j], height + 1);
out0[i] = a0.size();
a0.push_back(i);
fl[i] = 0;
}
void builst(int i) {
for (int j = l[i]; j <= r[i]; j++) st[i].push_back({h[a0[j]], a[a0[j]]});
sort(st[i].begin(), st[i].end());
for (int j = 1; j < st[i].size(); j++)
st[i][j].second = min(st[i][j - 1].second, st[i][j].second);
if (l[i] == r[i]) return;
l[i * 2] = l[i];
r[i * 2] = (l[i] + r[i]) / 2;
l[i * 2 + 1] = r[i * 2] + 1;
r[i * 2 + 1] = r[i];
builst(i * 2);
builst(i * 2 + 1);
}
int ret(int i) {
if (l[i] > xr || r[i] < xl) return 1000000001;
if (xl <= l[i] && r[i] <= xr) {
int tl = 0, tr = st[i].size() - 1, tm = 0, ttm = 0;
bb = 1;
while (tl <= tr) {
tm = (tl + tr) / 2;
if (st[i][tm].first <= k) {
ttm = tm;
tl = tm + 1;
bb = 0;
} else
tr = tm - 1;
}
return st[i][ttm].second + bb * 1000000001;
}
return min(ret(i * 2), ret(i * 2 + 1));
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> rr;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfsb(rr, 1);
l[1] = 0;
r[1] = 2 * n - 1;
builst(1);
cin >> m;
while (m--) {
cin >> p >> q;
xl = in0[(ans + p) % n + 1];
xr = out0[(ans + p) % n + 1];
k = h[(ans + p) % n + 1] + (q + ans) % n;
ans = ret(1);
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
void dfs(int32_t vertex, int32_t parent, std::vector<int32_t>* tree,
int32_t depth, int32_t* depths, std::vector<int32_t>& euler) {
depths[vertex] = depth;
euler.push_back(vertex);
for (int32_t i = 0; i < tree[vertex].size(); i++)
if (tree[vertex][i] != parent) {
dfs(tree[vertex][i], vertex, tree, depth + 1, depths, euler);
euler.push_back(vertex);
}
}
int32_t** segtree_pref;
std::pair<int32_t, int32_t>** segtree;
void build(int32_t node, int32_t left, int32_t right, int32_t* depths,
int32_t* labels, std::vector<int32_t>& euler) {
segtree[node] = new std::pair<int32_t, int32_t>[right - left];
segtree_pref[node] = new int32_t[right - left + 1];
segtree_pref[node][0] = INT32_MAX;
if (right - left == 1) {
segtree[node][0] = {depths[euler[left]], labels[euler[left]]};
segtree_pref[node][1] = labels[euler[left]];
return;
}
int32_t m = (left + right) / 2;
build(node * 2 + 1, left, m, depths, labels, euler);
build(node * 2 + 2, m, right, depths, labels, euler);
std::merge(segtree[node * 2 + 1], segtree[node * 2 + 1] + m - left,
segtree[node * 2 + 2], segtree[node * 2 + 2] + right - m,
segtree[node]);
for (int32_t i = 1; i <= right - left; i++)
segtree_pref[node][i] =
std::min(segtree_pref[node][i - 1], segtree[node][i - 1].second);
}
int32_t query(int32_t node, int32_t left, int32_t right, int32_t query_left,
int32_t query_right, int32_t param) {
if (left >= query_right || right <= query_left) return INT32_MAX;
if (left >= query_left && right <= query_right) {
return segtree_pref[node]
[std::lower_bound(
segtree[node], segtree[node] + right - left,
std::pair<int32_t, int32_t>(param, INT32_MIN)) -
segtree[node]];
}
int32_t m = (left + right) / 2;
return std::min(
query(node * 2 + 1, left, m, query_left, query_right, param),
query(node * 2 + 2, m, right, query_left, query_right, param));
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int32_t n, root;
std::cin >> n >> root;
root--;
int32_t* labels = new int32_t[n];
for (int32_t i = 0; i < n; i++) std::cin >> labels[i];
std::vector<int32_t>* tree = new std::vector<int32_t>[n];
for (int32_t i = 0; i < n - 1; i++) {
int32_t src, dst;
std::cin >> src >> dst;
src--;
dst--;
tree[src].push_back(dst);
tree[dst].push_back(src);
}
int32_t* depths = new int32_t[n];
std::vector<int32_t> euler;
dfs(root, -1, tree, 0, depths, euler);
int32_t* first_euler = new int32_t[n];
for (int32_t i = 0; i < n; i++) first_euler[i] = INT32_MAX;
int32_t* last_euler = new int32_t[n];
for (int32_t i = 0; i < euler.size(); i++) {
first_euler[euler[i]] = std::min(first_euler[euler[i]], i);
last_euler[euler[i]] = i;
}
int32_t num_queries;
std::cin >> num_queries;
segtree = new std::pair<int32_t, int32_t>*[4 * euler.size()];
segtree_pref = new int32_t*[4 * euler.size()];
build(0, 0, euler.size(), depths, labels, euler);
int32_t last = 0;
for (int32_t q = 0; q < num_queries; q++) {
int32_t p, q_;
std::cin >> p >> q_;
int32_t vertex = (p + last) % n, max_shift = (q_ + last) % n;
last = query(0, 0, euler.size(), first_euler[vertex],
last_euler[vertex] + 1, depths[vertex] + max_shift + 1);
std::cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool umin(T1& x, T2 y) {
return (x > y ? (x = y, true) : false);
}
template <typename T1, typename T2>
bool umax(T1& x, T2 y) {
return (x < y ? (x = y, true) : false);
}
template <typename T>
void read(T& x) {
char ch;
T p = 1;
x = 0;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= p;
}
void read(string& x) {
char ch;
do {
ch = getchar();
} while (ch <= ' ');
while (ch > ' ') x += ch, ch = getchar();
}
void read(char& x) {
do {
x = getchar();
} while (x <= ' ');
}
template <typename T, typename... R>
void read(T& x, R&... y) {
read(x);
read(y...);
}
const int N = (int)1e5 + 3;
const long long mod = (long long)1e9 + 7;
const int INF = (int)1e9 + 1;
const long long LLINF = (long long)1e18 + 1;
const long double pi = (long double)acos(-1.0);
const long double eps = (long double)1e-11;
const int block = 93;
int n, m, r;
int p[N];
int w[N];
int d[N];
int sz[N];
int in[N];
int out[N];
vector<int> g[N];
vector<int> sn[N];
void prepare(int v, int p) {
static int timer = 0;
in[v] = ++timer;
::p[v] = p;
for (int to : g[v])
if (to != p) prepare(to, v);
out[v] = ++timer;
}
inline bool upper(int x, int y) { return in[x] <= in[y] && out[y] <= out[x]; }
void dfs(int v, int p, int dist = 0) {
d[v] = dist;
sz[v] = 1;
for (int to : g[v]) {
if (to == p) continue;
dfs(to, v, dist + 1);
sz[v] += sz[to];
}
if (sz[v] > block) {
sn[v].resize(n + 1);
sz[v] = 1;
for (long long i = (0); i < (n); i++) {
if (upper(v, i)) {
if (sn[v][d[i] - d[v]] == 0) {
sn[v][d[i] - d[v]] = w[i];
}
umin(sn[v][d[i] - d[v]], w[i]);
}
}
int mn = INF;
for (long long i = (0); i < (n + 1); i++) {
if (sn[v][i] > 0) umin(mn, sn[v][i]);
sn[v][i] = mn;
}
}
}
int query(int v, int p, int md) {
if (md < 0) return INF;
int ret = w[v];
if (!sn[v].empty()) return sn[v][md];
for (int to : g[v]) {
if (to == p) continue;
umin(ret, query(to, v, md - 1));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
read(n, r);
for (long long i = (0); i < (n); i++) read(w[i]);
for (long long i = (1); i < (n); i++) {
int x, y;
read(x, y);
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
prepare(--r, -1);
dfs(r, -1);
int last = 0;
read(m);
while (m-- > 0) {
int p, q;
read(p, q);
int v = (p + last) % n;
int k = (q + last) % n;
last = query(v, ::p[v], k);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
const int inf = (1ll << 30) - 1;
const int maxn = (int)1e5 + 10;
using namespace std;
vector<int> g[100100];
vector<int> t[4 * 100100];
vector<int> L[4 * 100100];
vector<int> val[4 * 100100];
int tin[100100];
int tout[100100];
int a[100100];
int timer = 0;
int n;
int V[100100];
int lev[100100];
int r;
void dfs(int v, int p) {
V[timer] = v;
lev[v] = lev[p] + 1;
tin[v] = timer++;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == p) continue;
dfs(to, v);
}
tout[v] = timer - 1;
}
void build(int v, int l, int r) {
if (l == r) {
int D = V[l];
t[v].push_back(lev[D]);
val[v].push_back(a[D]);
return;
}
int mid = (l + r) >> 1;
build(v * 2, l, mid);
build(v * 2 + 1, mid + 1, r);
int i = 0, j = 0;
vector<int>& x = t[v * 2];
vector<int>& y = t[v * 2 + 1];
while (i < x.size() && j < y.size()) {
if (x[i] < y[j]) {
val[v].push_back(val[v * 2][i]);
t[v].push_back(x[i]);
i++;
L[v].push_back(i);
} else {
val[v].push_back(val[v * 2 + 1][j]);
t[v].push_back(y[j]);
j++;
L[v].push_back(i);
}
}
while (i < x.size()) {
val[v].push_back(val[v * 2][i]);
t[v].push_back(x[i]);
i++;
L[v].push_back(i);
}
while (j < y.size()) {
val[v].push_back(val[v * 2 + 1][j]);
t[v].push_back(y[j]);
j++;
L[v].push_back(i);
}
for (int i = 1; i < val[v].size(); i++) {
val[v][i] = min(val[v][i], val[v][i - 1]);
}
}
int get(int v, int tl, int tr, int l, int r, int pos) {
if (l > tr || tl > r || pos == 0) return inf;
if (l <= tl && tr <= r) {
return val[v][pos - 1];
}
int mid = (tl + tr) >> 1;
return min(get(v * 2, tl, mid, l, r, L[v][pos - 1]),
get(v * 2 + 1, mid + 1, tr, l, r, pos - L[v][pos - 1]));
}
inline int nextInt() {
register int n = 0;
register char c = getchar();
while (c == ' ' || c == '\t' || c == '\n') {
c = getchar();
}
while (!(c == ' ' || c == '\t' || c == '\n')) {
n = n * 10 + c - '0';
c = getchar();
}
return n;
}
void out(int x) {
if (x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
void solve() {
n = nextInt();
r = nextInt();
for (int i = 1; i <= n; i++) {
a[i] = nextInt();
}
for (int i = 1, x, y; i < n; i++) {
x = nextInt();
y = nextInt();
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r, 0);
build(1, 0, n - 1);
int m;
cin >> m;
int last = 0;
for (int i = 0, x, y; i < m; i++) {
x = nextInt();
y = nextInt();
x = (x + last) % n + 1;
y = (y + last) % n;
int pos = upper_bound(t[1].begin(), t[1].end(), lev[x] + y) - t[1].begin();
last = get(1, 0, n - 1, tin[x], tout[x], pos);
out(last);
putchar('\n');
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
template <typename T>
struct Segtree_ptr {
int N;
struct Node {
int l, r;
vector<int> ch;
T val;
Node(int l, int r) : l(l), r(r) {
val = INF;
ch.resize(2, -1);
}
};
vector<Node> nodes;
Segtree_ptr() {}
Segtree_ptr(int Nin) { initialize(Nin); }
void initialize(int Nin) {
N = 1;
while (N < Nin) N <<= 1;
}
int create() {
nodes.push_back(Node(0, N));
return nodes.size() - 1;
}
T getval(int nd) { return (nd != -1 ? nodes[nd].val : INF); }
void update(int k, T x) { update(0, k, x); }
void update(int nd, int k, T x) {
int l = nodes[nd].l, r = nodes[nd].r;
if (k < l || r <= k) return;
if (r - l == 1) {
nodes[nd].val = min(nodes[nd].val, x);
} else {
int d = (r - l) / 2;
int t = (k - l) / d;
if (nodes[nd].ch[t] == -1) {
nodes[nd].ch[t] = nodes.size();
nodes.push_back(Node(l + t * d, l + (t + 1) * d));
}
update(nodes[nd].ch[t], k, x);
nodes[nd].val = min(getval(nodes[nd].ch[0]), getval(nodes[nd].ch[1]));
}
}
T between(int a, int b) { return query(0, a, b + 1); }
T query(int nd, int a, int b) {
if (nd == -1) return INF;
int l = nodes[nd].l, r = nodes[nd].r;
if (b <= l || r <= a) return INF;
if (a <= l && r <= b) return nodes[nd].val;
return min(query(nodes[nd].ch[0], a, b), query(nodes[nd].ch[1], a, b));
}
};
Segtree_ptr<int> stpt;
template <typename T>
struct Segtree {
int n;
vector<int> dat;
Segtree() {}
Segtree(int n_input, int m_input) { initialize(n_input, m_input); }
void initialize(int n_input, int m_input) {
n = 1;
while (n < n_input) n <<= 1;
stpt.initialize(m_input);
dat.resize(2 * n - 1);
for (auto& a : dat) a = stpt.create();
}
void update(int k, int x, T a) {
k += n - 1;
stpt.update(dat[k], x, a);
while (k > 0) {
k = (k - 1) / 2;
stpt.update(dat[k], x, a);
}
}
T between(int a, int b, int s, int t) {
return query(a, b + 1, 0, 0, n, s, t);
}
T query(int a, int b, int k, int l, int r, int s, int t) {
if (r <= a || b <= l) return INF;
if (a <= l && r <= b) return stpt.query(dat[k], s, t + 1);
T vl = query(a, b, 2 * k + 1, l, (l + r) / 2, s, t);
T vr = query(a, b, 2 * k + 2, (l + r) / 2, r, s, t);
return min(vl, vr);
}
};
int depth[100000];
struct EulerTour {
int sz = 0;
vector<int> L, R;
EulerTour() {}
EulerTour(int N, vector<int> G[], int root = 0) { initialize(N, G, root); }
void dfs(int i, int p, vector<int> G[], int d) {
depth[i] = d;
L[i] = sz;
bool first = true;
for (int j : G[i])
if (j != p) {
if (!first) sz++;
first = false;
dfs(j, i, G, d + 1);
}
R[i] = sz;
}
void initialize(int N, vector<int> G[], int root) {
L.resize(N);
R.resize(N);
dfs(root, -1, G, 0);
}
};
int main() {
int N, R;
cin >> N >> R;
R--;
vector<int> A(N);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
vector<int> edges[100000];
for (int i = 0; i < N - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
EulerTour et(N, edges, R);
int mx_len = *max_element(et.L.begin(), et.L.end());
int mx_depth = *max_element(depth, depth + N);
Segtree<int> st(mx_len + 1, mx_depth + 1);
for (int i = 0; i < N; i++) st.update(et.L[i], depth[i], A[i]);
int Q;
cin >> Q;
int last = 0;
while (Q--) {
int p, q;
scanf("%d %d", &p, &q);
int x = (p + last) % N, k = (q + last) % N;
int ds = depth[x];
int dt = min(mx_depth, ds + k);
int ans = st.between(et.L[x], et.R[x], ds, dt);
printf("%d\n", ans);
last = ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int a[100005];
int interval[100005][2];
vector<int> graph[100005];
int preorder[100005];
int invertorder[100005];
int height[100005];
int val = 0;
void dfs(int v, int par) {
preorder[val] = v;
invertorder[v] = val;
interval[v][0] = val;
val++;
for (int w : graph[v]) {
if (w != par) {
height[w] = height[v] + 1;
dfs(w, v);
}
}
interval[v][1] = val - 1;
}
struct node {
int val = 0;
node* c[2];
int query(int low, int high, int L, int R) {
if (low <= L && R <= high) return val;
if (R < low || high < L) return MOD;
int M = (L + R) / 2;
return min(c[0]->query(low, high, L, M), c[1]->query(low, high, M + 1, R));
}
void upd(int ind, int v, int L, int R) {
if (L == ind && R == ind) {
val = v;
return;
}
if (R < ind || ind < L) return;
int M = (L + R) / 2;
c[0] = new node(*c[0]), c[1] = new node(*c[1]);
c[0]->upd(ind, v, L, M);
c[1]->upd(ind, v, M + 1, R);
val = min(c[0]->val, c[1]->val);
}
void build(vector<int>& arr, int L, int R) {
if (L == R) {
if (L < (int)arr.size())
val = arr[L];
else
val = 0;
return;
}
int M = (L + R) / 2;
c[0] = new node();
c[0]->build(arr, L, M);
c[1] = new node();
c[1]->build(arr, M + 1, R);
val = min(c[0]->val, c[1]->val);
}
};
template <int SZ>
struct pers {
node* loc[SZ + 1];
int nex = 1;
pers() { loc[0] = new node(); }
void upd(int ind, int val) {
loc[nex] = new node(*loc[nex - 1]);
loc[nex]->upd(ind, val, 0, SZ - 1);
nex++;
}
void build(vector<int>& arr) { loc[0]->build(arr, 0, SZ - 1); }
int query(int ti, int low, int high) {
return loc[ti]->query(low, high, 0, SZ - 1);
}
};
pers<100005> p;
vector<int> lheight[100005];
vector<int> versions;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<int> arr;
int n, r;
cin >> n >> r;
r--;
for (int i = 0; i < n; i++) {
cin >> a[i];
arr.push_back(MOD);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
height[r] = 0;
dfs(r, -1);
for (int i = 0; i < n; i++) {
lheight[height[i]].push_back(i);
}
p.build(arr);
for (int i = 0; i < n; i++) {
for (int v : lheight[i]) {
p.upd(invertorder[v], a[v]);
}
versions.push_back(p.nex - 1);
}
int last = 0;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int pro, q;
cin >> pro >> q;
int v = (pro + last) % n;
int h = (q + last) % n;
int H = h + height[v];
last = p.query(versions[min(H, n - 1)], interval[v][0], interval[v][1]);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
using matrix = vector<vector<long long>>;
const int INF = 1e9 + 1;
struct node {
int val;
node *l, *r;
node() : val(INF), l(nullptr), r(nullptr){};
};
const int MAXN = 1e5 + 100;
int arr[MAXN];
int tin[MAXN], tout[MAXN], timer = 0;
int d[MAXN];
vector<int> g[MAXN], dep[MAXN];
node *T[MAXN];
void build(node *&root, int tl, int tr) {
if (tl + 1 == tr) {
return;
}
root->l = new node(), root->r = new node();
int tm = (tl + tr) >> 1;
build(root->l, tl, tm);
build(root->r, tm, tr);
}
void update(node *&prev, node *&root, int tl, int tr, int pos, int value) {
if (tl + 1 == tr) {
root->val = value;
return;
}
int tm = (tl + tr) >> 1;
if (pos < tm) {
root->l = new node(), root->r = prev->r;
update(prev->l, root->l, tl, tm, pos, value);
} else {
root->l = prev->l, root->r = new node();
update(prev->r, root->r, tm, tr, pos, value);
}
root->val = min(root->l->val, root->r->val);
}
int get(node *&root, int tl, int tr, int l, int r) {
if (tl >= r || tr <= l) {
return INF;
}
if (tl >= l && tr <= r) {
return root->val;
}
int tm = (tl + tr) >> 1;
int a = get(root->l, tl, tm, l, r);
int b = get(root->r, tm, tr, l, r);
return min(a, b);
}
void dfs(int u, int p) {
tin[u] = timer++;
dep[d[u]].push_back(u);
for (int to : g[u]) {
if (to == p) {
continue;
}
d[to] = d[u] + 1;
dfs(to, u);
}
tout[u] = timer;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, root;
cin >> n >> root;
root--;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
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);
}
d[root] = 1;
dfs(root, -1);
for (int i = 0; i <= n; ++i) {
T[i] = new node();
}
build(T[0], 0, n);
for (int i = 1; i <= n; ++i) {
node *prev = T[i - 1];
for (int j : dep[i]) {
node *cur = new node();
update(prev, cur, 0, n, tin[j], arr[j]);
prev = cur;
}
T[i] = prev;
}
int last = 0;
int q;
cin >> q;
while (q--) {
int P, Q;
cin >> P >> Q;
int x = (P + last) % n;
int k = (Q + last) % n;
int need = min(n, d[x] + k);
last = get(T[need], 0, n, tin[x], tout[x]);
cout << last << '\n';
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.