text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
struct segtree {
struct node {
int x0, x1;
};
node combine(node x, node y) { return {max(x.x0, y.x0), max(x.x1, y.x1)}; }
constexpr static node identity = {-inf, -inf};
vector<int> a, b;
vector<node> tree;
vector<bool> u;
int n;
segtree(vector<node>& v) {
n = 1 << int(ceil(log2(v.size())));
tree.resize(2 * n);
a.resize(2 * n);
b.resize(2 * n);
u.assign(2 * n, 0);
for (int i = 2 * n - 1; i > 0; i--) {
if (i >= n) {
a[i] = b[i] = i - n;
if (i - n < v.size()) {
tree[i] = v[i - n];
} else {
tree[i] = identity;
}
} else {
a[i] = a[2 * i];
b[i] = b[2 * i + 1];
tree[i] = combine(tree[2 * i], tree[2 * i + 1]);
}
}
}
void push(int i) {
if (!u[i]) return;
swap(tree[i].x0, tree[i].x1);
if (i < n) {
u[2 * i] = !u[2 * i];
u[2 * i + 1] = !u[2 * i + 1];
}
u[i] = 0;
}
void update(int l, int r, int i = 1) {
if (l <= a[i] && r >= b[i]) {
u[i] = !u[i];
}
push(i);
if (l > b[i] || r < a[i] || l <= a[i] && r >= b[i]) return;
update(l, r, 2 * i);
update(l, r, 2 * i + 1);
tree[i] = combine(tree[2 * i], tree[2 * i + 1]);
}
node query(int l, int r, int i = 1) {
push(i);
if (l <= a[i] && r >= b[i]) return tree[i];
if (l > b[i] || r < a[i]) return identity;
return combine(query(l, r, 2 * i), query(l, r, 2 * i + 1));
}
};
int n;
vector<vector<array<int, 2>>> adj;
int bfs(int i) {
vector<bool> v(n);
queue<int> q({i});
v[i] = 1;
int x;
while (!q.empty()) {
x = q.front();
q.pop();
for (auto& [t, j] : adj[x])
if (!v[j]) v[j] = 1, q.push(j);
}
return x;
}
vector<int> d, col;
vector<segtree::node> v;
int tt = 0;
vector<int> vin, vout;
void dfs(int i, int k) {
vin[i] = tt++;
if (col[i])
v.push_back({-inf, d[i]});
else
v.push_back({d[i], -inf});
for (auto& [t, j] : adj[i])
if (j != k) {
d[j] = d[i] + 1;
col[j] = col[i] ^ t;
dfs(j, i);
}
vout[i] = tt - 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
adj.resize(n);
vector<array<int, 2>> e;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
int t;
cin >> t;
adj[x].push_back({t, y}), adj[y].push_back({t, x});
e.push_back({x, y});
}
int r1 = bfs(0);
int r2 = bfs(r1);
0;
d.assign(n, 0);
col.assign(n, 0);
vin.assign(n, 0);
vout.assign(n, 0);
v.clear();
dfs(r1, r1);
vector<int> vin1(vin), vout1(vout);
segtree s1(v);
tt = 0;
d.assign(n, 0);
col.assign(n, 0);
vin.assign(n, 0);
vout.assign(n, 0);
v.clear();
dfs(r2, r2);
vector<int> vin2(vin), vout2(vout);
segtree s2(v);
int m;
cin >> m;
while (m--) {
int i;
cin >> i;
i--;
auto [x, y] = e[i];
0;
if (vin1[x] >= vin1[y])
s1.update(vin1[x], vout1[x]);
else
s1.update(vin1[y], vout1[y]);
if (vin2[x] >= vin2[y]) {
0;
s2.update(vin2[x], vout2[x]);
} else {
0;
s2.update(vin2[y], vout2[y]);
}
0;
0;
cout << max(s1.query(0, n - 1).x0, s2.query(0, n - 1).x0) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int n;
int u[1 << 19], v[1 << 19];
vector<pair<int, int> > nei[1 << 19];
int dep[1 << 19];
struct Segtree {
int mn[1 << 20], mx[1 << 20], tag[1 << 20];
void inline pu(int now) {
mn[now] = min(mn[now << 1], mn[now << 1 | 1]);
mx[now] = max(mx[now << 1], mx[now << 1 | 1]);
}
void inline rev(int now) {
swap(mn[now], mx[now]);
mn[now] = -mn[now];
mx[now] = -mx[now];
}
void inline pd(int now) {
if (tag[now]) {
tag[now << 1] ^= 1;
tag[now << 1 | 1] ^= 1;
rev(now << 1), rev(now << 1 | 1);
tag[now] = 0;
}
}
void init(int now = 1, int nl = 1, int nr = n) {
if (nl == nr) return void(mn[now] = mx[now] = dep[nl]);
int m = (nl + nr) >> 1;
init(now << 1, nl, m);
init(now << 1 | 1, m + 1, nr);
pu(now);
}
void change(int l, int r, int now = 1, int nl = 1, int nr = n) {
if (nl >= l && nr <= r) {
tag[now] ^= 1;
rev(now);
return;
}
if (nl > r || nr < l) return;
pd(now);
int m = (nl + nr) >> 1;
change(l, r, now << 1, nl, m);
change(l, r, now << 1 | 1, m + 1, nr);
pu(now);
}
} s1, s2;
int dps = -1, dpi;
int b1[1 << 19], e1[1 << 19], b2[1 << 19], e2[1 << 19], tmc;
void dfs(int now, int lst = 0, int lvl = 0, int col = 0) {
if (lvl > dps) {
dps = lvl;
dpi = now;
}
b2[now] = ++tmc;
dep[tmc] = (col ? -1 : 1) * lvl;
for (int i = 0; i < (((int)(nei[now]).size())); ++i) {
int to = nei[now][i].first;
if (to == lst) continue;
dfs(to, now, lvl + 1, col ^ nei[now][i].second);
}
e2[now] = tmc;
}
void inline change(int a) {
int u = ::u[a], v = ::v[a];
if (b1[u] > b1[v]) swap(u, v);
s1.change(b1[v], e1[v]);
if (b2[u] > b2[v]) swap(u, v);
s2.change(b2[v], e2[v]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= (n - 1); ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
nei[a].push_back(make_pair(b, c));
u[i] = a;
nei[b].push_back(make_pair(a, c));
v[i] = b;
}
int r1, r2;
dfs(1);
r1 = dpi;
tmc = 0;
dps = -1;
dfs(r1);
memcpy(b1, b2, sizeof(b1));
memcpy(e1, e2, sizeof(e1));
s1.init();
r2 = dpi;
tmc = 0;
dfs(r2);
s2.init();
int m;
scanf("%d", &m);
while (m--) {
int a;
scanf("%d", &a);
change(a);
printf("%d\n", max(s1.mx[1], s2.mx[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
struct Node {
Node *l = 0, *r = 0;
int lo, hi;
int mx[2];
bool lz = 0;
Node(int _lo, int _hi) : lo(_lo), hi(_hi) { mx[0] = mx[1] = 0; }
Node(ii v[], int _lo, int _hi) : lo(_lo), hi(_hi) {
mx[0] = mx[1] = 0;
if (lo + 1 < hi) {
int mid = lo + (hi - lo) / 2;
l = new Node(v, lo, mid);
r = new Node(v, mid, hi);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
} else {
mx[v[lo].first] = v[lo].second;
}
}
void upd() {
swap(mx[0], mx[1]);
lz ^= 1;
}
void flip(int L, int R) {
if (R <= lo || hi <= L) return;
if (L <= lo && hi <= R) {
upd();
} else {
push(), l->flip(L, R), r->flip(L, R);
for (int i : {0, 1}) mx[i] = max(l->mx[i], r->mx[i]);
}
}
void push() {
if (lo + 1 < hi and lz) {
l->upd(), r->upd();
}
lz = 0;
}
};
const int N = 5e5 + 5;
int n, q;
int l[N], r[N], w[N];
vi g[N];
int d1, d2;
int tym;
ii dis[N];
int IN[N], OUT[N];
int EDGE[N];
ii dis_[N];
void dfs(int u, int daddy, int pe) {
IN[u] = ++tym;
EDGE[pe] = u;
for (int i : g[u]) {
int v = l[i] ^ r[i] ^ u;
if (v != daddy) {
dis[v] = {dis[u].first ^ w[i], dis[u].second + 1};
dfs(v, u, i);
}
}
OUT[u] = tym;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d %d", &l[i], &r[i], &w[i]);
g[l[i]].emplace_back(i);
g[r[i]].emplace_back(i);
}
dis[1] = {0, 0};
dfs(1, 0, 0);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d1 = i;
mx = dis[i].second;
}
}
}
vi in[2], out[2], e[2];
Node *t[2];
dis[d1] = {0, 0}, tym = 0;
dfs(d1, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
t[0] = new Node(dis_, 1, n + 1);
in[0] = vi(IN, IN + 1 + n);
out[0] = vi(OUT, OUT + 1 + n);
e[0] = vi(EDGE, EDGE + 1 + n);
{
int mx = INT_MIN;
for (int i = 1; i <= n; ++i) {
if (dis[i].second > mx) {
d2 = i;
mx = dis[i].second;
}
}
}
dis[d2] = {0, 0}, tym = 0;
dfs(d2, 0, 0);
for (int i = 1; i <= n; ++i) {
dis_[IN[i]] = dis[i];
}
t[1] = new Node(dis_, 1, n + 1);
in[1] = vi(IN, IN + 1 + n);
out[1] = vi(OUT, OUT + 1 + n);
e[1] = vi(EDGE, EDGE + 1 + n);
scanf("%d", &q);
while (q--) {
int id;
scanf("%d", &id);
int ans = 0;
for (int i : {0, 1}) {
t[i]->flip(in[i][e[i][id]], out[i][e[i][id]] + 1);
ans = max(ans, t[i]->mx[0]);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const long long mod = 1e9 + 7;
long long n;
vector<vector<pair<long long, long long>>> g;
long long far(long long v) {
vector<long long> d(n + 1, -1);
d[v] = 0;
queue<long long> q;
q.push(v);
while (!q.empty()) {
long long s = q.front();
q.pop();
for (auto x : g[s]) {
long long u = x.first;
if (d[u] == -1) {
d[u] = d[s] + 1;
q.push(u);
}
}
}
long long id = 1;
for (long long i = 2; i <= n; ++i) {
if (d[i] > d[id]) id = i;
}
return id;
}
void dfs(long long v, long long p, vector<long long>& tin,
vector<long long>& tout, vector<long long>& d, vector<long long>& h,
vector<long long>& e, long long& timer) {
tin[v] = timer++;
e.push_back(v);
for (auto x : g[v]) {
long long u = x.first, w = x.second;
if (u == p) continue;
d[u] = (d[v] + w) % 2;
h[u] = h[v] + 1;
dfs(u, v, tin, tout, d, h, e, timer);
}
tout[v] = timer;
}
struct segtree {
long long size;
vector<vector<long long>> tree;
vector<long long> modify;
segtree(long long n) {
size = 1;
while (size < n) size <<= 1;
tree.resize(2 * size - 1, vector<long long>(2));
modify.resize(2 * size - 1);
}
void get(long long v) {
tree[v][0] = max(tree[2 * v + 1][0], tree[2 * v + 2][0]);
tree[v][1] = max(tree[2 * v + 1][1], tree[2 * v + 2][1]);
}
void push(long long v) {
if (modify[v]) {
modify[2 * v + 1] ^= 1;
modify[2 * v + 2] ^= 1;
swap(tree[2 * v + 1][0], tree[2 * v + 1][1]);
swap(tree[2 * v + 2][0], tree[2 * v + 2][1]);
}
modify[v] = 0;
}
void upd(long long v, long long lx, long long rx, long long l, long long h,
long long d) {
if (lx + 1 == rx) {
tree[v][d] = h;
return;
}
long long m = (lx + rx) / 2;
if (l < m)
upd(2 * v + 1, lx, m, l, h, d);
else
upd(2 * v + 2, m, rx, l, h, d);
get(v);
}
void upd(long long l, long long h, long long d) { upd(0, 0, size, l, h, d); }
void rev(long long v, long long lx, long long rx, long long l, long long r) {
if (l <= lx and rx <= r) {
modify[v] ^= 1;
swap(tree[v][0], tree[v][1]);
return;
}
if (rx <= l or r <= lx) {
return;
}
push(v);
long long m = (lx + rx) / 2;
rev(2 * v + 1, lx, m, l, r);
rev(2 * v + 2, m, rx, l, r);
get(v);
}
void rev(long long l, long long r) { rev(0, 0, size, l, r); }
long long ans() { return tree[0][0]; }
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
g.resize(n + 1);
vector<vector<long long>> edges;
for (long long i = 0, u, v, w; i < n - 1; ++i) {
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
edges.push_back({u, v});
}
long long S = far(1), T = far(S);
vector<long long> tin1(n + 1), tin2(n + 1), h1(n + 1), h2(n + 1),
tout1(n + 1), tout2(n + 1), d1(n + 1), d2(n + 1), e1, e2;
long long timer = 0;
dfs(S, -1, tin1, tout1, d1, h1, e1, timer);
timer = 0;
dfs(T, -1, tin2, tout2, d2, h2, e2, timer);
segtree ST1(n), ST2(n);
for (long long i = 0; i < n; ++i) {
ST1.upd(i, h1[e1[i]], d1[e1[i]]);
ST2.upd(i, h2[e2[i]], d2[e2[i]]);
}
long long q;
cin >> q;
while (q-- > 0) {
long long id;
cin >> id;
id--;
long long u = edges[id][0], v = edges[id][1];
if (h1[u] > h1[v])
ST1.rev(tin1[u], tout1[u]);
else
ST1.rev(tin1[v], tout1[v]);
if (h2[u] > h2[v])
ST2.rev(tin2[u], tout2[u]);
else
ST2.rev(tin2[v], tout2[v]);
cout << max(ST1.ans(), ST2.ans()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
virtual void update() {}
virtual void push() {}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
virtual void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
update();
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() override {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() override {}
static void push_back(splay_tree_vchs*& u, const pnode& key) {
if (!u) {
u = new splay_tree_vchs(key);
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = new splay_tree_vchs(key);
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
}
static void erase(splay_tree_vchs*& u, splay_tree_vchs* v) {
v->splay();
if (!v->ch[0]) {
u = v->ch[1];
} else if (!v->ch[1]) {
u = v->ch[0];
} else {
u = v->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = v->ch[1];
v->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
delete v;
}
};
template <typename pnode>
struct splay_tree_lct : splay_tree<pnode> {
using splay_tree<pnode>::ch;
bool rev;
splay_tree_vchs<pnode>*root, *parent;
splay_tree_lct() : splay_tree<pnode>() {
root = parent = NULL;
rev = 0;
}
virtual void update() override {}
virtual void push() override {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
virtual void rotate() override {
swap(this->parent, this->p->parent);
splay_tree<pnode>::rotate();
}
virtual void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() override {
splay_tree::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void update_vsub(node* v, bool add) {
if (add) {
splay_tree_vchs<node*>::push_back(root, v);
v->parent = root;
} else {
splay_tree_vchs<node*>::erase(root, v->parent);
v->parent = NULL;
}
}
void push() override { splay_tree_lct::push(); }
void reverse() override {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
enum seg_type { seg_not_lazy, seg_lazy, seg_beats };
template <class node, seg_type type>
struct segment_tree {
using node_container = typename node::node_container;
using lazy_container = typename node::lazy_container;
private:
template <const bool T = (type != seg_not_lazy),
typename enable_if<T, bool>::type = 0>
inline void push(int x, int b, int e, int m) {
if (st[x].lazy()) {
st[x + 1].apply(b, m, st[x].lazy);
st[x + ((m - b) << 1)].apply(m, e, st[x].lazy);
st[x].lazy = lazy_container();
}
}
template <const bool T = (type != seg_not_lazy),
typename enable_if<!T, bool>::type = 0>
inline void push(int x, int b, int e, int m) {}
template <typename RAIter>
void build(int x, int b, int e, const RAIter &a) {
if (b + 1 == e) {
st[x].nod.build(a[b]);
return;
}
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
build(x + 1, b, m, a);
build(y, m, e, a);
st[x].nod = st[x + 1].nod + st[y].nod;
}
template <const bool T = (type == seg_beats),
typename enable_if<!T, bool>::type = 0>
void update_(int x, int b, int e) {
if (lo <= b && e <= hi) {
st[x].apply(b, e, lazy);
return;
}
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
push(x, b, e, m);
if (lo < m) update_(x + 1, b, m);
if (m < hi) update_(y, m, e);
st[x].nod = st[x + 1].nod + st[y].nod;
}
template <const bool T = (type == seg_beats),
typename enable_if<T, bool>::type = 0>
void update_(int x, int b, int e) {
if (st[x].break_condition(lazy)) return;
if (lo <= b && e <= hi && st[x].tag_condition(lazy)) {
st[x].apply(b, e, lazy);
return;
}
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
push(x, b, e, m);
if (lo < m) update_(x + 1, b, m);
if (m < hi) update_(y, m, e);
st[x].nod = st[x + 1].nod + st[y].nod;
}
node_container query(int x, int b, int e) {
if (lo <= b && e <= hi) return st[x].nod;
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
push(x, b, e, m);
if (m >= hi) return query(x + 1, b, m);
if (m <= lo) return query(y, m, e);
return query(x + 1, b, m) + query(y, m, e);
}
template <class P>
int find_first(int x, int b, int e, const P &f) {
if (b + 1 == e) return f(st[x]) ? b : -1;
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
push(x, b, e, m);
if (lo < m && f(st[x + 1])) {
auto t = find_first(x + 1, b, m, f);
if (t != -1) return t;
}
if (m < hi && f(st[y])) return find_first(y, m, e, f);
return -1;
}
template <class P>
int find_last(int x, int b, int e, const P &f) {
if (b + 1 == e) return f(st[x]) ? b : -1;
int m = (b + e) >> 1;
int y = x + ((m - b) << 1);
push(x, b, e, m);
if (m < hi && f(st[y])) {
auto t = find_last(y, m, e, f);
if (t != -1) return t;
}
if (lo < m && f(st[x + 1])) return find_last(x + 1, b, m, f);
return -1;
}
lazy_container lazy;
int n, lo, hi;
vector<node> st;
public:
template <typename RAIter>
void build(const RAIter &a) {
build(0, 0, n, a);
}
void update(int l, int r, const lazy_container &x) {
lo = l, hi = r, lazy = x, update_(0, 0, n);
}
node_container query(int l, int r) { return lo = l, hi = r, query(0, 0, n); }
template <class P>
int find_first(int l, int r, const P &f) {
return lo = l, hi = r, find_first(0, 0, n, f);
}
template <class P>
int find_last(int l, int r, const P &f) {
return lo = l, hi = r, find_last(0, 0, n, f);
}
segment_tree(int n) : n(n), st(2 * n - 1) {}
};
struct node {
struct node_container {
struct data {
int a, b, c, ab, bc, abc;
data() { a = b = c = ab = bc = abc = -(1 << 20); }
friend data operator+(const data &l, const data &r) {
data res;
res.a = max(l.a, r.a);
res.b = max(l.b, r.b);
res.c = max(l.c, r.c);
res.ab = max({l.ab, r.ab, l.a + r.b});
res.bc = max({l.bc, r.bc, l.b + r.c});
res.abc = max({l.abc, r.abc, l.a + r.bc, l.ab + r.c});
return res;
}
};
array<data, 2> d;
template <typename T>
inline void build(T a) {
int t = a >= 1 << 30;
if (t) a -= 1 << 30;
d[0].b = d[1].b = -2 * a;
d[t].a = d[t].c = a;
d[t].ab = d[t].bc = -a;
d[t].abc = 0;
}
friend node_container operator+(node_container l, const node_container &r) {
node_container a;
a.d = {l.d[0] + r.d[0], l.d[1] + r.d[1]};
return a;
}
node_container() {}
} nod;
struct lazy_container {
int rev = 0;
inline bool operator()() { return rev; }
lazy_container(int rev = 0) : rev(rev) {}
} lazy;
inline void apply(int l, int r, lazy_container &p) {
lazy.rev ^= 1;
swap(nod.d[0], nod.d[1]);
}
};
struct diameter {
int n;
vector<array<int, 3>> edges;
vector<vector<array<int, 2>>> g;
vector<int> h, tin, tout, tour;
segment_tree<node, seg_lazy> st;
diameter(vector<array<int, 3>> el)
: n(el.size() + 1),
edges(el),
g(n),
h(n),
tin(n),
tout(n),
st(2 * n - 1) {
for (auto &[x, y, z] : el) {
g[x].push_back({y, z});
g[y].push_back({x, z});
}
dfs(0, 0);
for (auto &[x, y, z] : edges)
if (tin[x] > tin[y]) swap(x, y);
st.build(tour.begin());
}
void dfs(int v, int dep) {
tin[v] = tour.size();
tour.push_back(dep + (h[v] << 30));
for (auto &[i, w] : g[v]) {
g[i].erase(find(g[i].begin(), g[i].end(), array<int, 2>{v, w}));
h[i] = h[v] ^ w;
dfs(i, dep + 1);
tour.push_back(dep + (h[v] << 30));
}
tout[v] = tour.size();
}
int update(int v) {
v = edges[v][1];
st.update(tin[v], tout[v], node::lazy_container(1));
auto t = st.query(0, 2 * n - 1);
return max(t.d[0].abc, t.d[1].abc);
}
};
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, x, y;
cin >> n;
vector<array<int, 3>> er(n - 1);
for (auto &i : er) cin >> i[0] >> i[1] >> i[2], --i[0], --i[1];
diameter d(er);
for (cin >> x; x--;) {
cin >> y;
cout << d.update(--y) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode> {
splay_tree_vchs vnode;
using splay_tree<pnode>::ch;
bool rev;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode>() {
root = NULL;
rev = 0;
}
void update() {}
void push() {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
void rotate() {
swap(vnode, this->p->vnode);
splay_tree<pnode>::rotate();
}
void splay() {
auto v = &vnode;
bool r = !v->key;
splay_tree<pnode>::splay();
if (r && v->key) {
if (v->p) v->p->ch[v->p->ch[1] == &v->key->vnode] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
v->key = static_cast<pnode>(this);
}
}
void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs(v);
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
x->key = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs() : key(NULL){};
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() { splay_tree_lct::push(); }
void reverse() {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 5e5 + 5;
vector<pair<int, int> > g[mxn];
int n, m, root;
int bg[mxn], ed[mxn], cur;
int dep[mxn];
int pari[mxn];
int ord[mxn];
pair<int, int> edge[mxn];
inline void dfs(int x, int par, int Pa, int deep) {
Pa %= 2;
bg[x] = ++cur;
dep[x] = deep;
pari[x] = Pa;
ord[cur] = x;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) dfs(y, x, Pa + g[x][i].second, deep + 1);
}
ed[x] = cur;
}
struct Segt {
int val1[mxn << 3], val2[mxn << 3];
int lazy[mxn << 3];
int le[mxn << 3], ri[mxn << 3];
inline void init() {
memset(val1, -1, sizeof(val1));
memset(val2, -1, sizeof(val2));
memset(lazy, 0, sizeof(lazy));
}
inline void pushdown(int x) {
if (lazy[x]) {
lazy[x] = 0;
swap(val1[x << 1], val2[x << 1]);
swap(val1[x << 1 | 1], val2[x << 1 | 1]);
lazy[x << 1] ^= 1;
lazy[x << 1 | 1] ^= 1;
}
}
inline void pushup(int x) {
pushdown(x);
val1[x] = -1, val2[x] = -1;
if (val1[x << 1] != -1) val1[x] = max(val1[x], val1[x << 1]);
if (val2[x << 1] != -1) val2[x] = max(val2[x], val2[x << 1]);
if (val1[x << 1 | 1] != -1) val1[x] = max(val1[x], val1[x << 1 | 1]);
if (val2[x << 1 | 1] != -1) val2[x] = max(val2[x], val2[x << 1 | 1]);
}
inline void build(int x, int l, int r) {
le[x] = l, ri[x] = r;
if (l == r) {
if (pari[ord[l]])
val2[x] = dep[ord[l]];
else
val1[x] = dep[ord[l]];
return;
}
int md = l + r >> 1;
build(x << 1, l, md);
build(x << 1 | 1, md + 1, r);
pushup(x);
}
inline void upd(int x, int l, int r, int a, int b) {
if (r < a or b < l) return;
pushdown(x);
if (a <= l and r <= b) {
swap(val1[x], val2[x]);
lazy[x] = 1;
pushdown(x);
return;
}
int md = l + r >> 1;
upd(x << 1, l, md, a, b);
upd(x << 1 | 1, md + 1, r, a, b);
pushup(x);
}
inline int ask() { return val1[1]; }
} seg;
int dist[mxn];
inline void getd(int x, int par = -1, int dis = 0) {
dist[x] = dis;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) getd(y, x, dis + 1);
}
}
int root1, root2;
int tans[mxn];
int asks[mxn];
inline void solve() {
scanf("%d", &n);
for (int i = 1, u, v, t; i < n; ++i) {
scanf("%d%d%d", &u, &v, &t);
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
edge[i] = make_pair(u, v);
}
for (int i = 1; i <= n; ++i) {
if (g[i].size() == 1) {
root = i;
break;
}
}
memset(dist, 0, sizeof(dist));
int mw = root;
getd(root, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] > dist[mw]) mw = i;
root1 = mw;
memset(dist, 0, sizeof(dist));
mw = root1;
getd(root1, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] >= dist[mw]) mw = i;
root2 = mw;
scanf("%d", &m);
dfs(root1, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
asks[i] = x;
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
tans[i] = seg.ask();
}
cur = 0;
memset(bg, 0, sizeof(bg));
memset(ed, 0, sizeof(ed));
memset(dep, 0, sizeof(dep));
memset(pari, 0, sizeof(pari));
memset(ord, 0, sizeof(ord));
dfs(root2, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x = asks[i];
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
printf("%d\n", max(seg.ask(), tans[i]));
}
}
int main() {
ios_base::sync_with_stdio(false);
int T = 1;
for (; T--;) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct Info {
int u, type;
};
const int INF = 1e9;
struct segment_tree {
vector<int> _max1;
vector<int> _max2;
vector<int> promise;
vector<bool> used;
vector<int> tin;
vector<int> tout;
int timer;
segment_tree(vector<vector<Info> > &g, int _u) {
timer = 0;
int n = (1 << 21);
_max1.resize(n, 0);
_max2.resize(n, 0);
used.resize(n, false);
tin.resize(1 << 20);
tout.resize(1 << 20);
dfs1(_u, g, 0, 0);
promise.resize(n, -INF);
build();
}
void build() {
int now = (1 << 19) - 2;
while (now >= 0) {
promise[now] = 0;
_max1[now] = max(_max1[now * 2 + 1], _max1[now * 2 + 2]);
_max2[now] = max(_max2[now * 2 + 1], _max2[now * 2 + 2]);
now--;
}
}
void dfs1(int v, vector<vector<Info> > &g, int parity, int height) {
tin[v] = timer++;
if (parity == 0)
_max1[(1 << 19) - 1 + tin[v]] = height;
else
_max2[(1 << 19) - 1 + tin[v]] = height;
used[v] = true;
for (auto [_u, _type] : g[v]) {
if (!used[_u]) {
dfs1(_u, g, parity ^ _type, height + 1);
}
}
tout[v] = timer;
}
void push(int v) {
if (promise[v] == 1) {
promise[v] = 0;
swap(_max1[2 * v + 1], _max2[2 * v + 1]);
swap(_max1[2 * v + 2], _max2[2 * v + 2]);
promise[2 * v + 1] ^= 1;
promise[2 * v + 2] ^= 1;
}
}
void updute(int v, int l, int r, int lq, int rq) {
if (lq >= r || l >= rq) {
return;
}
if (l >= lq && r <= rq) {
promise[v] ^= 1;
swap(_max1[v], _max2[v]);
return;
}
push(v);
int m = (l + r) / 2;
updute(v * 2 + 1, l, m, lq, rq);
updute(v * 2 + 2, m, r, lq, rq);
_max1[v] = max(_max1[2 * v + 1], _max1[2 * v + 2]);
_max2[v] = max(_max2[2 * v + 1], _max2[2 * v + 2]);
}
int Answer(int q) {
updute(0, 0, (1 << 19), tin[q], tout[q]);
return _max1[0];
}
void write(int v, int l, int r) {
push(v);
if (l + 1 == r) {
cout << _max1[v] << ' ' << _max2[v] << '\n';
return;
}
int m = (l + r) / 2;
write(v * 2 + 1, l, m);
write(v * 2 + 2, m, r);
}
};
void dfs(int v, vector<bool> &used, vector<vector<Info> > &g, vector<int> &d) {
used[v] = true;
for (auto [_u, _type] : g[v]) {
if (!used[_u]) {
d[_u] = d[v] + 1;
dfs(_u, used, g, d);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<Info> > g(n);
vector<pair<int, int> > numbers;
for (int i = 0; i < n - 1; ++i) {
int _u, _v, _type;
cin >> _v >> _u >> _type;
numbers.push_back({_v - 1, _u - 1});
g[_v - 1].push_back(Info{_u - 1, _type});
g[_u - 1].push_back(Info{_v - 1, _type});
}
vector<bool> used(n, false);
vector<int> d(n, 0);
dfs(0, used, g, d);
int _u = 0;
for (int i = 0; i < n; ++i) {
if (d[i] > d[_u]) {
_u = i;
}
}
used.assign(n, false);
d.assign(n, 0);
dfs(_u, used, g, d);
int _v = 0;
for (int i = 0; i < n; ++i) {
if (d[i] > d[_v]) {
_v = i;
}
}
segment_tree st1(g, _u);
segment_tree st2(g, _v);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int q, q1, q2;
cin >> q;
if (st1.tin[numbers[q - 1].first] > st1.tin[numbers[q - 1].second])
q1 = numbers[q - 1].first;
else
q1 = numbers[q - 1].second;
if (st2.tin[numbers[q - 1].first] > st2.tin[numbers[q - 1].second])
q2 = numbers[q - 1].first;
else
q2 = numbers[q - 1].second;
cout << max(st1.Answer(q1), st2.Answer(q2)) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
void chkmax(T& x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T& x, T y) {
if (x > y) x = y;
}
inline int read() {
int x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return x;
}
const int maxn = 5e5 + 10;
int n, q;
int S, T, ecnt = 1, h[maxn], eid[maxn << 1];
struct edges {
int nxt, to, w;
} E[maxn << 1];
void addline(int u, int v, int w) { E[++ecnt] = {h[u], v, w}, h[u] = ecnt; }
int dfn[maxn], arr[maxn], dis[maxn], col[maxn], sz[maxn];
int bfs(int S) {
static int Q[maxn];
memset(dis, -1, sizeof dis);
int l = 1, r = 1;
Q[1] = S, dis[S] = 0;
while (l <= r) {
int u = Q[l++];
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (dis[v] == -1) dis[v] = dis[u] + 1, Q[++r] = v;
}
}
int res = S;
for (int i = (1), iend = (n); i <= iend; ++i)
if (dis[res] < dis[i]) res = i;
return res;
}
void dfs(int u, int f) {
static int now;
dfn[u] = ++now, arr[now] = u, sz[u] = 1;
for (int i = h[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v != f) {
col[v] = col[u] ^ E[i].w, eid[i ^ 1] = eid[i] = v, dfs(v, u),
sz[u] += sz[v];
}
}
}
struct SGT {
int val[maxn << 2][2], tag[maxn << 2];
void maintain(int k) {
for (int t = (0), tend = (1); t <= tend; ++t)
val[k][t] = max(val[k << 1][t], val[k << 1 | 1][t]);
}
void pushtag(int k) { tag[k] ^= 1, swap(val[k][0], val[k][1]); }
void pushdown(int k) {
if (tag[k]) tag[k] = 0, pushtag(k << 1), pushtag(k << 1 | 1);
}
void build(int k, int l, int r) {
if (l == r)
return val[k][col[arr[l]]] = dis[arr[l]], val[k][col[arr[l]] ^ 1] = -1,
void();
build(k << 1, l, ((l + r) >> 1)), build(k << 1 | 1, ((l + r) >> 1) + 1, r),
maintain(k);
}
void upd(int k, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return pushtag(k), void();
pushdown(k);
if (ql <= ((l + r) >> 1)) upd(k << 1, l, ((l + r) >> 1), ql, qr);
if (qr > ((l + r) >> 1)) upd(k << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr);
maintain(k);
}
int getc(int k, int l, int r, int p) {
if (l == r) return val[k][0] == -1 ? 1 : 0;
return pushdown(k), p <= ((l + r) >> 1)
? getc(k << 1, l, ((l + r) >> 1), p)
: getc(k << 1 | 1, ((l + r) >> 1) + 1, r, p);
}
} TS, TT;
void solve() {
cin >> n;
for (int i = (2), iend = (n); i <= iend; ++i) {
int u = read(), v = read(), w = read();
addline(u, v, w), addline(v, u, w);
}
dfs(1, 0);
S = bfs(1), T = bfs(S);
TS.build(1, 1, n);
bfs(T);
TT.build(1, 1, n);
cin >> q;
while (q--) {
int id = read(), v = eid[id * 2];
TS.upd(1, 1, n, dfn[v], dfn[v] + sz[v] - 1);
TT.upd(1, 1, n, dfn[v], dfn[v] + sz[v] - 1);
int cs = TS.getc(1, 1, n, dfn[S]), ct = TT.getc(1, 1, n, dfn[T]);
printf("%d\n", max(TS.val[1][cs], TT.val[1][ct]));
}
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
class Scanner {
private:
static const int BUFFER_SIZE = 1 << 18;
char buff[BUFFER_SIZE];
char *buffPos, *buffLim;
FILE* file;
public:
Scanner(FILE* file) {
this->file = file;
buffLim = buff + fread(buff, 1, BUFFER_SIZE, file);
buffPos = buff;
}
private:
inline void flushBuff() {
buffLim = buff + fread(buff, 1, BUFFER_SIZE, file);
if (buffLim == buff) {
*buffLim++ = '\n';
}
buffPos = buff;
}
inline bool isWS(char t) { return t <= ' '; }
inline bool isDig(char t) { return t >= '0' && t <= '9'; }
inline void nextPos() {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
public:
inline char getchar() {
char ch = *buffPos;
nextPos();
return ch;
}
inline void next(char* s) {
while (isWS(*buffPos)) {
nextPos();
}
while (!isWS(*buffPos)) {
*s = *buffPos;
s++;
nextPos();
}
*s = '\0';
}
inline void nextLine(char* s) {
while (*buffPos != '\n') {
nextPos();
}
if (*buffPos == '\n') {
nextPos();
}
while (*buffPos != '\n') {
*s++ = *buffPos;
nextPos();
}
*s = '\0';
}
inline int nextInt() {
while (!isDig(*buffPos) && *buffPos != '-') {
nextPos();
}
int sign = (*buffPos == '-') ? nextPos(), -1 : 1;
int res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
return res * sign;
}
inline long long nextLong() {
while (!isDig(*buffPos) && *buffPos != '-') {
nextPos();
}
long long sign = (*buffPos == '-') ? nextPos(), -1 : 1;
long long res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
return res * sign;
}
inline int n() {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
int res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = res * 10 + (*buffPos - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nl() {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = res * 10 + (*buffPos - '0');
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline long long nlm(const int MOD) {
while (*buffPos < '0' || *buffPos > '9') {
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
long long res = 0;
while (*buffPos >= '0' && *buffPos <= '9') {
res = (res * 10 + (*buffPos - '0')) % MOD;
buffPos++;
if (buffPos == buffLim) {
flushBuff();
}
}
return res;
}
inline double nextDouble() {
while (isWS(*buffPos)) {
nextPos();
}
int sign = (*buffPos == '-') ? nextPos(), -1 : 1;
double res = 0;
while (isDig(*buffPos)) {
res = res * 10 + *buffPos - '0';
nextPos();
}
if (*buffPos == '.') {
nextPos();
double ep = 1;
while (isDig(*buffPos)) {
ep *= 0.1;
res += ep * (*buffPos - '0');
nextPos();
}
}
return sign * res;
}
inline char nextChar() {
while (isWS(*buffPos)) nextPos();
char res = *buffPos;
nextPos();
return res;
}
~Scanner() { fclose(file); }
};
Scanner sc(stdin);
template <class __TyFirst, class __TySecond>
std::ostream& operator<<(std::ostream& out,
const std::pair<__TyFirst, __TySecond>& o);
static std::string cout_list_sep = " ";
template <
class IterateType, typename = decltype(std::declval<IterateType>().begin()),
typename = decltype(std::declval<IterateType>().end()),
typename = typename std::enable_if<std::is_convertible<
typename std::iterator_traits<
typename IterateType::iterator>::iterator_category,
std::input_iterator_tag>::value>::type,
typename = typename std::enable_if<!std::is_base_of<
std::string, typename std::decay<IterateType>::type>::value>::type,
typename value_type = typename IterateType::value_type>
std::ostream& operator<<(std::ostream& out, const IterateType& a) {
for (const auto& i : a) out << i << cout_list_sep;
return out;
}
template <class __TyFirst, class __TySecond>
std::ostream& operator<<(std::ostream& out,
const std::pair<__TyFirst, __TySecond>& o) {
out << "(" << o.first << "," << o.second << ")";
return out;
}
template <typename _ForwardIterator>
void logArray(_ForwardIterator, _ForwardIterator, const char* = 0) {}
namespace Temps {
template <typename _IntType>
class RangeInt {
static_assert(std::is_integral<_IntType>::value,
"RangeInt object must have integral value type");
public:
class iterator : public std::iterator<std::input_iterator_tag, _IntType,
_IntType, const _IntType*, _IntType> {
_IntType val, step;
public:
using typename std::iterator<std::input_iterator_tag, _IntType, _IntType,
const _IntType*, _IntType>::reference;
explicit constexpr iterator(int val, int step) noexcept
: val(val), step(step) {}
constexpr iterator& operator++() noexcept {
val += step;
return *this;
}
constexpr iterator operator++(int) noexcept {
iterator ret = *this;
val += step;
return ret;
}
constexpr bool operator==(const iterator& rhs) const noexcept {
return val == rhs.val;
}
constexpr bool operator!=(const iterator& rhs) const noexcept {
return val != rhs.val;
}
constexpr reference operator*() const { return val; }
};
const _IntType _begin, _step, _end;
explicit constexpr RangeInt(const _IntType end) noexcept
: _begin(0), _step(1), _end(end > 0 ? end : 0) {}
explicit constexpr RangeInt(const _IntType begin, const _IntType end) noexcept
: _begin(begin), _step(1), _end(end > begin ? end : begin) {}
explicit constexpr RangeInt(const _IntType begin, const _IntType end,
const _IntType step)
: _begin(begin),
_step(step),
_end(((step > 0 && end <= begin) || (step < 0 && end >= begin))
? begin
: (step > 0
? begin + (end - begin + step - 1) / step * step
: begin + (begin - end - step - 1) / (-step) * step)) {}
constexpr iterator begin() const noexcept { return iterator(_begin, _step); }
constexpr iterator end() const noexcept { return iterator(_end, _step); }
constexpr _IntType size() const noexcept { return (_end - _begin) / _step; }
};
template <class IntType, typename = typename std::enable_if<
std::is_integral<IntType>::value>::type>
inline constexpr RangeInt<IntType> range(IntType arg1) {
return RangeInt<IntType>(arg1);
}
template <class IntType, typename = typename std::enable_if<
std::is_integral<IntType>::value>::type>
inline constexpr RangeInt<IntType> range(IntType arg1, IntType arg2) {
return RangeInt<IntType>(arg1, arg2);
}
template <class IntType, typename = typename std::enable_if<
std::is_integral<IntType>::value>::type>
inline constexpr RangeInt<IntType> range(IntType arg1, IntType arg2,
IntType arg3) {
return RangeInt<IntType>(arg1, arg2, arg3);
}
} // namespace Temps
using Temps::range;
namespace Temps {
template <class T>
inline bool checkMin(T& a, T b) {
return (b < a ? a = b, 1 : 0);
}
template <class T>
inline bool checkMax(T& a, T b) {
return (a < b ? a = b, 1 : 0);
}
template <class IntType, typename = typename std::enable_if<
std::is_integral<IntType>::value>::type>
IntType gcd(const IntType a, const IntType b) {
return b == 0 ? a : gcd(b, a % b);
}
template <class ForwardIterator, class OutputIterator>
void dissociate(ForwardIterator __begin, ForwardIterator __end,
OutputIterator __dest) {
std::vector<typename std::iterator_traits<ForwardIterator>::_IntType> values(
__begin, __end);
std::sort(values.begin(), values.end());
std::unique(values.begin(), values.end());
while (__begin != __end) {
*__dest =
std::distance(values.begin(),
std::lower_bound(values.begin(), values.end(), *__begin));
__dest++;
__begin++;
}
}
} // namespace Temps
using Temps::checkMax;
using Temps::checkMin;
namespace Temps {
template <class Type>
class Vector {
static_assert(std::is_trivial<Type>::value,
"Temps::Vector can only be used for trival types");
public:
typedef Type& reference;
typedef const Type& const_reference;
class iterator : public std::iterator<std::random_access_iterator_tag, Type> {
public:
friend class Vector;
using typename std::iterator<std::random_access_iterator_tag,
Type>::difference_type;
using
typename std::iterator<std::random_access_iterator_tag, Type>::pointer;
using typename std::iterator<std::random_access_iterator_tag,
Type>::reference;
private:
pointer ptr;
iterator(pointer ptr) : ptr(ptr) {}
public:
bool operator==(const iterator rhs) const { return ptr == rhs.ptr; }
bool operator!=(const iterator rhs) const { return ptr != rhs.ptr; }
bool operator<(const iterator rhs) const { return ptr < rhs.ptr; }
bool operator<=(const iterator rhs) const { return ptr <= rhs.ptr; }
bool operator>(const iterator rhs) const { return ptr > rhs.ptr; }
bool operator>=(const iterator rhs) const { return ptr >= rhs.ptr; }
iterator operator++() { return iterator(++ptr); }
iterator operator++(int) { return iterator(ptr++); }
iterator operator--() { return iterator(--ptr); }
iterator operator--(int) { return iterator(ptr--); }
iterator operator+(const difference_type dif) const {
return iterator(ptr + dif);
}
iterator operator-(const difference_type dif) const {
return iterator(ptr - dif);
}
iterator operator+=(const difference_type dif) {
ptr += dif;
return *this;
}
iterator operator-=(const difference_type dif) {
ptr -= dif;
return *this;
}
difference_type operator-(const iterator& rhs) const {
return ptr - rhs.ptr;
}
operator pointer() { return ptr; }
};
protected:
Type* a = nullptr;
unsigned int _capacity = 0, _size = 0;
void __grow_capacity(unsigned int least_size) {
if (_capacity >= least_size) {
return;
}
if (_capacity == 0) {
_capacity = 1;
}
while (_capacity < least_size) {
_capacity = _capacity * 2;
}
a = static_cast<Type*>(realloc(a, sizeof(Type) * _capacity));
}
public:
Vector() = default;
explicit Vector(unsigned int size, const Type& initial_value = Type())
: _capacity(size), _size(size) {
a = static_cast<Type*>(malloc(sizeof(Type) * _capacity));
Type *__first = a, *const __last = a + _size;
while (__first != __last) {
*__first++ = initial_value;
}
}
Vector(const Vector& rhs) : _capacity(rhs._size), _size(rhs._size) {
a = static_cast<Type*>(malloc(sizeof(Type) * _capacity));
Type *__first = a, *__r_p = rhs.a, *const __last = a + _size;
while (__first != __last) {
*__first++ = *__r_p++;
}
}
Vector(Vector&& rhs) : _capacity(rhs._capacity), _size(rhs._size) {
a = rhs.a;
rhs.a = nullptr;
}
template <typename Container,
typename = decltype(std::declval<Container>().begin(),
std::declval<Container>().end())>
Vector(const Container& list)
: _capacity(std::distance(list.begin(), list.end())), _size(_capacity) {
a = static_cast<Type*>(malloc(sizeof(Type) * _capacity));
Type* p = a;
for (const auto& i : list) {
*p++ = i;
}
}
template <
typename _InputIterator,
typename = typename std::enable_if<std::is_convertible<
typename std::iterator_traits<_InputIterator>::iterator_category,
std::input_iterator_tag>::value>::type>
explicit Vector(_InputIterator __first, _InputIterator __last) {
_size = _capacity = std::distance(__first, __last);
a = static_cast<Type*>(malloc(sizeof(Type) * _capacity));
Type* p = a;
while (__first != __last) {
*p++ = *__first++;
}
}
inline bool empty() const { return _size == 0; }
inline unsigned int size() const { return _size; }
inline unsigned int capacity() const { return _capacity; }
void reserve(unsigned int __capacity) {
_capacity = __capacity;
if (_size > _capacity) {
_size = _capacity;
}
a = static_cast<Type*>(realloc(a, sizeof(Type) * _capacity));
}
void resize(unsigned int __size) {
if (_size > __size) {
_size = __size;
return;
}
__grow_capacity(__size);
Type *__un = a + _size, *const __ed = a + __size;
while (__un != __ed) {
*__un++ = Type();
}
_size = __size;
}
inline void clear() { resize(0); }
Vector& operator=(const Vector& rhs) {
__grow_capacity(rhs._size);
_size = rhs._size;
Type* __first = a;
const Type *const __last = a + _size, *__r_p = rhs.a;
while (__first != __last) {
*__first++ = *__r_p++;
}
return *this;
}
Vector& operator=(Vector&& rhs) {
_size = rhs._size;
_capacity = rhs._capacity;
free(a);
a = rhs.a;
rhs.a = nullptr;
return *this;
}
Type operator[](const unsigned int id) const { return a[id]; }
Type& operator[](const unsigned int id) { return a[id]; }
Type front() const { return a[0]; }
Type& front() { return a[0]; }
Type back() const { return a[_size - 1]; }
Type& back() { return a[_size - 1]; }
void pop_back() { _size--; }
Vector& push_back(const Type& b) {
__grow_capacity(_size + 1);
a[_size] = b;
_size++;
return *this;
}
Vector& push_back(const Vector& rhs) {
__grow_capacity(_size + rhs._size);
for (const auto& i : rhs) {
a[_size++] = i;
}
return *this;
}
Vector& push_back(const std::initializer_list<Type>& rhs) {
__grow_capacity(_size + rhs.size());
for (const auto& i : rhs) {
a[_size++] = i;
}
return *this;
}
inline iterator begin() const { return iterator(a); }
inline iterator end() const { return iterator(a + _size); }
~Vector() { free(a); }
};
} // namespace Temps
using Temps::Vector;
void preInit();
void init();
void solve();
int32_t main() {
preInit();
init();
solve();
return 0;
}
constexpr int N = 500005;
struct STree {
struct Node {
int a = 0, b = 0;
bool flip_flag = false;
Node() = default;
Node(const Node& l, const Node& r)
: a(std::max(l.a, r.a)), b(std::max(l.b, r.b)) {}
void flip() {
std::swap(a, b);
flip_flag = !flip_flag;
}
void push_down(Node& l, Node& r) {
if (flip_flag) {
l.flip();
r.flip();
flip_flag = false;
}
}
} p[N * 4];
void init(int* a, int l, int r, int u) {
if (r - l == 1) {
p[u].a = a[l];
return;
}
int mid = (l + r) / 2;
init(a, l, mid, u + u);
init(a, mid, r, u + u + 1);
p[u] = Node(p[u + u], p[u + u + 1]);
}
void flip(int fl, int fr, int l, int r, int u) {
if (fl <= l && r <= fr) {
p[u].flip();
return;
}
p[u].push_down(p[u + u], p[u + u + 1]);
int mid = (l + r) / 2;
if (fl < mid) flip(fl, fr, l, mid, u + u);
if (fr > mid) flip(fl, fr, mid, r, u + u + 1);
p[u] = Node(p[u + u], p[u + u + 1]);
}
Node query(int ql, int qr, int l, int r, int u) {
if (ql <= l && r <= qr) {
return p[u];
}
p[u].push_down(p[u + u], p[u + u + 1]);
int mid = (l + r) / 2;
if (ql >= mid) {
return query(ql, qr, mid, r, u + u + 1);
}
if (qr <= mid) {
return query(ql, qr, l, mid, u + u);
}
return Node(query(ql, qr, l, mid, u + u), query(ql, qr, mid, r, u + u + 1));
}
};
Vector<int> e[N];
int u[N], v[N], w[N], n, m, r1, r2;
std::pair<int, int> get_farthest(int u, int f) {
std::pair<int, int> res(-1, u);
for (int v : e[u])
if (v != f) {
checkMax(res, get_farthest(v, u));
}
res.first++;
return res;
}
struct Tree {
STree st;
int dep[N], dfnl[N], dfnr[N], dfn_top = 0;
void dfs(int u, int f) {
dfnl[u] = dfn_top++;
dep[dfnl[u]] = dep[dfnl[f]] + 1;
for (int v : e[u])
if (v != f) dfs(v, u);
dfnr[u] = dfn_top;
}
void init(int r) {
dep[0] = -1;
dfs(r, 0);
st.init(dep, 0, n, 1);
}
void flip(int u, int v) {
if (dep[dfnl[v]] > dep[dfnl[u]]) {
u = v;
}
st.flip(dfnl[u], dfnr[u], 0, n, 1);
}
int query() { return st.query(0, n, 0, n, 1).a; }
} T1, T2;
void preInit() {}
void init() {
n = sc.n();
for (int i = 1; i < n; ++i) {
u[i] = sc.n(), v[i] = sc.n(), w[i] = sc.n();
e[u[i]].push_back(v[i]), e[v[i]].push_back(u[i]);
}
m = sc.n();
}
void solve() {
r1 = get_farthest(1, 0).second;
T1.init(r1);
r2 = get_farthest(r1, 0).second;
T2.init(r2);
;
for (int i = 1; i < n; ++i)
if (w[i]) {
T1.flip(u[i], v[i]);
T2.flip(u[i], v[i]);
}
for (int i = 0; i < m; ++i) {
int id = sc.n();
T1.flip(u[id], v[id]);
T2.flip(u[id], v[id]);
printf("%d\n", std::max(T1.query(), T2.query()));
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x;
scanf("%lld", &x);
return x;
}
const int N = 5.1e5;
vector<int> es[N];
int dis[N];
int dfn[N];
int dfe[N];
void dfs(int x, int fa) {
static int dft;
if (fa == -1) dft = 0;
dfn[x] = ++dft;
dis[x] = fa == -1 ? 0 : dis[fa] + 1;
for (int i = 0; i < (int)(es[x].size()); i++) {
int v = es[x][i];
if (v == fa) continue;
dfs(v, x);
}
dfe[x] = dft;
}
struct SegTree {
int dis[4 * N][2];
bool flag[4 * N];
void build(const int *a, int ll, int rr, int id) {
if (ll == rr) {
dis[id][0] = a[ll];
dis[id][1] = INT_MIN;
flag[id] = false;
return;
}
int mid = (ll + rr) >> 1;
build(a, ll, mid, id * 2);
build(a, mid + 1, rr, id * 2 + 1);
for (int i = 0; i < (int)(2); i++)
dis[id][i] =
max(dis[id * 2][i ^ flag[id]], dis[id * 2 + 1][i ^ flag[id]]);
}
void flip(int l, int r, int ll, int rr, int id) {
if (l <= ll && r >= rr) {
flag[id] ^= 1;
swap(dis[id][0], dis[id][1]);
return;
}
if (r < ll || l > rr) return;
int mid = (ll + rr) >> 1;
flip(l, r, ll, mid, id * 2);
flip(l, r, mid + 1, rr, id * 2 + 1);
for (int i = 0; i < (int)(2); i++)
dis[id][i] =
max(dis[id * 2][i ^ flag[id]], dis[id * 2 + 1][i ^ flag[id]]);
}
};
int n;
int u[N], v[N], t[N];
struct Solver {
int dis[N];
int dfn[N];
int dfe[N];
SegTree tr;
Solver() {
memcpy(dis, ::dis, sizeof(dis));
memcpy(dfn, ::dfn, sizeof(dfn));
memcpy(dfe, ::dfe, sizeof(dfe));
static int tmp[N];
for (int i = (int)(1); i <= (int)(n); i++) tmp[dfn[i]] = ::dis[i];
tr.build(tmp, 1, n, 1);
}
void edit(int u, int v) {
int c = dis[u] > dis[v] ? u : v;
tr.flip(dfn[c], dfe[c], 1, n, 1);
}
int query() { return tr.dis[1][tr.flag[1]]; }
};
int main() {
n = read();
for (int i = (int)(1); i <= (int)(n - 1); i++) {
u[i] = read();
v[i] = read();
t[i] = read();
es[u[i]].push_back(v[i]);
es[v[i]].push_back(u[i]);
}
dfs(1, -1);
int a = max_element(dis + 1, dis + n + 1) - dis;
dfs(a, -1);
int b = max_element(dis + 1, dis + n + 1) - dis;
static Solver s1;
dfs(b, -1);
static Solver s2;
for (int i = (int)(1); i <= (int)(n - 1); i++)
if (t[i]) {
s1.edit(u[i], v[i]);
s2.edit(u[i], v[i]);
};
int m = read();
for (int _ = 0; _ < (int)(m); _++) {
int id = read();
s1.edit(u[id], v[id]);
s2.edit(u[id], v[id]);
int ans = max(s1.query(), s2.query());
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
vector<int> g[N];
int par[N];
int h1[N], h2[N];
int v1[N], v2[N];
int ph[N];
void dfs(int u, int p) {
h2[u] = -1e9;
par[u] = p;
for (auto v : g[u]) {
if (v != p) {
dfs(v, u);
if (h1[v] + 1 > h1[u]) {
h2[u] = h1[u];
h1[u] = h1[v] + 1;
} else {
h2[u] = max(h2[u], h1[v] + 1);
}
}
}
}
void jhfs(int u, int p) {
v1[u] = v2[u] = -1;
for (auto v : g[u]) {
if (v != p) {
ph[v] = max(ph[v], ph[u] + 1);
if (h1[u] == h1[v] + 1) {
ph[v] = max(ph[v], h2[u] + 1);
} else {
ph[v] = max(ph[v], h1[u] + 1);
}
if (h1[v] + 1 == h1[u]) {
v1[u] = v;
} else if (h1[v] + 1 == h2[u]) {
v2[u] = v;
}
jhfs(v, u);
}
}
}
int get(int u, int ban) {
int res = 0;
if (ban != par[u]) res = max(res, ph[u]);
if (v1[u] != ban) res = max(res, h1[u]);
if (v2[u] != ban) res = max(res, h2[u]);
return res;
}
pair<int, int> best;
void dfsD(int u, int d, int p) {
best = max(best, {d, u});
for (auto v : g[u]) {
if (v != p) {
dfsD(v, d + 1, u);
}
}
}
vector<int> curPath;
vector<int> path;
void dfsP(int u, int finish, int p) {
curPath.push_back(u);
if (u == finish) path = curPath;
for (auto v : g[u]) {
if (v != p) dfsP(v, finish, u);
}
curPath.pop_back();
}
vector<int> getPath(int u, int v) {
dfsP(u, v, -1);
return path;
}
vector<int> getDiam() {
best = {-1, 0};
dfsD(0, 0, -1);
int u = best.second;
best = {-1, 0};
dfsD(u, 0, -1);
int v = best.second;
return getPath(u, v);
}
struct Edge {
int u, v, t;
};
const int Inf = 1e9;
struct SegmentTree {
vector<vector<int>> best;
vector<int> mod;
void update(int v) {
swap(best[v][0], best[v][1]);
mod[v] ^= 1;
}
void push(int v) {
if (mod[v]) {
update(2 * v + 1);
update(2 * v + 2);
mod[v] = 0;
}
}
void pull(int v) {
for (int i = 0; i < 2; ++i) {
best[v][i] = max(best[2 * v + 1][i], best[2 * v + 2][i]);
}
}
void modify(int ql, int qr, int l, int r, int v) {
if (r < ql || qr < l) return;
if (ql <= l && r <= qr) {
update(v);
} else {
push(v);
int m = (l + r) / 2;
modify(ql, qr, l, m, 2 * v + 1);
modify(ql, qr, m + 1, r, 2 * v + 2);
pull(v);
}
}
pair<int, int> get(int ql, int qr, int l, int r, int v) {
if (r < ql || qr < l) return make_pair(-Inf, -Inf);
if (ql <= l && r <= qr) {
return make_pair(best[v][0], best[v][1]);
}
push(v);
int m = (l + r) >> 1;
auto p1 = get(ql, qr, l, m, 2 * v + 1);
auto p2 = get(ql, qr, m + 1, r, 2 * v + 2);
return make_pair(max(p1.first, p2.first), max(p1.second, p2.second));
}
void build(int l, int r, int v, vector<int> &xr, vector<int> &h) {
if (l == r) {
best[v][xr[l]] = h[l];
} else {
int m = (l + r) / 2;
build(l, m, 2 * v + 1, xr, h);
build(m + 1, r, 2 * v + 2, xr, h);
pull(v);
}
}
SegmentTree(int n) {
best.resize(4 * n, vector<int>(2, -Inf));
mod.resize(4 * n, 0);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int n;
cin >> n;
vector<Edge> E;
for (int i = 0; i + 1 < n; ++i) {
int u, v, t;
cin >> u >> v >> t;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
E.push_back({u, v, t});
}
dfs(0, -1);
jhfs(0, -1);
int can = 0;
for (int i = 0; i < n; ++i) {
vector<int> cur;
cur.push_back(max(0, h1[i]));
cur.push_back(max(0, h2[i]));
cur.push_back(max(0, ph[i]));
sort(cur.begin(), cur.end());
can = max(can, cur[0] + cur[1]);
}
int rt = -1;
{
vector<int> D = getDiam();
rt = D[(int)D.size() / 2];
}
vector<vector<pair<int, int>>> cg(n);
for (auto e : E) {
cg[e.u].push_back(make_pair(e.v, e.t));
cg[e.v].push_back(make_pair(e.u, e.t));
}
vector<int> l(n), r(n);
vector<int> xr(n);
vector<int> hh(n);
vector<int> e;
vector<int> who(n);
function<void(int, int)> zhfs = [&](int u, int p) {
par[u] = p;
e.push_back(u);
l[u] = (int)e.size() - 1;
for (auto [v, t] : cg[u]) {
if (v != p) {
hh[v] = hh[u] + 1;
xr[v] = xr[u] ^ t;
zhfs(v, u);
}
}
r[u] = (int)e.size() - 1;
};
zhfs(rt, -1);
function<void(int, int)> hs = [&](int u, int p) {
for (auto [v, t] : cg[u]) {
if (v != p) {
if (u == rt) {
who[v] = v;
} else {
who[v] = who[u];
}
hs(v, u);
}
}
};
hs(rt, -1);
SegmentTree tr(n);
{
vector<int> nxr(n);
vector<int> nh(n);
for (int i = 0; i < n; ++i) {
nxr[l[i]] = xr[i];
nh[l[i]] = hh[i];
}
tr.build(0, n - 1, 0, nxr, nh);
}
multiset<int> he, ho;
auto add = [&](int v) {
auto p = tr.get(l[v], r[v], 0, n - 1, 0);
he.insert(p.first);
ho.insert(p.second);
};
auto del = [&](int v) {
auto p = tr.get(l[v], r[v], 0, n - 1, 0);
he.erase(he.find(p.first));
ho.erase(ho.find(p.second));
};
for (auto v : g[rt]) {
add(v);
}
int m;
cin >> m;
while (m--) {
int id;
cin >> id;
--id;
int u = E[id].u, v = E[id].v;
if (par[u] != v) {
swap(u, v);
}
del(who[u]);
tr.modify(l[u], r[u], 0, n - 1, 0);
add(who[u]);
int res = 0;
if (he.size() >= 2) {
res = max(res, *he.rbegin() + *prev(--he.end()));
}
if (he.size() >= 1) {
res = max(res, *he.rbegin());
}
if (ho.size() >= 2) {
res = max(res, *ho.rbegin() + *prev(--ho.end()));
}
res = max(res, can);
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int get_random() {
static uniform_int_distribution<int> dist(0, 1e9 + 6);
return dist(rng);
}
template <class T>
void make_unique(T& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int geti() {
int x;
cin >> x;
return x;
}
long long getll() {
long long x;
cin >> x;
return x;
}
double getd() {
double x;
cin >> x;
return x;
}
const int MAXN = 5e5 + 100;
void solve(int tt) {}
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct segment_tree {
int _l, _r;
vector<S> a;
vector<S> tree;
vector<F> lazy;
void push(int l, int r, int node) {
if (lazy[node] != id()) {
int mid = (l + r) / 2;
int rnode = node + (mid - l + 1) * 2;
tree[node + 1] = mapping(lazy[node], tree[node + 1]);
lazy[node + 1] = composition(lazy[node], lazy[node + 1]);
tree[rnode] = mapping(lazy[node], tree[rnode]);
lazy[rnode] = composition(lazy[node], lazy[rnode]);
lazy[node] = id();
}
}
void build(int l, int r, int node) {
if (l == r)
tree[node] = a[l];
else {
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
build(l, mid, node + 1);
build(mid + 1, r, rnode);
tree[node] = op(tree[node + 1], tree[rnode]);
}
}
void update(F v, int left, int right, int l, int r, int node) {
if (left > right) return;
if (right < l || r < left) return;
if (left <= l && r <= right) {
tree[node] = mapping(v, tree[node]);
lazy[node] = composition(v, lazy[node]);
} else {
push(l, r, node);
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
update(v, left, right, l, mid, node + 1);
update(v, left, right, mid + 1, r, rnode);
tree[node] = op(tree[node + 1], tree[rnode]);
}
}
S query(int left, int right, int l, int r, int node) {
if (left > right) return e();
if (right < l || r < left) return e();
if (left <= l && r <= right) return tree[node];
push(l, r, node);
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
S r1 = query(left, right, l, mid, node + 1);
S r2 = query(left, right, mid + 1, r, rnode);
return op(r1, r2);
}
vector<S> get_tree() {
vector<S> res;
for (int i = _l; i <= _r; i++) {
res.push_back(query(i, i));
}
return res;
}
void init(int l, int r) {
_l = l;
_r = r;
a.assign(r + 1, e());
tree.assign(2 * r + 1, e());
lazy.assign(2 * r + 1, id());
}
S& operator[](int idx) { return a[idx]; }
void build() { build(_l, _r, 0); }
void update(F v, int left, int right) { update(v, left, right, _l, _r, 0); }
S query(int left, int right) { return query(left, right, _l, _r, 0); }
};
long long zero() { return 0; }
long long int_max() { return INT_MAX; }
long long int_min() { return INT_MIN; }
long long get_min(long long x, long long y) { return min(x, y); }
long long get_max(long long x, long long y) { return max(x, y); }
long long add(long long x, long long y) { return x + y; }
long long mul(long long x, long long y) { return x * y; }
pair<int, int> f1(pair<int, int> x, pair<int, int> y) {
return pair<int, int>({min(x.first, y.first), max(x.second, y.second)});
};
pair<int, int> f2() { return pair<int, int>({1e9, -1e9}); };
pair<int, int> f3(int x, pair<int, int> y) {
return pair<int, int>(
{min(y.second * x, y.first * x), max(y.second * x, y.first * x)});
};
int f4(int x, int y) { return x * y; };
int f5() { return 1; };
segment_tree<pair<int, int>, f1, f2, int, f3, f4, f5> segt;
vector<int> graph1[MAXN];
vector<int> graph2[MAXN];
int in[MAXN], out[MAXN], level[MAXN], t = 1;
int cnt[MAXN];
int n;
void dfs(int i, int p, int c, int l) {
;
;
in[i] = t++;
cnt[in[i]] = c;
segt[in[i]] = (c % 2 ? pair<int, int>({-l, -l}) : pair<int, int>({l, l}));
level[i] = l;
for (auto j : graph1[i]) {
if (j == p) continue;
dfs(j, i, c, l + 1);
}
for (auto j : graph2[i]) {
if (j == p) continue;
dfs(j, i, c + 1, l + 1);
}
out[i] = t;
}
pair<int, int> find_root() {
queue<int> q({1});
vector<int> vis(n + 1);
vis[1] = 1;
int res1 = 1;
while (q.size()) {
int len = q.size();
while (len--) {
auto f = q.front();
q.pop();
for (auto p : graph1[f]) {
if (!vis[p]) {
q.push(p);
res1 = p;
vis[p] = 1;
}
}
for (auto p : graph2[f]) {
if (!vis[p]) {
q.push(p);
res1 = p;
vis[p] = 1;
}
}
}
}
int res2 = res1;
q.push(res1);
vis = vector<int>(n + 1);
vis[res1] = 1;
while (q.size()) {
int len = q.size();
while (len--) {
auto f = q.front();
q.pop();
for (auto p : graph1[f]) {
if (!vis[p]) {
q.push(p);
res2 = p;
vis[p] = 1;
}
}
for (auto p : graph2[f]) {
if (!vis[p]) {
q.push(p);
res2 = p;
vis[p] = 1;
}
}
}
}
return {res1, res2};
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
int u, v, tp;
vector<int> us, vs;
for (auto i = (0); i < (n - 1); i++) {
cin >> u >> v >> tp;
if (tp == 0) {
graph1[u].push_back(v);
graph1[v].push_back(u);
} else {
graph2[u].push_back(v);
graph2[v].push_back(u);
}
us.push_back(u);
vs.push_back(v);
}
pair<int, int> roots = find_root();
segt.init(1, n);
t = 1;
dfs(roots.first, -1, 0, 0);
segt.build();
int m;
cin >> m;
vector<int> idxs;
for (auto i = (0); i < (m); i++) {
int idx;
cin >> idx;
idx--;
idxs.push_back(idx);
}
vector<int> res1(m), res2(m);
for (auto i = (0); i < (m); i++) {
int idx = idxs[i];
u = us[idx], v = vs[idx];
if (level[u] > level[v]) swap(u, v);
;
;
segt.update(-1, in[v], out[v] - 1);
res1[i] = segt.query(1, n).second;
}
segt.init(1, n);
t = 1;
dfs(roots.second, -1, 0, 0);
segt.build();
;
;
;
;
for (auto i = (0); i < (m); i++) {
int idx = idxs[i];
u = us[idx], v = vs[idx];
if (level[u] > level[v]) swap(u, v);
;
;
segt.update(-1, in[v], out[v] - 1);
res2[i] = segt.query(1, n).second;
}
for (auto i = (0); i < (m); i++) {
cout << max(res1[i], res2[i]) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10, INF = 0x3f3f3f3f;
template <class T>
inline T Read(T &r) {
int b = 1, c = getchar();
r = 0;
while (c < '0' || '9' < c) b = c == '-' ? -1 : b, c = getchar();
while ('0' <= c && c <= '9')
r = (r << 1) + (r << 3) + (c ^ '0'), c = getchar();
return r *= b;
}
struct GRAPH {
int head[N], to[N << 1], nxt[N << 1], ncnt;
GRAPH() { ncnt = 1; }
void AddEdge(const int &u, const int &v) {
int p = ++ncnt, q = ++ncnt;
to[p] = v, nxt[p] = head[u], head[u] = p;
to[q] = u, nxt[q] = head[v], head[v] = q;
}
inline int operator[](const int &u) { return head[u]; }
} Gr;
int n, nary, m;
bool typ[N];
int dep[N], dcnt[N], clo[N], ope[N], ary[N << 1], gto[N];
struct DATA {
int omxd, omnd, emxd, emnd, omxLM, omxMR, emxLM, emxMR, omx, emx;
inline friend DATA operator+(const DATA &L, const DATA &R) {
return (DATA){
max(L.omxd, R.omxd),
min(L.omnd, R.omnd),
max(L.emxd, R.emxd),
min(L.emnd, R.emnd),
max(max(L.omxLM, R.omxLM), L.omxd - 2 * min(R.omnd, R.emnd)),
max(max(L.omxMR, R.omxMR), R.omxd - 2 * min(L.omnd, L.emnd)),
max(max(L.emxLM, R.emxLM), L.emxd - 2 * min(R.omnd, R.emnd)),
max(max(L.emxMR, R.emxMR), R.emxd - 2 * min(L.omnd, L.emnd)),
max(max(L.omx, R.omx), max(max(L.omxd + R.emxMR, L.emxd + R.omxMR),
max(L.omxLM + R.emxd, L.emxLM + R.omxd))),
max(max(L.emx, R.emx), max(max(L.emxd + R.emxMR, L.omxd + R.omxMR),
max(L.emxLM + R.emxd, L.omxLM + R.omxd)))};
}
inline DATA operator~() const {
return (DATA){emxd, emnd, omxd, omnd, emxLM, emxMR, omxLM, omxMR, omx, emx};
}
};
struct SEGTREE {
DATA seg[N << 2];
bool rev[N << 2];
inline void InitOdd(const int &u, const int &d) {
seg[u] = (DATA){d, d, -INF, INF, -d, -d, -INF, -INF, -INF, 0};
}
inline void InitEve(const int &u, const int &d) {
seg[u] = (DATA){-INF, INF, d, d, -INF, -INF, -d, -d, -INF, 0};
}
void PushUp(const int &le, const int &ri) {
int mi = (le + ri) >> 1;
seg[(((le) + (ri)) | ((le) != (ri)))] =
seg[(((le) + (mi)) | ((le) != (mi)))] +
seg[(((mi + 1) + (ri)) | ((mi + 1) != (ri)))];
}
void Update(const int &u) { rev[u] = !rev[u], seg[u] = ~seg[u]; }
void PushDown(const int &le, const int &ri) {
if (!rev[(((le) + (ri)) | ((le) != (ri)))]) return;
int mi = (le + ri) >> 1;
Update((((le) + (mi)) | ((le) != (mi)))),
Update((((mi + 1) + (ri)) | ((mi + 1) != (ri))));
rev[(((le) + (ri)) | ((le) != (ri)))] = false;
}
void Build(const int &le, const int &ri) {
if (le == ri) {
int v = ary[le];
if (dcnt[v] & 1)
InitOdd((((le) + (ri)) | ((le) != (ri))), dep[v]);
else
InitEve((((le) + (ri)) | ((le) != (ri))), dep[v]);
return;
}
int mi = (le + ri) >> 1;
Build(le, mi), Build(mi + 1, ri);
PushUp(le, ri);
}
void Reverse(const int &le, const int &ri, const int &Le, const int &Ri) {
if (Le <= le && ri <= Ri) {
Update((((le) + (ri)) | ((le) != (ri))));
return;
}
PushDown(le, ri);
int mi = (le + ri) >> 1;
if (Le <= mi) Reverse(le, mi, Le, Ri);
if (mi < Ri) Reverse(mi + 1, ri, Le, Ri);
PushUp(le, ri);
}
int Root() { return seg[(((1) + (nary)) | ((1) != (nary)))].emx; }
} Se;
void DFS(const int &u, const int &fa) {
dep[ary[ope[u] = clo[u] = ++nary] = u] = dep[fa] + 1;
for (int it = Gr[u]; it; it = Gr.nxt[it]) {
int v = Gr.to[it];
if (v == fa) continue;
dcnt[v] = dcnt[u] + typ[it >> 1];
gto[it >> 1] = v;
DFS(v, u);
ary[clo[u] = ++nary] = u;
}
}
int main() {
Read(n);
for (int i = 1, u, v; i < n; i++) {
Read(u), Read(v), Read(typ[i]);
Gr.AddEdge(u, v);
}
DFS(1, 0);
Se.Build(1, nary);
Read(m);
while (m--) {
int it, u;
Read(it), u = gto[it];
Se.Reverse(1, nary, ope[u], clo[u]);
printf("%d\n", Se.Root());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 7;
const long long mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
vector<pair<int, int> > v[N];
int get(int st) {
queue<int> q;
vector<int> d(n + 1, 1e9);
d[st] = 0;
q.push(st);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto y : v[x]) {
if (d[y.first] == 1e9) {
d[y.first] = d[x] + 1;
q.push(y.first);
}
}
}
int id = 1;
for (int i = 1; i <= n; i++) {
if (d[i] > d[id]) {
id = i;
}
}
return id;
}
struct tr {
int G, ch[N];
int t[N], a[N];
int f[N], lz[N];
int d[N], c[N];
int tin[N], tout[N];
void meg(int x) {
t[x] = max(t[x + x], t[x + x + 1]);
f[x] = max(f[x + x], f[x + x + 1]);
}
void dfs(int x, int par) {
tin[x] = ++G;
ch[G] = x;
for (auto y : v[x]) {
if (y.first != par) {
d[y.first] = d[x] + 1;
c[y.first] = (c[x] ^ y.second);
dfs(y.first, x);
}
}
tout[x] = G;
}
void build(int x, int l, int r) {
if (l == r) {
if (c[ch[l]] == 0) {
f[x] = d[ch[l]];
} else
t[x] = d[ch[l]];
return;
}
int m = (l + r) / 2;
build(x + x, l, m);
build(x + x + 1, m + 1, r);
meg(x);
}
void push(int x) {
if (lz[x]) {
lz[x + x] ^= 1;
lz[x + x + 1] ^= 1;
swap(t[x + x], f[x + x]);
swap(t[x + x + 1], f[x + x + 1]);
lz[x] = 0;
}
}
void upd(int x, int l, int r, int tl, int tr) {
if (tl > tr) return;
if (l == tl && r == tr) {
lz[x] ^= 1;
swap(t[x], f[x]);
return;
}
push(x);
int m = (l + r) / 2;
upd(x + x, l, m, tl, min(tr, m));
upd(x + x + 1, m + 1, r, max(tl, m + 1), tr);
meg(x);
}
} D[2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
vector<pair<int, int> > g;
for (int i = 1; i < n; i++) {
int x, y, t;
cin >> x >> y >> t;
g.push_back({x, y});
v[x].push_back({y, t});
v[y].push_back({x, t});
}
int x = get(1);
int y = get(x);
D[0].dfs(x, x);
D[1].dfs(y, y);
D[0].build(1, 1, n);
D[1].build(1, 1, n);
int q;
cin >> q;
while (q--) {
int h;
cin >> h;
int x = g[h - 1].first, y = g[h - 1].second;
D[0].upd(1, 1, n, max(D[0].tin[x], D[0].tin[y]),
min(D[0].tout[x], D[0].tout[y]));
D[1].upd(1, 1, n, max(D[1].tin[x], D[1].tin[y]),
min(D[1].tout[x], D[1].tout[y]));
cout << max(D[0].f[1], D[1].f[1]) << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 5e5 + 4;
struct edge {
int v, w, nxt;
} e[N << 1];
int first[N], cnt = 1;
inline void addedge(int u, int v, int w) {
e[++cnt] = (edge){v, w, first[u]};
first[u] = cnt;
}
int n, Q, tim, siz[N], dep[N], son[N], top[N], idx[N], dfn[N], fa[N], dis[N],
iw[N];
void dfs_1(int x) {
siz[x] = 1;
idx[dfn[x] = ++tim] = x;
for (int i = first[x], v; i; i = e[i].nxt) {
v = e[i].v;
if (v == fa[x]) continue;
fa[v] = x;
dep[v] = dep[x] + 1;
dis[v] = dis[x] ^ e[i].w;
iw[i >> 1] = v;
dfs_1(v);
siz[x] += siz[v];
if (siz[v] > siz[son[x]]) son[x] = v;
}
}
int mn[N << 1][20], lg[N << 1], st[N];
void dfs_2(int x) {
mn[st[x] = ++tim][0] = x;
for (int i = first[x], v; i; i = e[i].nxt) {
v = e[i].v;
if (v == fa[x]) continue;
dfs_2(v);
mn[++tim][0] = x;
}
}
inline int cmp(int x, int y) { return dep[x] < dep[y] ? x : y; }
inline void prepare() {
tim = 0;
dfs_2(1);
for (int i = 2; i <= tim; i++) lg[i] = lg[i >> 1] + 1;
for (int j = 1; j <= lg[tim]; j++)
for (int i = 1, r = 1 << j; r <= tim; i++, r++)
mn[i][j] = cmp(mn[i][j - 1], mn[i + (1 << j - 1)][j - 1]);
}
inline int getlca(int x, int y) {
x = st[x];
y = st[y];
if (x > y) x ^= y ^= x ^= y;
int k = lg[y - x + 1];
return cmp(mn[x][k], mn[y - (1 << k) + 1][k]);
}
struct node {
int p1, p2, w;
node() {}
node(int x, int y, int v) : p1(x), p2(y), w(v) {}
};
inline bool upd(int &x, int v) {
if (x < v) {
x = v;
return 1;
}
return 0;
}
inline int distan(int x, int y) {
return (!x || !y) ? -1 : dep[x] + dep[y] - dep[getlca(x, y)] * 2;
}
inline node operator+(const node &a, const node &b) {
node ret = a.w > b.w ? a : b;
if (upd(ret.w, distan(a.p1, b.p1))) {
ret.p1 = a.p1;
ret.p2 = b.p1;
}
if (upd(ret.w, distan(a.p1, b.p2))) {
ret.p1 = a.p1;
ret.p2 = b.p2;
}
if (upd(ret.w, distan(a.p2, b.p1))) {
ret.p1 = a.p2;
ret.p2 = b.p1;
}
if (upd(ret.w, distan(a.p2, b.p2))) {
ret.p1 = a.p2;
ret.p2 = b.p2;
}
return ret;
}
namespace seg {
node t[N << 2][2];
int lz[N << 2];
inline void pushup(int p) {
t[p][0] = t[(p << 1)][0] + t[(p << 1 | 1)][0];
t[p][1] = t[(p << 1)][1] + t[(p << 1 | 1)][1];
}
inline void pushnow(int p) {
swap(t[p][0], t[p][1]);
lz[p] ^= 1;
}
inline void pushdown(int p) {
if (!lz[p]) return;
pushnow((p << 1));
pushnow((p << 1 | 1));
lz[p] ^= 1;
}
void build(int p, int l, int r) {
if (l == r) {
t[p][dis[idx[r]]].p1 = t[p][dis[idx[r]]].p2 = idx[r];
t[p][dis[idx[r]] ^ 1].w = -1;
return;
}
build((p << 1), l, ((l + r) >> 1));
build((p << 1 | 1), ((l + r) >> 1) + 1, r);
pushup(p);
}
void modify(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
pushnow(p);
return;
}
pushdown(p);
if (ql <= ((l + r) >> 1)) modify((p << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr) modify((p << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr);
pushup(p);
}
} // namespace seg
int main() {
n = read();
for (int i = 1, u, v, w; i < n; i++) {
u = read();
v = read();
w = read();
addedge(u, v, w);
addedge(v, u, w);
}
dfs_1(1);
prepare();
seg::build(1, 1, n);
for (int Q = read(), x; Q--;) {
x = iw[read()];
seg::modify(1, 1, n, dfn[x], dfn[x] + siz[x] - 1);
cout << max(seg::t[1][0].w, seg::t[1][1].w) << "\n";
}
return (0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 512345;
int n, q;
vector<tuple<int, int, int>> G[maxn];
struct Tree {
int clk;
int in[maxn], out[maxn], dep[maxn], stone[maxn], ver[maxn], seq[maxn];
bool vis[maxn];
struct Seg {
int l, r;
int mx[2];
bool lzy;
} T[maxn << 2];
void push_up(int o) {
T[o].mx[0] = max(T[o << 1].mx[0], T[o << 1 | 1].mx[0]);
T[o].mx[1] = max(T[o << 1].mx[1], T[o << 1 | 1].mx[1]);
}
void push_down(int o) {
if (!T[o].lzy) return;
swap(T[o << 1].mx[0], T[o << 1].mx[1]);
T[o << 1].lzy ^= true;
swap(T[o << 1 | 1].mx[0], T[o << 1 | 1].mx[1]);
T[o << 1 | 1].lzy ^= true;
T[o].lzy = false;
}
void build(int o, int l, int r) {
T[o].l = l, T[o].r = r;
if (l == r) {
T[o].mx[stone[seq[l]] & 1] = dep[seq[l]];
} else {
int mi = l + r >> 1;
build(o << 1, l, mi);
build(o << 1 | 1, mi + 1, r);
push_up(o);
}
}
void update(int o, int l, int r) {
if (l <= T[o].l && T[o].r <= r) {
swap(T[o].mx[0], T[o].mx[1]);
T[o].lzy ^= true;
return;
}
push_down(o);
int mi = T[o].l + T[o].r >> 1;
if (l <= mi) update(o << 1, l, r);
if (r > mi) update(o << 1 | 1, l, r);
push_up(o);
}
void dfs(int u, int par) {
if (par) dep[u] = dep[par] + 1;
in[u] = ++clk;
seq[clk] = u;
for (auto [v, t, e] : G[u])
if (v != par) {
stone[v] = stone[u] + t;
ver[e] = v;
dfs(v, u);
}
out[u] = clk;
}
int bfs(int r) {
queue<int> Q;
Q.emplace(r);
vis[r] = true;
int u = 0;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (auto [v, _, __] : G[u])
if (!vis[v]) {
vis[v] = true;
Q.emplace(v);
}
}
return u;
}
} T[2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int(i) = (1); (i) <= (n - 1); (i)++) {
int u, v, t;
cin >> u >> v >> t;
G[u].emplace_back(v, t, i);
G[v].emplace_back(u, t, i);
}
int r = 1;
for (int(i) = (0); (i) <= ((2) - 1); (i)++) {
r = T[i].bfs(r);
T[i].dfs(r, 0);
T[i].build(1, 1, n);
}
cin >> q;
while (q--) {
int id;
cin >> id;
int ans = 0;
for (int(i) = (0); (i) <= ((2) - 1); (i)++) {
int u = T[i].ver[id];
T[i].update(1, T[i].in[u], T[i].out[u]);
ans = max(ans, T[i].T[1].mx[0]);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
const long long MOD = 1000000007;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int iNF = 0x3f3f3f3f;
const long long MAXN = 5e5 + 5;
vector<pair<int, int>> tree;
vector<int> edge[MAXN];
vector<int> nid, in, out, dep;
void dfs(int nd, int par, int dp = 0) {
dep[nd] = dp;
in[nd] = static_cast<int>(nid.size());
nid.emplace_back(nd);
for (int v : edge[nd]) {
if (v != par) {
dfs(v, nd, dp + 1);
nid.emplace_back(nd);
}
}
out[nd] = static_cast<int>(nid.size());
}
struct Node {
int one[2];
int mid;
int lf[2];
int rt[2];
int ans;
Node() { ans = mid = one[0] = one[1] = lf[0] = lf[1] = rt[0] = rt[1] = -iNF; }
};
Node seg[MAXN * 8];
Node mrg(const Node &n1, const Node &n2) {
Node ret;
for (int i = 0; i < 2; i++) {
ret.one[i] = max(n1.one[i], n2.one[i]);
ret.mid = max(n1.mid, n2.mid);
ret.lf[i] = max({n1.lf[i], n2.lf[i], n1.one[i] + n2.mid});
ret.rt[i] = max({n1.rt[i], n2.rt[i], n1.mid + n2.one[i]});
ret.ans = max(
{ret.ans, n1.ans, n2.ans, n1.lf[i] + n2.one[i], n1.one[i] + n2.rt[i]});
}
return ret;
}
bool tag[MAXN * 8];
Node get(int o) {
Node ret = seg[o];
if (tag[o]) {
swap(ret.one[0], ret.one[1]);
swap(ret.lf[0], ret.lf[1]);
swap(ret.rt[0], ret.rt[1]);
}
return ret;
}
void pull(int nd) { seg[nd] = mrg(get(nd << 1), get(nd << 1 | 1)); }
void push(int nd) {
if (tag[nd]) {
seg[nd] = get(nd);
tag[nd << 1] ^= 1;
tag[nd << 1 | 1] ^= 1;
}
tag[nd] = 0;
}
void build(int o, int l, int r) {
if (r == l + 1) {
seg[o].one[0] = dep[nid[l]];
seg[o].mid = -2 * dep[nid[l]];
seg[o].lf[0] = seg[o].rt[0] = -dep[nid[l]];
} else {
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid, r);
pull(o);
}
}
void flp(int qL, int qR, int o, int nL, int nR) {
if (qL >= qR || qL >= nR || qR <= nL) {
return;
} else if (qL <= nL && nR <= qR) {
tag[o] ^= 1;
} else {
push(o);
int nM = (nL + nR) >> 1;
flp(qL, qR, o << 1, nL, nM);
flp(qL, qR, o << 1 | 1, nM, nR);
pull(o);
}
}
int sz;
void tog(int id) {
int u, v;
tie(u, v) = tree[id];
if (dep[u] > dep[v]) swap(u, v);
flp(in[v], out[v], 1, 0, sz);
}
signed main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
in.resize(n);
out.resize(n);
dep.resize(n);
vector<int> init;
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--, v--;
edge[u].emplace_back(v);
edge[v].emplace_back(u);
tree.emplace_back(u, v);
if (t) init.emplace_back(i);
}
dfs(0, -1);
;
sz = static_cast<int>(nid.size());
build(1, 0, sz);
for (auto v : init) {
tog(v);
}
int q;
cin >> q;
while (q--) {
int eid;
cin >> eid;
tog(eid - 1);
cout << seg[1].ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int mod = 1e9 + 7;
int n;
vector<vector<pair<int, int>>> g;
int far(int v) {
vector<int> d(n + 1, -1);
d[v] = 0;
queue<int> q;
q.push(v);
while (!q.empty()) {
int s = q.front();
q.pop();
for (auto x : g[s]) {
int u = x.first;
if (d[u] == -1) {
d[u] = d[s] + 1;
q.push(u);
}
}
}
int id = 1;
for (int i = 2; i <= n; ++i) {
if (d[i] > d[id]) id = i;
}
return id;
}
void dfs(int v, int p, vector<int>& tin, vector<int>& tout, vector<int>& d,
vector<int>& h, vector<int>& e, int& timer) {
tin[v] = timer++;
e.push_back(v);
for (auto x : g[v]) {
int u = x.first, w = x.second;
if (u == p) continue;
d[u] = (d[v] + w) % 2;
h[u] = h[v] + 1;
dfs(u, v, tin, tout, d, h, e, timer);
}
tout[v] = timer;
}
struct segtree {
int size;
vector<vector<int>> tree;
vector<int> modify;
segtree(int n) {
size = 1;
while (size < n) size <<= 1;
tree.resize(2 * size - 1, vector<int>(2));
modify.resize(2 * size - 1);
}
void get(int v) {
tree[v][0] = max(tree[2 * v + 1][0], tree[2 * v + 2][0]);
tree[v][1] = max(tree[2 * v + 1][1], tree[2 * v + 2][1]);
}
void push(int v) {
if (modify[v]) {
modify[2 * v + 1] ^= 1;
modify[2 * v + 2] ^= 1;
swap(tree[2 * v + 1][0], tree[2 * v + 1][1]);
swap(tree[2 * v + 2][0], tree[2 * v + 2][1]);
}
modify[v] = 0;
}
void upd(int v, int lx, int rx, int l, int h, int d) {
if (lx + 1 == rx) {
tree[v][d] = h;
return;
}
int m = (lx + rx) / 2;
if (l < m)
upd(2 * v + 1, lx, m, l, h, d);
else
upd(2 * v + 2, m, rx, l, h, d);
get(v);
}
void upd(int l, int h, int d) { upd(0, 0, size, l, h, d); }
void rev(int v, int lx, int rx, int l, int r) {
if (l <= lx and rx <= r) {
modify[v] ^= 1;
swap(tree[v][0], tree[v][1]);
return;
}
if (rx <= l or r <= lx) {
return;
}
push(v);
int m = (lx + rx) / 2;
rev(2 * v + 1, lx, m, l, r);
rev(2 * v + 2, m, rx, l, r);
get(v);
}
void rev(int l, int r) { rev(0, 0, size, l, r); }
int ans() { return tree[0][0]; }
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
g.resize(n + 1);
vector<vector<int>> edges;
for (int i = 0, u, v, w; i < n - 1; ++i) {
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
edges.push_back({u, v});
}
int S = far(1), T = far(S);
vector<int> tin1(n + 1), tin2(n + 1), h1(n + 1), h2(n + 1), tout1(n + 1),
tout2(n + 1), d1(n + 1), d2(n + 1), e1, e2;
int timer = 0;
dfs(S, -1, tin1, tout1, d1, h1, e1, timer);
timer = 0;
dfs(T, -1, tin2, tout2, d2, h2, e2, timer);
segtree ST1(n), ST2(n);
for (int i = 0; i < n; ++i) {
ST1.upd(i, h1[e1[i]], d1[e1[i]]);
ST2.upd(i, h2[e2[i]], d2[e2[i]]);
}
int q;
cin >> q;
while (q-- > 0) {
int id;
cin >> id;
id--;
int u = edges[id][0], v = edges[id][1];
if (h1[u] > h1[v])
ST1.rev(tin1[u], tout1[u]);
else
ST1.rev(tin1[v], tout1[v]);
if (h2[u] > h2[v])
ST2.rev(tin2[u], tout2[u]);
else
ST2.rev(tin2[v], tout2[v]);
cout << max(ST1.ans(), ST2.ans()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int U[505050], V[505050], T[505050];
vector<vector<int>> E;
int id;
int L[2][505050], R[2][505050], D[2][505050];
pair<int, int> farthest(vector<vector<int>>& E, int cur, int pre, int d,
vector<int>& D) {
D[cur] = d;
pair<int, int> r = {d, cur};
for (auto& e : E[cur])
if (e != pre) r = max(r, farthest(E, e, cur, d + 1, D));
return r;
}
pair<int, vector<int>> diameter(vector<vector<int>>& E) {
vector<int> D[2];
D[0].resize(E.size());
D[1].resize(E.size());
auto v1 = farthest(E, 0, 0, 0, D[0]);
auto v2 = farthest(E, v1.second, v1.second, 0, D[0]);
farthest(E, v2.second, v2.second, 0, D[1]);
pair<int, vector<int>> R;
R.first = v2.first;
R.second.push_back(v1.second);
R.second.push_back(v2.second);
return R;
}
template <class V, int NV>
class SegTree_3 {
public:
vector<V> ma, mi, rev;
SegTree_3() {
int i;
ma.resize(NV * 2, -1 << 20);
mi.resize(NV * 2, 1 << 20);
rev.resize(NV * 2, 0);
};
void update(int x, int y, V v, int l = 0, int r = NV, int k = 1) {
if (l >= r) return;
if (x <= l && r <= y) {
rev[k] ^= 1;
swap(ma[k], mi[k]);
ma[k] = -ma[k];
mi[k] = -mi[k];
} else if (l < y && x < r) {
update(x, y, v, l, (l + r) / 2, k * 2);
update(x, y, v, (l + r) / 2, r, k * 2 + 1);
ma[k] = max(ma[k * 2], ma[k * 2 + 1]);
mi[k] = min(mi[k * 2], mi[k * 2 + 1]);
if (rev[k]) {
swap(ma[k], mi[k]);
ma[k] = -ma[k];
mi[k] = -mi[k];
}
}
}
void build() {
int i;
for (i = NV - 1; i >= 1; i--) {
ma[i] = max(ma[2 * i], ma[2 * i + 1]);
mi[i] = min(mi[2 * i], mi[2 * i + 1]);
}
}
};
SegTree_3<int, 1 << 19> st[2];
void dfs(int cur, int pre, int cid, int d) {
D[cid][cur] = d;
L[cid][cur] = id++;
for (auto& e : E[cur])
if (e != pre) dfs(e, cur, cid, d + 1);
R[cid][cur] = id;
st[cid].ma[(1 << 19) + L[cid][cur]] = st[cid].mi[(1 << 19) + L[cid][cur]] = d;
}
void solve() {
int i, j, k, l, x, y;
string s;
scanf("%d", &N);
E.resize(N);
for (i = 0; i < (N - 1); i++) {
scanf("%d%d%d", &U[i], &V[i], &T[i]);
U[i]--;
V[i]--;
E[U[i]].push_back(V[i]);
E[V[i]].push_back(U[i]);
}
auto d = diameter(E);
int root[2] = {d.second[0], d.second[1]};
for (i = 0; i < (2); i++) {
id = 0;
dfs(root[i], root[i], i, 0);
st[i].build();
for (j = 0; j < (N - 1); j++) {
if (T[j]) {
if (D[i][U[j]] > D[i][V[j]])
st[i].update(L[i][U[j]], R[i][U[j]], 1);
else
st[i].update(L[i][V[j]], R[i][V[j]], 1);
}
}
}
scanf("%d", &M);
while (M--) {
scanf("%d", &x);
x--;
int ma = 0;
for (i = 0; i < (2); i++) {
if (D[i][U[x]] > D[i][V[x]])
st[i].update(L[i][U[x]], R[i][U[x]], 1);
else
st[i].update(L[i][V[x]], R[i][V[x]], 1);
ma = max(ma, st[i].ma[1]);
}
cout << ma << endl;
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
return p1 == p2 ? EOF : *(p1++);
}
template <class T>
inline void read(T &n) {
n = 0;
register int ch = gc(), f;
while ((ch < '0' || ch > '9') && ch != '-') ch = gc();
f = (ch == '-' ? ch = gc(), -1 : 1);
while (ch >= '0' && ch <= '9') n = n * 10 + (ch ^ 48), ch = gc();
n *= f;
}
char Of[105], *O1 = Of, *O2 = Of;
template <class T>
inline void print(T n, char ch = '\n') {
if (n < 0) putchar('-'), n = -n;
if (n == 0) putchar('0');
while (n) *(O1++) = (n % 10) ^ 48, n /= 10;
while (O1 != O2) putchar(*(--O1));
putchar(ch);
}
} // namespace IO
using IO ::print;
using IO ::read;
int const MAXN = 5e5 + 5;
struct Edges {
int to, next;
} e[MAXN << 1];
int head[MAXN], tot, n;
struct Edge {
int x, y, z;
} E[MAXN];
struct Tree {
int root;
int mx0[MAXN << 2], mx1[MAXN << 2];
int tag[MAXN << 2];
int dis[MAXN], Dfn[MAXN], dfncnt, size[MAXN];
int DDfn[MAXN];
void Update(int x) {
mx0[x] = max(mx0[(x << 1)], mx0[(x << 1 | 1)]);
mx1[x] = max(mx1[(x << 1)], mx1[(x << 1 | 1)]);
}
void Reverse(int x) { swap(mx0[x], mx1[x]), tag[x] ^= 1; }
void Pushdown(int x) { Reverse((x << 1)), Reverse((x << 1 | 1)), tag[x] = 0; }
void Build(int x, int l, int r) {
if (l == r) return mx0[x] = dis[DDfn[l]], void();
int mid = (l + r) >> 1;
Build((x << 1), l, mid);
Build((x << 1 | 1), mid + 1, r);
Update(x);
}
void Change(int x, int l, int r, int i, int j) {
if (i <= l && r <= j) return Reverse(x);
if (tag[x]) Pushdown(x);
int mid = (l + r) >> 1;
if (i <= mid) Change((x << 1), l, mid, i, j);
if (j > mid) Change((x << 1 | 1), mid + 1, r, i, j);
Update(x);
}
void Dfs(int now, int fa) {
Dfn[now] = ++dfncnt;
size[now] = 1;
for (register int i = head[now]; i; i = e[i].next)
if (e[i].to != fa) {
dis[e[i].to] = dis[now] + 1;
Dfs(e[i].to, now);
size[now] += size[e[i].to];
}
}
void Init() {
Dfs(root, 0);
for (register int i = 1; i <= n; ++i) DDfn[Dfn[i]] = i;
Build(1, 1, n);
}
void Modify(int x, int y) {
if (dis[y] > dis[x]) swap(x, y);
Change(1, 1, n, Dfn[x], Dfn[x] + size[x] - 1);
}
int Query() { return mx0[1]; }
} S, T;
int mxdis;
inline void addedge(int from, int to) {
e[++tot] = (Edges){to, head[from]};
head[from] = tot;
e[++tot] = (Edges){from, head[to]};
head[to] = tot;
}
void Dfs(int now, int fa, int dis, int &node) {
if (dis > mxdis) mxdis = dis, node = now;
for (register int i = head[now]; i; i = e[i].next)
if (e[i].to != fa) Dfs(e[i].to, now, dis + 1, node);
}
int main() {
read(n);
for (register int i = 1; i < n; ++i) {
read(E[i].x), read(E[i].y), read(E[i].z);
addedge(E[i].x, E[i].y);
}
mxdis = -1, Dfs(1, 0, 0, S.root);
mxdis = -1, Dfs(S.root, 0, 0, T.root);
S.Init(), T.Init();
for (register int i = 1; i < n; ++i)
if (E[i].z == 1) {
S.Modify(E[i].x, E[i].y);
T.Modify(E[i].x, E[i].y);
}
int m;
read(m);
while (m--) {
int p;
read(p);
S.Modify(E[p].x, E[p].y);
T.Modify(E[p].x, E[p].y);
print(max(S.Query(), T.Query()));
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 500005, L = N << 1, INF = 0x3f3f3f3f;
int n, q;
struct Edge {
int v, w, id;
};
std::vector<Edge> E[N];
int son[N];
int dep[N], sum[N];
int st[N], ed[N];
int idt[L], idx;
void dfs(int u, int fa) {
idt[++idx] = u;
st[u] = idx;
for (auto e : E[u]) {
if (e.v != fa) {
son[e.id] = e.v;
dep[e.v] = dep[u] + 1;
sum[e.v] = sum[u] + e.w;
dfs(e.v, u);
idt[++idx] = u;
}
}
ed[u] = idx;
}
struct SegmentTree {
static const int N = ::L << 2;
int W[N][2], M[N], LM[N][2], MR[N][2], LMR[N][2], tag[N];
void up(int u) {
M[u] = std::max(M[u << 1], M[u << 1 | 1]);
for (int k = 0; k < 2; ++k) {
W[u][k] = std::max(W[u << 1][k], W[u << 1 | 1][k]);
LM[u][k] = std::max(LM[u << 1][k], LM[u << 1 | 1][k]);
LM[u][k] = std::max(LM[u][k], W[u << 1][k] + M[u << 1 | 1]);
MR[u][k] = std::max(MR[u << 1][k], MR[u << 1 | 1][k]);
MR[u][k] = std::max(MR[u][k], M[u << 1] + W[u << 1 | 1][k]);
LMR[u][k] = std::max(LMR[u << 1][k], LMR[u << 1 | 1][k]);
}
for (int k1 = 0; k1 < 2; ++k1) {
for (int k2 = 0; k2 < 2; ++k2) {
LMR[u][k1 ^ k2] = std::max(
LMR[u][k1 ^ k2], std::max(LM[u << 1][k1] + W[u << 1 | 1][k2],
W[u << 1][k1] + MR[u << 1 | 1][k2]));
}
}
}
void rev(int u) {
std::swap(W[u][0], W[u][1]);
std::swap(LM[u][0], LM[u][1]);
std::swap(MR[u][0], MR[u][1]);
tag[u] ^= 1;
}
void down(int u) {
if (tag[u]) {
rev(u << 1);
rev(u << 1 | 1);
tag[u] = 0;
}
}
void build(int u, int l, int r) {
if (l == r) {
int k = sum[idt[l]] & 1;
W[u][k] = dep[idt[l]];
M[u] = -2 * dep[idt[l]];
LM[u][k] = MR[u][k] = -dep[idt[l]];
W[u][k ^ 1] = -INF;
LM[u][k ^ 1] = MR[u][k ^ 1] = -INF;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
up(u);
}
void modify(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
rev(u);
return;
}
int mid = (l + r) >> 1;
down(u);
if (L <= mid) {
modify(u << 1, l, mid, L, R);
}
if (R > mid) {
modify(u << 1 | 1, mid + 1, r, L, R);
}
up(u);
}
} T;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n;
for (int i = 1; i < n; ++i) {
int u, v, w;
std::cin >> u >> v >> w;
E[u].push_back({v, w, i});
E[v].push_back({u, w, i});
}
dfs(1, 0);
T.build(1, 1, idx);
std::cin >> q;
int dfcmd = 0;
while (q--) {
int d;
std::cin >> d;
T.modify(1, 1, idx, st[son[d]], ed[son[d]]);
std::cout << T.LMR[1][0] << std::endl;
++dfcmd;
}
}
|
#include <bits/stdc++.h>
template <class T, class U>
inline bool smin(T &x, const U &y) {
return y < x ? x = y, 1 : 0;
}
template <class T, class U>
inline bool smax(T &x, const U &y) {
return x < y ? x = y, 1 : 0;
}
using LL = long long;
using PII = std::pair<int, int>;
constexpr int N(5e5 + 5);
struct Info {
int c, len, d[2][2], r[2];
Info() : c(0), len(0) {
d[0][0] = 0, d[0][1] = -1e9;
d[1][0] = 0, d[1][1] = -1e9;
r[0] = r[1] = -1e9;
}
void reverse() {
std::swap(d[0][0], d[1][0]);
std::swap(d[0][1], d[1][1]);
}
Info &compress(Info a, Info b) {
c = a.c ^ b.c;
len = a.len + b.len;
d[0][0] = std::max(a.d[0][0], a.len + b.d[0][a.c]);
d[0][1] = std::max(a.d[0][1], a.len + b.d[0][!a.c]);
d[1][0] = std::max(b.d[1][0], b.len + a.d[1][b.c]);
d[1][1] = std::max(b.d[1][1], b.len + a.d[1][!b.c]);
r[0] = std::max(
{a.r[0], b.r[0], a.d[1][0] + b.d[0][0], a.d[1][1] + b.d[0][1]});
r[1] = std::max(
{a.r[1], b.r[1], a.d[1][0] + b.d[0][1], a.d[1][1] + b.d[0][0]});
return *this;
}
Info &rake(Info a, Info b) {
c = b.c;
len = b.len;
d[0][0] = std::max(a.d[0][0], b.d[0][0]);
d[0][1] = std::max(a.d[0][1], b.d[0][1]);
d[1][0] = std::max(b.d[1][0], b.len + a.d[0][b.c]);
d[1][1] = std::max(b.d[1][1], b.len + a.d[0][!b.c]);
r[0] = std::max(
{a.r[0], b.r[0], a.d[0][0] + b.d[0][0], a.d[0][1] + b.d[0][1]});
r[1] = std::max(
{a.r[1], b.r[1], a.d[0][0] + b.d[0][1], a.d[0][1] + b.d[0][0]});
return *this;
}
};
struct SplayTree {
static SplayTree *null;
SplayTree *ch[3], *fa;
bool rev;
Info info;
SplayTree() : rev(false), info() {
static bool init = true;
if (init) {
init = false;
null = new SplayTree;
null->ch[0] = null->ch[1] = null->ch[2] = null->fa = null;
}
ch[0] = ch[1] = ch[2] = fa = null;
}
bool notRoot() const { return fa->ch[0] == this || fa->ch[1] == this; }
void reverse() {
rev ^= 1;
std::swap(ch[0], ch[1]);
info.reverse();
}
bool dir() const { return fa->ch[1] == this; }
void sch(int d, SplayTree *c) { ch[d] = c, c->fa = this; }
void rotate() {
SplayTree *p = fa;
bool d = dir();
fa = p->fa;
if (fa != null) {
fa->ch[fa->ch[2] == p ? 2 : p->dir()] = this;
}
p->sch(d, ch[!d]), sch(!d, p);
p->pushup();
}
void splay() {
static SplayTree *s[N], **t;
t = s;
for (auto x = this; x->notRoot(); x = x->fa) *++t = x->fa;
while (t != s) (*t--)->pushdown();
for (pushdown(); notRoot(); rotate()) {
if (fa->notRoot()) {
(fa->dir() == dir() ? fa : this)->rotate();
}
}
pushup();
}
virtual void pushup() {}
virtual void pushdown() {}
virtual ~SplayTree() {}
};
SplayTree *SplayTree::null;
struct RakeTree : SplayTree {
void pushup() {
info.rake(ch[0]->info, Info().rake(ch[2]->info, ch[1]->info));
}
};
struct CompressTree : SplayTree {
void pushup() {
info.compress(ch[0]->info, Info().rake(ch[2]->info, ch[1]->info));
}
void pushdown() {
if (rev) {
rev = false;
ch[0]->reverse(), ch[1]->reverse();
}
}
void access() {
splay();
if (ch[1] != null) {
auto r = new RakeTree;
r->sch(0, ch[2]), r->sch(2, ch[1]), r->pushup();
ch[1] = null, sch(2, r), pushup();
}
for (; fa != null; rotate()) {
fa->splay();
SplayTree *m = fa, *p = m->fa;
assert(p != null);
p->splay();
if (p->ch[1] != null) {
m->sch(2, p->ch[1]);
m->pushup();
} else {
if (m->ch[0] == null) {
p->sch(2, m->ch[1]);
} else if (m->ch[1] == null) {
p->sch(2, m->ch[0]);
} else {
auto x = m->ch[0];
x->fa = null;
while (x->pushdown(), x->ch[1] != null) x = x->ch[1];
x->splay();
p->sch(2, x);
x->sch(1, m->ch[1]);
x->pushup();
}
delete m;
}
p->sch(1, this);
p->pushup();
}
pushup();
}
void evert() { access(), reverse(), pushdown(); }
};
void link(CompressTree *x, CompressTree *y, int c) {
x->access(), y->evert();
auto e = new SplayTree;
e->info.len = 1, e->info.c = c;
x->sch(1, y), y->sch(0, e);
y->pushup(), x->pushup();
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n;
CompressTree *t = new CompressTree[n + 1];
assert(SplayTree::null);
std::vector<int> u(n - 1), v(n - 1);
for (int i = 0, c; i < n - 1; i++) {
std::cin >> u[i] >> v[i] >> c;
link(t + u[i], t + v[i], c);
}
std::cin >> m;
while (m--) {
int i;
std::cin >> i;
i--;
t[u[i]].evert(), t[v[i]].access();
t[u[i]].ch[1]->info.c ^= 1;
t[u[i]].pushup();
t[v[i]].pushup();
std::cout << t[v[i]].info.r[0] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n;
vector<vector<pair<int, int>>> g;
int far(int v) {
vector<int> d(n + 1, -1);
d[v] = 0;
queue<int> q;
q.push(v);
while (!q.empty()) {
int s = q.front();
q.pop();
for (auto x : g[s]) {
int u = x.first;
if (d[u] == -1) {
d[u] = d[s] + 1;
q.push(u);
}
}
}
int id = 1;
for (int i = 2; i <= n; ++i) {
if (d[i] > d[id]) id = i;
}
return id;
}
void dfs(int v, int p, vector<int>& tin, vector<int>& tout, vector<int>& d,
vector<int>& h, vector<int>& e, int& timer) {
tin[v] = timer++;
e.push_back(v);
for (auto x : g[v]) {
int u = x.first, w = x.second;
if (u == p) continue;
d[u] = (d[v] + w) % 2;
h[u] = h[v] + 1;
dfs(u, v, tin, tout, d, h, e, timer);
}
tout[v] = timer;
}
struct segtree {
int size;
vector<vector<int>> tree;
vector<int> modify;
segtree(int n) {
size = 1;
while (size < n) size <<= 1;
tree.resize(2 * size - 1, vector<int>(2));
modify.resize(2 * size - 1);
}
void get(int v) {
tree[v][0] = max(tree[2 * v + 1][0], tree[2 * v + 2][0]);
tree[v][1] = max(tree[2 * v + 1][1], tree[2 * v + 2][1]);
}
void push(int v) {
if (modify[v]) {
modify[2 * v + 1] ^= 1;
modify[2 * v + 2] ^= 1;
swap(tree[2 * v + 1][0], tree[2 * v + 1][1]);
swap(tree[2 * v + 2][0], tree[2 * v + 2][1]);
}
modify[v] = 0;
}
void upd(int v, int lx, int rx, int l, int h, int d) {
if (lx + 1 == rx) {
tree[v][d] = h;
return;
}
int m = (lx + rx) / 2;
if (l < m)
upd(2 * v + 1, lx, m, l, h, d);
else
upd(2 * v + 2, m, rx, l, h, d);
get(v);
}
void upd(int l, int h, int d) { upd(0, 0, size, l, h, d); }
void rev(int v, int lx, int rx, int l, int r) {
if (l <= lx and rx <= r) {
modify[v] ^= 1;
swap(tree[v][0], tree[v][1]);
return;
}
if (rx <= l or r <= lx) {
return;
}
push(v);
int m = (lx + rx) / 2;
rev(2 * v + 1, lx, m, l, r);
rev(2 * v + 2, m, rx, l, r);
get(v);
}
void rev(int l, int r) { rev(0, 0, size, l, r); }
int ans() { return tree[0][0]; }
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
g.resize(n + 1);
vector<vector<int>> edges;
for (int i = 0, u, v, w; i < n - 1; ++i) {
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
edges.push_back({u, v});
}
int S = far(1), T = far(S);
vector<int> tin1(n + 1), tin2(n + 1), h1(n + 1), h2(n + 1), tout1(n + 1),
tout2(n + 1), d1(n + 1), d2(n + 1), e1, e2;
int timer = 0;
dfs(S, -1, tin1, tout1, d1, h1, e1, timer);
timer = 0;
dfs(T, -1, tin2, tout2, d2, h2, e2, timer);
segtree ST1(n), ST2(n);
for (int i = 0; i < n; ++i) {
ST1.upd(i, h1[e1[i]], d1[e1[i]]);
ST2.upd(i, h2[e2[i]], d2[e2[i]]);
}
int q;
cin >> q;
while (q-- > 0) {
int id;
cin >> id;
id--;
int u = edges[id][0], v = edges[id][1];
if (h1[u] > h1[v])
ST1.rev(tin1[u], tout1[u]);
else
ST1.rev(tin1[v], tout1[v]);
if (h2[u] > h2[v])
ST2.rev(tin2[u], tout2[u]);
else
ST2.rev(tin2[v], tout2[v]);
cout << max(ST1.ans(), ST2.ans()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nex[2000000], hea[2000000], wen[2000000], val[2000000], aid[2000000],
root2, root1, len, maxx;
struct segment_tree {
int a[2000000][2], lazy[2000000], fa[1000000], dep[1000000], in[1000000],
out[1000000], m;
void pushdown(int k) {
if (!lazy[k]) return;
swap(a[k << 1][0], a[k << 1][1]);
swap(a[(k << 1) | 1][0], a[(k << 1) | 1][1]);
lazy[k << 1] ^= 1;
lazy[(k << 1) | 1] ^= 1;
lazy[k] = 0;
}
void update1(int l, int r, int k, int x, int y, int z) {
if (l == r) {
a[k][z] = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) update1(l, mid, k << 1, x, y, z);
if (x > mid) update1(mid + 1, r, (k << 1) | 1, x, y, z);
a[k][0] = max(a[k << 1][0], a[(k << 1) | 1][0]);
a[k][1] = max(a[k << 1][1], a[(k << 1) | 1][1]);
}
void update2(int l, int r, int k, int x, int y) {
if (l >= x && r <= y) {
lazy[k] ^= 1;
swap(a[k][0], a[k][1]);
return;
}
pushdown(k);
int mid = (l + r) >> 1;
if (x <= mid) update2(l, mid, k << 1, x, y);
if (y > mid) update2(mid + 1, r, (k << 1) | 1, x, y);
a[k][0] = max(a[k << 1][0], a[(k << 1) | 1][0]);
a[k][1] = max(a[k << 1][1], a[(k << 1) | 1][1]);
}
void build(int x, int y, int z) {
int a = 0;
in[x] = ++m;
dep[x] = dep[y] + 1;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) {
++a;
fa[aid[i]] = wen[i];
build(wen[i], x, z ^ val[i]);
}
update1(1, n, 1, in[x], dep[x], z);
out[x] = m;
}
void revers(int x) { update2(1, n, 1, in[fa[x]], out[fa[x]]); }
} st1, st2;
void add(int x, int y, int z, int p) {
++len;
nex[len] = hea[x];
wen[len] = y;
val[len] = z;
aid[len] = p;
hea[x] = len;
}
void dfs(int x, int y, int z) {
if (z >= maxx) maxx = z, root1 = x;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) dfs(wen[i], x, z + 1);
}
void dfs1(int x, int y, int z) {
if (z >= maxx) maxx = z, root2 = x;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) dfs1(wen[i], x, z + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z, i);
add(y, x, z, i);
}
dfs(1, 0, 0);
dfs1(root1, 0, 0);
st1.build(root1, 0, 0);
st2.build(root2, 0, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
st1.revers(x);
st2.revers(x);
printf("%d\n", max(st1.a[1][0], st2.a[1][0]) - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct E {
int v, w;
};
vector<E> e[500005];
inline void addEdge(int u, int v, int w) { e[u].push_back(E{v, w}); }
struct SegmentTree {
struct T {
int l, r, mid, tag, v[2];
} t[500005 << 2];
int L[500005], R[500005], dep[500005], rk[500005], a[500005], tot;
inline void pushup(int rt) {
t[rt].v[0] = max(t[(rt << 1)].v[0], t[(rt << 1 | 1)].v[0]),
t[rt].v[1] = max(t[(rt << 1)].v[1], t[(rt << 1 | 1)].v[1]);
}
inline void pushdown(int rt) {
if (t[rt].tag)
t[(rt << 1)].tag ^= 1, t[(rt << 1 | 1)].tag ^= 1,
swap(t[(rt << 1)].v[0], t[(rt << 1)].v[1]),
swap(t[(rt << 1 | 1)].v[0], t[(rt << 1 | 1)].v[1]), t[rt].tag = 0;
}
void dfs(int u, int fa) {
L[u] = ++tot, rk[tot] = u, dep[u] = dep[fa] + 1;
for (auto it : e[u])
if (it.v != fa) a[it.v] = a[u] ^ it.w, dfs(it.v, u);
R[u] = tot;
}
void build(int rt, int l, int r) {
int mid = (l + r) >> 1;
t[rt].l = l, t[rt].r = r, t[rt].mid = mid;
if (l == r) {
t[rt].v[a[rk[l]]] = dep[rk[l]];
return;
}
build((rt << 1), l, mid), build((rt << 1 | 1), mid + 1, r), pushup(rt);
}
void update(int rt, int l, int r) {
if (l <= t[rt].l && t[rt].r <= r) {
t[rt].tag ^= 1, swap(t[rt].v[0], t[rt].v[1]);
return;
}
pushdown(rt);
if (l <= t[rt].mid) update((rt << 1), l, r);
if (t[rt].mid < r) update((rt << 1 | 1), l, r);
pushup(rt);
}
} T0, T1;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
if (ch == -1) return 0;
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
int ans, pos;
int dis[500005];
struct node {
int u, v, w;
} g[500005];
int qwq;
void dfs(int u, int fa) {
if (ans < dis[u]) ans = dis[u], pos = u;
for (auto it : e[u])
if (it.v != fa) dis[it.v] = dis[u] + 1, dfs(it.v, u);
}
int main() {
n = read();
int pos1, pos2;
for (int i = 1, u, v, w; i < n; i++)
u = read(), v = read(), w = read(), addEdge(u, v, w), addEdge(v, u, w),
g[++qwq] = {u, v, w};
dfs(1, 0), pos1 = pos, ans = 0, dis[pos] = 0, dfs(pos, 0), pos2 = pos;
T0.dfs(pos1, 0), T0.build(1, 1, n), T1.dfs(pos2, 0), T1.build(1, 1, n),
m = read();
while (m--) {
int x, y, id;
id = read(), x = g[id].u, y = g[id].v;
if (T0.dep[x] < T0.dep[y]) swap(x, y);
T0.update(1, T0.L[x], T0.R[x]);
if (T1.dep[x] < T1.dep[y]) swap(x, y);
T1.update(1, T1.L[x], T1.R[x]);
printf("%d\n", max(T0.t[1].v[0], T1.t[1].v[0]) - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
char ibuf[1 << 20], obuf[1 << 20];
const char *sp, *ep;
char *op = obuf;
int read() {
static int c, x;
while (
(c = (sp == ep && (ep = (sp = ibuf) + fread(ibuf, 1, sizeof ibuf, stdin)),
*sp++)) < 48) {
}
x = c & 15;
while (
(c = (sp == ep && (ep = (sp = ibuf) + fread(ibuf, 1, sizeof ibuf, stdin)),
*sp++)) >= 48)
x = x * 10 + (c & 15);
return x;
}
void write(const int &x) {
if (x >= 10) write(x / 10);
(op == obuf + sizeof obuf && (fwrite(obuf, 1, op - obuf, stdout), op = obuf),
*op++ = ((x % 10) | 48));
}
typedef int arr[500010];
struct edge {
int next, to;
bool v;
} e[500010 << 1];
int n, rt;
arr head, dep;
inline void add(const int &x, const int &y, const bool &z) {
static int ei = 1;
e[++ei].next = head[x];
e[ei].to = y;
e[ei].v = z;
head[x] = ei;
}
void dfs(const int f, const int &fa) {
if (dep[f] > dep[rt]) rt = f;
for (int i = head[f]; i; i = e[i].next) {
const int t = e[i].to;
if (t != fa) {
dep[t] = dep[f] + 1;
dfs(t, f);
}
}
}
struct solver {
int cnt;
arr dep, dfn, out, seg;
bool sum[500010];
int p0[500010 << 2], p1[500010 << 2];
bool tag[500010 << 2];
void dfs(const int &f, const int &fa) {
seg[++cnt] = f;
dfn[f] = cnt;
for (int i = head[f]; i; i = e[i].next) {
const int t = e[i].to;
if (t != fa) {
dep[t] = dep[f] + 1;
sum[t] = sum[f] ^ e[i].v;
dfs(t, f);
}
}
out[f] = cnt;
}
inline void mark(const int &o) {
tag[o] = !tag[o];
std::swap(p0[o], p1[o]);
}
inline void pushup(const int &o) {
p0[o] = std::max(p0[o << 1], p0[o << 1 | 1]);
p1[o] = std::max(p1[o << 1], p1[o << 1 | 1]);
}
void build(const int &o, const int &l, const int &r) {
if (l == r) {
const int x = seg[l];
if (sum[x]) {
p1[o] = dep[x];
} else {
p0[o] = dep[x];
}
return;
}
const int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
pushup(o);
}
void modify(const int &o, const int &l, const int &r, const int &L,
const int &R) {
if (L <= l && r <= R) {
mark(o);
return;
}
const int mid = (l + r) >> 1;
if (tag[o]) {
mark(o << 1);
mark(o << 1 | 1);
tag[o] = false;
}
if (L <= mid) modify(o << 1, l, mid, L, R);
if (mid < R) modify(o << 1 | 1, mid + 1, r, L, R);
pushup(o);
}
inline void modify(const int &id) {
int x = e[id << 1].to, y = e[id << 1 | 1].to;
if (dep[x] < dep[y]) x = y;
modify(1, 1, n, dfn[x], out[x]);
}
} S1, S2;
int main() {
n = read();
for (int i = n; --i;) {
const int x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
S1.dfs(rt, 0);
dep[rt] = 0;
dfs(rt, 0);
S2.dfs(rt, 0);
S1.build(1, 1, n);
S2.build(1, 1, n);
for (int q = read(); q--;) {
const int x = read();
S1.modify(x);
S2.modify(x);
printf("%d\n", std::max(S1.p0[1], S2.p0[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int M = 8e5 + 5;
const int inf = 0x3f3f3f3f;
const long long mod = 1e8 + 7;
const double eps = 1e-8;
const long double pi = acos(-1.0L);
long long read() {
long long x = 0, t = 1;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') t = -1;
while (isdigit(ch)) {
x = 10 * x + ch - '0';
ch = getchar();
}
return x * t;
}
vector<pair<int, int> > e[N];
struct edge {
int u, v, w;
} a[N];
int rt1, rt2, ma;
pair<int, int> ma1[N], ma2[N];
struct node {
int c[N << 2][2], lz[N << 2], in[N], out[N], rk[N], dep[N], col[N], tot;
inline void pushdown(int i) {
swap(c[(i << 1)][0], c[(i << 1)][1]);
swap(c[(i << 1 | 1)][0], c[(i << 1 | 1)][1]);
lz[(i << 1)] ^= 1;
lz[(i << 1 | 1)] ^= 1;
lz[i] = 0;
}
inline void pushup(int i) {
c[i][0] = max(c[(i << 1)][0], c[(i << 1 | 1)][0]);
c[i][1] = max(c[(i << 1)][1], c[(i << 1 | 1)][1]);
}
void build(int i, int l, int r) {
c[i][0] = c[i][1] = lz[i] = 0;
if (l == r) return (void)(c[i][col[rk[l]]] = dep[rk[l]]);
int mid = l + r >> 1;
build((i << 1), l, mid);
build((i << 1 | 1), mid + 1, r);
pushup(i);
}
void update(int i, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return (void)(swap(c[i][0], c[i][1]), lz[i] ^= 1);
int mid = l + r >> 1;
if (lz[i]) pushdown(i);
if (mid >= ll) update((i << 1), l, mid, ll, rr);
if (mid < rr) update((i << 1 | 1), mid + 1, r, ll, rr);
pushup(i);
}
void dfs(int u, int pre) {
in[u] = ++tot;
rk[tot] = u;
dep[u] = dep[pre] + 1;
for (auto x : e[u]) {
int v = x.first, w = x.second;
if (v == pre) continue;
col[v] = col[u] ^ w;
dfs(v, u);
}
out[u] = tot;
}
} tr[2];
void dfs2(int u, int pre) {
ma1[u] = ma2[u] = make_pair(0, u);
for (auto x : e[u]) {
int v = x.first;
if (v == pre) continue;
dfs2(v, u);
pair<int, int> t = ma1[v];
if (t > ma1[u]) swap(t, ma1[u]);
if (t > ma2[u]) ma2[u] = t;
}
if (ma1[u].first + ma2[u].first > ma)
ma = ma1[u].first + ma2[u].first, rt1 = ma1[u].second, rt2 = ma2[u].second;
ma1[u].first++;
ma2[u].first++;
}
int main() {
int n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read(), z = read();
a[i] = edge{x, y, z};
e[x].emplace_back(y, z);
e[y].emplace_back(x, z);
}
dfs2(1, 0);
tr[0].dfs(rt1, 0);
tr[0].build(1, 1, n);
tr[1].dfs(rt2, 0);
tr[1].build(1, 1, n);
int m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = a[x].u;
if (tr[0].dep[a[x].u] < tr[0].dep[a[x].v]) y = a[x].v;
tr[0].update(1, 1, n, tr[0].in[y], tr[0].out[y]);
y = a[x].u;
if (tr[1].dep[a[x].u] < tr[1].dep[a[x].v]) y = a[x].v;
tr[1].update(1, 1, n, tr[1].in[y], tr[1].out[y]);
printf("%d\n", max(tr[0].c[1][0], tr[1].c[1][0]) - 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long DIM = 5E5 + 7;
const long long INF = 1E18;
struct node {
long long first, second, num;
};
vector<node> G[DIM];
long long dist[DIM];
void dfs(long long v, long long par) {
for (auto to : G[v]) {
if (to.first == par) continue;
dist[to.first] = dist[v] + 1;
dfs(to.first, v);
}
}
long long depth[2][DIM], col[2][DIM], tin[2][DIM], tout[2][DIM], vt[2][DIM],
timer = 0, C[2][DIM];
void solve(long long v, long long par, long long type) {
tin[type][v] = ++timer;
vt[type][timer] = v;
for (auto to : G[v]) {
if (to.first == par) continue;
C[type][to.num] = to.first;
col[type][to.first] = col[type][v] ^ to.second;
depth[type][to.first] = depth[type][v] + 1;
solve(to.first, v, type);
}
tout[type][v] = timer;
}
pair<long long, long long> T[2][DIM * 4];
long long mod[2][DIM * 4];
void buildtree(long long t, long long tl, long long tr) {
if (tl == tr) {
if (col[0][vt[0][tl]] == 0) {
T[0][t] = {depth[0][vt[0][tl]], -INF};
} else {
T[0][t] = {-INF, depth[0][vt[0][tl]]};
}
if (col[1][vt[1][tl]] == 0) {
T[1][t] = {depth[1][vt[1][tl]], -INF};
} else {
T[1][t] = {-INF, depth[1][vt[1][tl]]};
}
return;
}
long long tm = (tl + tr) / 2;
buildtree(t * 2 + 1, tl, tm);
buildtree(t * 2 + 2, tm + 1, tr);
for (long long i = 0; i < 2; ++i) {
T[i][t].first = max(T[i][t * 2 + 1].first, T[i][t * 2 + 2].first);
T[i][t].second = max(T[i][t * 2 + 1].second, T[i][t * 2 + 2].second);
}
}
void push(long long t) {
for (long long i = 0; i < 2; ++i) {
if (mod[i][t] == 0) continue;
swap(T[i][t * 2 + 1].first, T[i][t * 2 + 1].second);
swap(T[i][t * 2 + 2].first, T[i][t * 2 + 2].second);
mod[i][t * 2 + 1] ^= 1;
mod[i][t * 2 + 2] ^= 1;
mod[i][t] = 0;
}
}
void update(long long t, long long tl, long long tr, long long l, long long r,
long long type) {
if (tl > r || l > tr) return;
if (l <= tl && tr <= r) {
swap(T[type][t].first, T[type][t].second);
mod[type][t] ^= 1;
return;
}
push(t);
long long tm = (tl + tr) / 2;
update(t * 2 + 1, tl, tm, l, r, type);
update(t * 2 + 2, tm + 1, tr, l, r, type);
T[type][t].first = max(T[type][t * 2 + 1].first, T[type][t * 2 + 2].first);
T[type][t].second = max(T[type][t * 2 + 1].second, T[type][t * 2 + 2].second);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i < n; ++i) {
long long u, v, t;
cin >> u >> v >> t;
G[u].push_back({v, t, i});
G[v].push_back({u, t, i});
}
dfs(1, 0);
long long mx = 0;
for (long long i = 1; i <= n; ++i) {
if (dist[i] > dist[mx]) mx = i;
}
memset(dist, 0, sizeof(dist));
dfs(mx, mx);
long long a = mx, b = 0;
for (long long i = 1; i <= n; ++i) {
if (dist[i] > dist[b]) b = i;
}
solve(a, a, 0);
timer = 0;
solve(b, b, 1);
buildtree(0, 1, n);
long long m;
cin >> m;
while (m--) {
long long q;
cin >> q;
long long v1 = C[0][q], v2 = C[1][q];
update(0, 1, n, tin[0][v1], tout[0][v1], 0);
update(0, 1, n, tin[1][v2], tout[1][v2], 1);
cout << max(T[0][0].first, T[1][0].first) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m;
vector<pair<int, int>> g[N];
int eu[N], ev[N], et[N];
int in[N], out[N], rin[N], dfst;
int val[N], lvl[N];
void dfs(int u, int p) {
in[u] = ++dfst;
rin[in[u]] = u;
for (auto [v, w] : g[u])
if (v != p) {
val[v] = val[u] ^ w;
lvl[v] = lvl[u] + 1;
dfs(v, u);
}
out[u] = dfst;
}
int dist[N];
int bfs(int st) {
for (int i = 1; i <= n; i++) dist[i] = -1;
queue<int> q;
q.push(st);
dist[st] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (dist[u] > dist[st]) st = u;
for (auto [v, w] : g[u])
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
return st;
}
struct Node {
int best[2] = {0, 0}, lz = 0;
};
Node st[4 * N];
void prop(int p, int L, int R) {
if (st[p].lz) {
swap(st[p].best[0], st[p].best[1]);
if (L < R) {
st[2 * p].lz ^= 1;
st[2 * p + 1].lz ^= 1;
}
st[p].lz = 0;
}
}
void upd(int p, int L, int R, int i, int j) {
prop(p, L, R);
if (i > R or j < L) return;
if (L >= i and R <= j) {
st[p].lz = 1;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, j);
upd(2 * p + 1, mid + 1, R, i, j);
st[p].best[0] = max(st[2 * p].best[0], st[2 * p + 1].best[0]);
st[p].best[1] = max(st[2 * p].best[1], st[2 * p + 1].best[1]);
}
void build(int p, int L, int R) {
st[p].lz = 0;
if (L == R) {
int u = rin[L];
st[p].best[1 - val[u]] = 0;
st[p].best[val[u]] = lvl[u];
return;
}
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
st[p].best[0] = max(st[2 * p].best[0], st[2 * p + 1].best[0]);
st[p].best[1] = max(st[2 * p].best[1], st[2 * p + 1].best[1]);
}
int mid[N];
int ans[N];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", eu + i, ev + i, et + i);
g[eu[i]].emplace_back(ev[i], et[i]);
g[ev[i]].emplace_back(eu[i], et[i]);
}
int sa = bfs(1);
int sb = bfs(sa);
lvl[sa] = val[sa] = 0;
dfst = 0;
dfs(sa, sa);
build(1, 1, n);
scanf("%d", &m);
for (int j = 0; j < m; j++) {
scanf("%d", mid + j);
int i = mid[j];
int u = lvl[eu[i]] < lvl[ev[i]] ? ev[i] : eu[i];
upd(1, 1, n, in[u], out[u]);
ans[j] = st[1].best[0];
}
lvl[sb] = val[sb] = 0;
dfst = 0;
dfs(sb, sb);
build(1, 1, n);
for (int j = 0; j < m; j++) {
int i = mid[j];
int u = lvl[eu[i]] < lvl[ev[i]] ? ev[i] : eu[i];
upd(1, 1, n, in[u], out[u]);
printf("%d\n", max(ans[j], st[1].best[0]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode> {
splay_tree_vchs vnode;
using splay_tree<pnode>::ch;
bool rev;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode>() {
root = NULL;
rev = 0;
}
void update() {}
void push() {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
void rotate() {
swap(vnode, this->p->vnode);
splay_tree<pnode>::rotate();
}
void splay() {
bool r = !this->is_root();
splay_tree<pnode>::splay();
if (r && this->p) {
auto v = &this->vnode;
if (v->p) v->p->ch[v->p->ch[1] && v->p->ch[1]->key == NULL] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
v->key = static_cast<pnode>(this);
}
}
void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs(v);
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
x->key = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs() : key(NULL){};
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() { splay_tree_lct::push(); }
void reverse() {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -2);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int eu[500005], ev[500005], ew[500005];
int n, q, tot, st[500005], ed[500005];
int val[2][500005], dist[2][500005];
int dep[500005];
vector<pair<int, int> > G[500005];
void add_edge(int u, int v, int w) {
G[u].push_back(pair<int, int>(v, w));
G[v].push_back(pair<int, int>(u, w));
}
void dfs(int v, int p, int d, bool flag = false) {
if (flag) st[v] = ++tot;
dep[v] = d;
for (auto e : G[v]) {
int to = e.first;
if (to == p) continue;
dfs(to, v, d + 1, flag);
}
if (flag) ed[v] = tot;
}
void dfs2(int v, int p, int d, int sgn, int id) {
val[id][st[v]] = sgn;
dist[id][st[v]] = d;
for (auto e : G[v]) {
int to = e.first, x = e.second;
if (to == p) continue;
dfs2(to, v, d + 1, sgn ^ x, id);
}
}
struct segtree {
int lazy[4 * 500005];
int maxi[2][4 * 500005];
void pushup(int k) {
for (int i = 0; i < 2; i++)
maxi[i][k] = max(maxi[i][k * 2], maxi[i][k * 2 + 1]);
}
void flip(int k) {
swap(maxi[0][k], maxi[1][k]);
lazy[k] ^= 1;
}
void pushdown(int k) {
if (!lazy[k]) return;
for (int i = k * 2; i <= k * 2 + 1; i++) flip(i);
lazy[k] = 0;
}
void build(int k, int l, int r, int id) {
lazy[k] = 0;
if (l == r) {
if (val[id][l] == 0) {
maxi[0][k] = dist[id][l];
maxi[1][k] = -1000000000;
} else {
maxi[0][k] = -1000000000;
maxi[1][k] = dist[id][l];
}
return;
}
int mid = (l + r) / 2;
build(k * 2, l, mid, id);
build(k * 2 + 1, mid + 1, r, id);
pushup(k);
}
void update(int k, int l, int r, int x, int y) {
if (l > y || x > r) return;
if (l >= x && r <= y) {
flip(k);
return;
}
pushdown(k);
int mid = (l + r) / 2;
update(k * 2, l, mid, x, y);
update(k * 2 + 1, mid + 1, r, x, y);
pushup(k);
}
int query() { return maxi[0][1]; }
} seg[2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v, w;
scanf("%d%d%d", &eu[i], &ev[i], &ew[i]);
add_edge(eu[i], ev[i], ew[i]);
}
dfs(1, 0, 0, true);
int maxd = -1000000000, u = -1, v = -1;
for (int i = 1; i <= n; i++) {
if (dep[i] > maxd) {
maxd = dep[i];
u = i;
}
}
dfs(u, 0, 0);
maxd = -1000000000;
for (int i = 1; i <= n; i++) {
if (dep[i] > maxd) {
maxd = dep[i];
v = i;
}
}
dfs(1, 0, 0);
dfs2(u, 0, 0, 0, 0);
dfs2(v, 0, 0, 0, 1);
seg[0].build(1, 1, n, 0);
seg[1].build(1, 1, n, 1);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int id;
scanf("%d", &id);
id--;
int uu = eu[id], vv = ev[id];
if (dep[uu] > dep[vv]) swap(uu, vv);
int l = st[vv], r = ed[vv];
if (st[u] >= l && st[u] <= r) {
seg[0].update(1, 1, n, 1, l - 1);
seg[0].update(1, 1, n, r + 1, n);
} else {
seg[0].update(1, 1, n, l, r);
}
if (st[v] >= l && st[v] <= r) {
seg[1].update(1, 1, n, 1, l - 1);
seg[1].update(1, 1, n, r + 1, n);
} else {
seg[1].update(1, 1, n, l, r);
}
printf("%d\n", max(seg[0].query(), seg[1].query()));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
namespace io {
const int BUFSIZE = 1 << 20;
char ibuf[BUFSIZE + 1], *is = ibuf, *it = ibuf;
char obuf[BUFSIZE + 1], *os = obuf, *ot = obuf + BUFSIZE;
inline char read_char() {
if (is == it) {
it = (is = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
if (is == it) *it++ = EOF;
}
return *is++;
}
template <class T>
inline void read_int(T &x) {
T f = 1;
char c = read_char();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = read_char();
}
x = 0;
while (isdigit(c)) {
x = x * 10 + c - '0';
c = read_char();
}
x *= f;
}
inline void read_str(char *s) {
char c = read_char();
while (c <= ' ') {
c = read_char();
}
while (c > ' ') {
*s++ = c;
c = read_char();
}
*s = 0;
}
inline void flush() {
fwrite(obuf, 1, os - obuf, stdout);
os = obuf;
}
inline void print_char(char c) {
*os++ = c;
if (os == ot) {
flush();
}
}
template <class T>
inline void print_int(T x, char c = 0) {
static char q[40];
if (!x) {
print_char('0');
} else {
if (x < 0) {
print_char('-');
x = -x;
}
int top = 0;
while (x) {
q[top++] = x % 10 + '0';
x /= 10;
}
while (top--) {
print_char(q[top]);
}
}
if (c) print_char(c);
}
inline void print_str(char *s, char c = 0) {
while (*s) {
print_char(*s++);
}
if (c) print_char(c);
}
struct flusher_t {
inline ~flusher_t() { flush(); }
} flusher;
} // namespace io
using io::print_char;
using io::print_int;
using io::print_str;
using io::read_char;
using io::read_int;
using io::read_str;
const int N = 500005;
int n, Q, tot, dfn[N], dl[N], pp[N], dr[N], dfc, st[20][N * 2], lg2[N * 2],
dep[N], dist[N];
vector<pair<int, int> > G[N];
inline int LCA(int l, int r) {
l = dfn[l], r = dfn[r];
if (l > r) swap(l, r);
int i = lg2[r - l + 1];
if (dep[st[i][l]] < dep[st[i][r - (1 << i) + 1]])
return st[i][l];
else
return st[i][r - (1 << i) + 1];
}
inline int getdist(int u, int v) {
return dep[u] + dep[v] - 2 * dep[LCA(u, v)];
}
struct Node {
int u, v, d;
};
inline Node Merge(const Node &a, const Node &b) {
if (a.d == -1) return b;
if (b.d == -1) return a;
Node ret;
if (a.d > b.d) {
ret = a;
} else {
ret = b;
}
int d1 = getdist(a.u, b.u), d2 = getdist(a.u, b.v), d3 = getdist(a.v, b.u),
d4 = getdist(a.v, b.v);
int md = max(max(d1, d2), max(d3, d4));
if (md <= ret.d) return ret;
ret.d = md;
if (d1 == md) {
ret.u = a.u;
ret.v = b.u;
} else if (d2 == md) {
ret.u = a.u;
ret.v = b.v;
} else if (d3 == md) {
ret.u = a.v;
ret.v = b.u;
} else {
ret.u = a.v;
ret.v = b.v;
}
return ret;
}
Node tr[N * 4][2];
int tag[N * 4];
void build(int i, int l, int r) {
tag[i] = 0;
if (l == r) {
int u = pp[l];
tr[i][dist[u]].u = tr[i][dist[u]].v = u;
tr[i][dist[u]].d = 0;
tr[i][dist[u] ^ 1].u = tr[i][dist[u] ^ 1].v = 0;
tr[i][dist[u] ^ 1].d = -1;
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
tr[i][0] = Merge(tr[i << 1][0], tr[i << 1 | 1][0]);
tr[i][1] = Merge(tr[i << 1][1], tr[i << 1 | 1][1]);
}
inline void pushdown(int i) {
if (tag[i]) {
swap(tr[i << 1][0], tr[i << 1][1]);
swap(tr[i << 1 | 1][0], tr[i << 1 | 1][1]);
tag[i << 1] ^= 1;
tag[i << 1 | 1] ^= 1;
tag[i] = 0;
}
}
void modify(int i, int l, int r, int lf, int rg) {
if (lf <= l && r <= rg) {
swap(tr[i][0], tr[i][1]);
tag[i] ^= 1;
return;
}
pushdown(i);
int mid = (l + r) >> 1;
if (lf <= mid) modify(i << 1, l, mid, lf, rg);
if (rg > mid) modify(i << 1 | 1, mid + 1, r, lf, rg);
tr[i][0] = Merge(tr[i << 1][0], tr[i << 1 | 1][0]);
tr[i][1] = Merge(tr[i << 1][1], tr[i << 1 | 1][1]);
}
void dfs(int u, int lst, int depth, int D) {
dl[u] = ++dfc;
pp[dfc] = u;
st[0][dfn[u] = ++tot] = u;
dep[u] = depth;
dist[u] = D;
for (auto &e : G[u]) {
int v = e.first;
if (v == lst) continue;
dfs(v, u, depth + 1, D ^ e.second);
st[0][++tot] = u;
}
dr[u] = dfc;
}
int eu[N], ev[N];
int main() {
read_int(n);
for (int i = 1; i < n; i++) {
int u, v, w;
read_int(u);
eu[i] = u;
read_int(v);
ev[i] = v;
read_int(w);
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
}
tot = 0;
dfs(1, 0, 0, 0);
lg2[0] = -1;
for (int i = 1; i <= tot; i++) lg2[i] = lg2[i - 1] + ((i & (i - 1)) ? 0 : 1);
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= tot - (1 << i) + 1; j++) {
if (dep[st[i - 1][j]] < dep[st[i - 1][j + (1 << (i - 1))]])
st[i][j] = st[i - 1][j];
else
st[i][j] = st[i - 1][j + (1 << (i - 1))];
}
}
build(1, 1, n);
read_int(Q);
for (int i = 1; i < n; i++) {
if (dl[eu[i]] > dl[ev[i]]) swap(eu[i], ev[i]);
}
while (Q--) {
int eid;
read_int(eid);
modify(1, 1, n, dl[ev[eid]], dr[ev[eid]]);
print_int(max(tr[1][0].d, tr[1][1].d), '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch <= '9' && ch >= '0') sum = sum * 10 + ch - '0', ch = getchar();
return sum;
}
int n;
int head[500010], last[500010 << 1], p, v[500010 << 1], val[500010 << 1];
void add(int a, int b, int c) {
v[++p] = b;
last[p] = head[a];
head[a] = p;
val[p] = c;
}
int Val[500010];
int Size[2][500010];
int dep[2][500010];
int dfn[2][500010], cnt;
int fan[2][500010];
struct seg_tree {
int flag;
int mmax[2][500010 << 2];
int rev[500010 << 2];
void gai(int now) {
rev[now] ^= 1;
swap(mmax[0][now], mmax[1][now]);
}
void pushdown(int now) {
if (!rev[now]) return;
gai(now << 1);
gai(now << 1 | 1);
rev[now] = 0;
}
void build(int now, int l, int r) {
if (l == r)
return void(mmax[Val[fan[flag][l]]][now] = dep[flag][fan[flag][l]]);
int mid = l + r >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
up(now);
}
void up(int now) {
mmax[0][now] = max(mmax[0][now << 1], mmax[0][now << 1 | 1]);
mmax[1][now] = max(mmax[1][now << 1], mmax[1][now << 1 | 1]);
}
void modify(int now, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return void(gai(now));
pushdown(now);
int mid = l + r >> 1;
if (ll <= mid) modify(now << 1, l, mid, ll, rr);
if (rr >= mid + 1) modify(now << 1 | 1, mid + 1, r, ll, rr);
up(now);
}
} S[2];
void dfs(int a, int b, int ty) {
Size[ty][a] = 1;
dep[ty][a] = dep[ty][b] + 1;
fan[ty][dfn[ty][a] = ++cnt] = a;
for (int i = head[a]; i; i = last[i])
if (v[i] != b)
Val[v[i]] = Val[a] ^ val[i], dfs(v[i], a, ty),
Size[ty][a] += Size[ty][v[i]];
}
int rt1, rt2;
pair<int, int> st[500010];
int sum[500010];
int lowbit(int w) { return w & (-w); }
void upd(int a, int b) {
for (int i = a; i <= n; i += lowbit(i)) sum[i] ^= b;
}
int cha(int a) {
int u = 0;
for (int i = a; i; i -= lowbit(i)) u ^= sum[i];
return u;
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int l = read(), r = read(), c = read();
add(l, r, c);
add(r, l, c);
st[i] = make_pair(l, r);
}
dfs(1, 0, 0);
cnt = 0;
int mmax = 0;
for (int i = 1; i <= n; i++) mmax = max(mmax, dep[0][i]);
for (int i = 1; i <= n; i++)
if (dep[0][i] == mmax) rt1 = i;
Val[rt1] = 0;
dfs(rt1, 0, 0);
cnt = 0;
mmax = 0;
for (int i = 1; i <= n; i++) mmax = max(mmax, dep[0][i]);
for (int i = 1; i <= n; i++)
if (dep[0][i] == mmax) rt2 = i;
dfs(rt2, 0, 1);
S[0].flag = 0, S[1].flag = 1;
S[0].build(1, 1, n);
S[1].build(1, 1, n);
int q = read();
for (int i = 1; i <= q; i++) {
int id = read();
int l = st[id].first, r = st[id].second;
if (dfn[0][l] > dfn[0][r]) swap(l, r);
upd(dfn[0][r], 1);
upd(dfn[0][r] + Size[0][r], 1);
S[0].modify(1, 1, n, dfn[0][r], dfn[0][r] + Size[0][r] - 1);
if (dfn[1][l] < dfn[1][r]) swap(l, r);
S[1].modify(1, 1, n, dfn[1][l], dfn[1][l] + Size[1][l] - 1);
if (dfn[1][rt1] >= dfn[1][l] && dfn[1][rt1] <= dfn[1][l] + Size[1][l] - 1)
S[1].modify(1, 1, n, 1, n);
int col1 = Val[rt1] ^ cha(dfn[0][rt1]);
int col2 = Val[rt2] ^ cha(dfn[0][rt2]);
if (col1 == col2)
cout << dep[0][rt2] - 1 << '\n';
else {
int ans = max(S[0].mmax[col1][1], S[1].mmax[col2][1]) - 1;
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode> {
splay_tree_vchs vnode;
using splay_tree<pnode>::ch;
bool rev;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode>() {
root = NULL;
rev = 0;
}
void update() {}
void push() {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
void rotate() {
swap(vnode, this->p->vnode);
splay_tree<pnode>::rotate();
}
void splay() {
auto v = &vnode;
bool r = !v->key;
splay_tree<pnode>::splay();
if (r && v->key) {
if (v->p) v->p->ch[v->p->ch[1] == &v->key->vnode] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
v->key = static_cast<pnode>(this);
}
}
void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs(v);
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
x->key = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs() : key(NULL){};
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() { splay_tree_lct::push(); }
void reverse() {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -5);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 19;
int n, q;
struct E {
int to, next, id;
} e[N << 1];
int head[N], cnt;
inline void add(int from, int to, int id) {
e[++cnt].to = to;
e[cnt].next = head[from];
e[cnt].id = id;
head[from] = cnt;
}
int su, rt, dep[N], type[N];
void dfs1(int node, int f) {
dep[node] = dep[f] + 1;
if (dep[node] > dep[rt]) rt = node;
for (int i = head[node]; i; i = e[i].next)
if (e[i].to != f) dfs1(e[i].to, node);
}
int to[N], dfn[N], siz[N], id[N], ind;
bool c[N];
void dfs2(int node, int f) {
dep[node] = dep[f] + 1, siz[node] = 1, id[dfn[node] = ++ind] = node;
for (int i = head[node]; i; i = e[i].next)
if (e[i].to != f)
to[e[i].id] = e[i].to, c[e[i].to] = c[node] ^ type[e[i].id],
dfs2(e[i].to, node), siz[node] += siz[e[i].to];
}
struct Node {
int mx[2];
bool tag;
} tr[N << 2];
inline void push_up(int node) {
for (int i = 0; i < 2; i++)
tr[node].mx[i] = max(tr[(node << 1)].mx[i ^ tr[node].tag],
tr[(node << 1 | 1)].mx[i ^ tr[node].tag]);
}
void build(int node, int L, int R) {
if (L == R) {
tr[node].mx[c[id[L]]] = dep[id[L]];
tr[node].mx[c[id[L]] ^ 1] = 0;
return;
}
int mid = (L + R) >> 1;
build((node << 1), L, mid), build((node << 1 | 1), mid + 1, R);
tr[node].tag = 0, push_up(node);
}
void modify(int node, int L, int R, int l, int r) {
if (l <= L && R <= r) {
swap(tr[node].mx[0], tr[node].mx[1]);
tr[node].tag ^= 1;
return;
}
int mid = (L + R) >> 1;
if (l <= mid) modify((node << 1), L, mid, l, r);
if (r > mid) modify((node << 1 | 1), mid + 1, R, l, r);
push_up(node);
}
int ans[N], Q[N];
void solve(int root) {
ind = 0, dfs2(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; i++)
modify(1, 1, n, dfn[to[Q[i]]], dfn[to[Q[i]]] + siz[to[Q[i]]] - 1),
ans[i] = max(ans[i], tr[1].mx[c[root]]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d%d", &u, &v, &type[i]);
add(u, v, i), add(v, u, i);
}
dfs1(1, 0), dfs1(su = rt, 0);
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d", &Q[i]);
solve(su), solve(rt);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i] - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int __SIZE = (1 << 21) + 1;
char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1,
__c, qu[55];
int __f, qr, _eof;
inline void flush() { fwrite(obuf, 1, oS - obuf, stdout), oS = obuf; }
inline void gc(char &x) {
x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
inline void pstr(const char *s) {
int __len = strlen(s);
for (__f = 0; __f < __len; ++__f) pc(s[__f]);
}
inline void gstr(char *s) {
for (__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
__c < 32 || __c > 126 || __c == ' ';)
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
for (; __c > 31 && __c < 127 && __c != ' ';
++s, __c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*s = __c;
*s = 0;
}
template <class I>
inline bool gi(I &x) {
_eof = 0;
for (__f = 1,
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(__c < '0' || __c > '9') && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) {
if (__c == '-') __f = -1;
_eof |= __c == EOF;
}
for (x = 0; __c <= '9' && __c >= '0' && !_eof;
__c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, __SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (__c & 15), _eof |= __c == EOF;
x *= __f;
return !_eof;
}
template <class I>
inline void print(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io::gc;
using io::gi;
using io::gstr;
using io::pc;
using io::print;
using io::pstr;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1000000007;
pii dat[500005 << 2];
bool laz[500005 << 2];
void push(int idx, int l, int r) {
if (!laz[idx] || l == r) return;
dat[idx * 2] = {dat[idx * 2].second, dat[idx * 2].first};
laz[idx * 2] = !laz[idx * 2];
dat[idx * 2 + 1] = {dat[idx * 2 + 1].second, dat[idx * 2 + 1].first};
laz[idx * 2 + 1] = !laz[idx * 2 + 1];
laz[idx] = 0;
}
void upd(int idx, int l, int r, int i, pii v) {
if (!(l <= i && i <= r)) return;
push(idx, l, r);
if (l == r) {
dat[idx] = v;
return;
}
upd(idx * 2, l, (l + r) / 2, i, v);
upd(idx * 2 + 1, (l + r) / 2 + 1, r, i, v);
dat[idx] = {max(dat[idx * 2].first, dat[idx * 2 + 1].first),
max(dat[idx * 2].second, dat[idx * 2 + 1].second)};
}
void tag(int idx, int l, int r, int ql, int qr) {
if (qr < l || r < ql) return;
push(idx, l, r);
if (ql <= l && r <= qr) {
dat[idx] = {dat[idx].second, dat[idx].first};
laz[idx] = !laz[idx];
return;
}
tag(idx * 2, l, (l + r) / 2, ql, qr);
tag(idx * 2 + 1, (l + r) / 2 + 1, r, ql, qr);
dat[idx] = {max(dat[idx * 2].first, dat[idx * 2 + 1].first),
max(dat[idx * 2].second, dat[idx * 2 + 1].second)};
}
pii el2[500005];
vector<pii> elist[500005];
pii dfsfar(int u, int f) {
pii ans = {0, u};
for (pii &v : elist[u])
if (v.first != f) ans = max(ans, dfsfar(v.first, u));
return {ans.first + 1, ans.second};
}
int clck = 1;
int n;
int L[500005], R[500005];
int qr[500005], ans[500005];
void dfs(int u, int f, int dep, int cnt) {
L[u] = clck++;
if (cnt % 2 == 0)
upd(1, 1, n, L[u], {dep, 0});
else
upd(1, 1, n, L[u], {0, dep});
for (pii &v : elist[u])
if (v.first != f) dfs(v.first, u, dep + 1, cnt + v.second);
R[u] = clck - 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
gi(n);
for (int i = (0); i < (n - 1); i++) {
int u, v, w;
gi(u), gi(v), gi(w);
el2[i] = {u, v};
elist[u].push_back({v, w});
elist[v].push_back({u, w});
}
int root = dfsfar(1, -1).second;
dfs(root, -1, 0, 0);
int q;
gi(q);
for (int i = (0); i < (q); i++) gi(qr[i]);
for (int i = (0); i < (q); i++) {
int par = el2[qr[i] - 1].first, ch = el2[qr[i] - 1].second;
if (R[par] - L[par] < R[ch] - L[ch]) swap(par, ch);
tag(1, 1, n, L[ch], R[ch]);
ans[i] = max(ans[i], dat[1].first);
}
root = dfsfar(root, -1).second;
memset(dat, 0, sizeof dat);
memset(laz, 0, sizeof laz);
clck = 1;
dfs(root, -1, 0, 0);
for (int i = (0); i < (q); i++) {
int par = el2[qr[i] - 1].first, ch = el2[qr[i] - 1].second;
if (R[par] - L[par] < R[ch] - L[ch]) swap(par, ch);
tag(1, 1, n, L[ch], R[ch]);
ans[i] = max(ans[i], dat[1].first);
print(ans[i]), pc('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool chkmin(T1 &x, T2 y) {
return y < x ? (x = y, true) : false;
}
template <typename T1, typename T2>
bool chkmax(T1 &x, T2 y) {
return y > x ? (x = y, true) : false;
}
void debug_out() { cerr << endl; }
template <typename T1, typename... T2>
void debug_out(T1 A, T2... B) {
cerr << ' ' << A;
debug_out(B...);
}
const long long INF32 = 1e8;
const long long maxN = 500005;
long long N;
vector<pair<long long, long long> > G[maxN];
long long H[maxN], T[maxN];
long long tin[maxN], tout[maxN];
long long ord[2 * maxN], ptr;
void dfs(long long v, long long pr = -1) {
tin[v] = ptr;
ord[ptr++] = v;
for (auto p : G[v])
if (p.first != pr) {
long long u = p.first;
long long dt = p.second;
H[u] = H[v] + 1;
T[u] = T[v] ^ dt;
dfs(u, v);
ord[ptr++] = v;
}
tout[v] = ptr - 1;
}
struct Node {
long long t;
long long max_v[2];
long long max_c;
long long max_vc[2];
long long max_cv[2];
long long max_vcv[2];
Node() {
t = 0;
max_c = -INF32;
for (long long j = 0; j < 2; ++j)
max_v[j] = max_vc[j] = max_cv[j] = max_vcv[j] = -INF32;
}
} sgt[(1 << 21) + 1337];
void apply(long long v) {
sgt[v].t ^= 1;
swap(sgt[v].max_v[0], sgt[v].max_v[1]);
swap(sgt[v].max_vc[0], sgt[v].max_vc[1]);
swap(sgt[v].max_cv[0], sgt[v].max_cv[1]);
swap(sgt[v].max_vcv[0], sgt[v].max_vcv[1]);
}
void push(long long v, long long vl, long long vr) {
if (vl == vr || !sgt[v].t) return;
apply(v << 1);
apply(v << 1 | 1);
sgt[v].t = 0;
}
void upd(long long v, long long vl, long long vr) {
if (vl == vr) return;
sgt[v].max_c = max(sgt[v << 1].max_c, sgt[v << 1 | 1].max_c);
for (long long j = 0; j < 2; ++j) {
sgt[v].max_v[j] = max(sgt[v << 1].max_v[j], sgt[v << 1 | 1].max_v[j]);
sgt[v].max_vc[j] = max(sgt[v << 1].max_vc[j], sgt[v << 1 | 1].max_vc[j]);
chkmax(sgt[v].max_vc[j], sgt[v << 1].max_v[j] + sgt[v << 1 | 1].max_c);
sgt[v].max_cv[j] = max(sgt[v << 1].max_cv[j], sgt[v << 1 | 1].max_cv[j]);
chkmax(sgt[v].max_cv[j], sgt[v << 1].max_c + sgt[v << 1 | 1].max_v[j]);
sgt[v].max_vcv[j] = max(sgt[v << 1].max_vcv[j], sgt[v << 1 | 1].max_vcv[j]);
chkmax(sgt[v].max_vcv[j], sgt[v << 1].max_v[j] + sgt[v << 1 | 1].max_cv[j]);
chkmax(sgt[v].max_vcv[j], sgt[v << 1].max_vc[j] + sgt[v << 1 | 1].max_v[j]);
}
}
void build(long long v, long long vl, long long vr) {
if (vl == vr) {
long long u = ord[vl];
sgt[v].t = T[u];
sgt[v].max_v[sgt[v].t] = H[u];
sgt[v].max_c = -2 * H[u];
sgt[v].max_vc[sgt[v].t] = -H[u];
sgt[v].max_cv[sgt[v].t] = -H[u];
return;
}
long long vm = (vl + vr) >> 1;
build(v << 1, vl, vm);
build(v << 1 | 1, vm + 1, vr);
upd(v, vl, vr);
}
void inv(long long v, long long vl, long long vr, long long l, long long r) {
if (vr < l || r < vl || l > r) return;
if (l <= vl && vr <= r) {
apply(v);
return;
}
long long vm = (vl + vr) >> 1;
push(v, vl, vr);
inv(v << 1, vl, vm, l, r);
inv(v << 1 | 1, vm + 1, vr, l, r);
upd(v, vl, vr);
}
pair<long long, long long> edges[maxN];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (long long i = 0; i < N - 1; ++i) {
long long a, b, t;
cin >> a >> b >> t;
edges[i + 1] = {a, b};
G[a].emplace_back(b, t);
G[b].emplace_back(a, t);
}
dfs(1);
build(1, 0, ptr - 1);
long long Q;
cin >> Q;
while (Q--) {
long long idx;
cin >> idx;
long long v = edges[idx].first;
if (H[edges[idx].second] > H[edges[idx].first]) v = edges[idx].second;
inv(1, 0, ptr - 1, tin[v], tout[v]);
long long ans = 0;
for (long long j = 0; j < 2; ++j) chkmax(ans, sgt[1].max_vcv[j]);
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
static char c;
int f = 0;
while (!isdigit(c = getchar()))
if (c == '-') f = 1;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
if (f) x = -x;
}
void read(long long &x) {
static char c;
int f = 0;
while (!isdigit(c = getchar()))
if (c == '-') f = 1;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
}
void read(unsigned int &x) {
static char c;
while (!isdigit(c = getchar()))
;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
}
void read(unsigned long long &x) {
static char c;
while (!isdigit(c = getchar()))
;
x = c ^ 48;
while (isdigit(c = getchar())) x = (x * 10) + (c ^ 48);
}
void chkmax(int &x, int y) {
if (y > x) x = y;
}
void chkmin(int &x, int y) {
if (y < x) x = y;
}
void chkmax(long long &x, long long y) {
if (y > x) x = y;
}
void chkmin(long long &x, long long y) {
if (y < x) x = y;
}
void chkmax(unsigned int &x, unsigned int y) {
if (y > x) x = y;
}
void chkmin(unsigned int &x, unsigned int y) {
if (y < x) x = y;
}
void chkmax(unsigned long long &x, unsigned long long y) {
if (y > x) x = y;
}
void chkmin(unsigned long long &x, unsigned long long y) {
if (y < x) x = y;
}
const int N = 5e5 + 10;
int n, q;
struct Link {
int u, v, w;
} L[N];
struct Edge {
int v, nxt, w;
} ed[N << 1];
int head[N], cnt;
void adde(int u, int v, int w) {
ed[++cnt] = (Edge){v, head[u], w}, head[u] = cnt;
}
void add(int u, int v, int w) { adde(u, v, w), adde(v, u, w); }
int siz[N], dep[N], col[N];
int Dfn[N], seg[N], Dtot;
int Eul[N << 1], Beg[N], Etot;
void Build(int now, int fa) {
siz[now] = 1, dep[now] = dep[fa] + 1;
Dfn[now] = ++Dtot, seg[Dtot] = now, Beg[now] = ++Etot, Eul[Etot] = dep[now];
for (int i = head[now]; i; i = ed[i].nxt) {
int v = ed[i].v;
if (v == fa) continue;
col[v] = col[now] ^ ed[i].w;
Build(v, now), siz[now] += siz[v];
Eul[++Etot] = dep[now];
}
}
int _log2[N << 1], ST[22][N << 1];
void Init() {
const int _n = 2 * n - 1;
for (int i = 2; i <= _n; ++i) _log2[i] = _log2[i >> 1] + 1;
for (int i = 1; i <= _n; ++i) ST[0][i] = Eul[i];
for (int B = 1; B <= _log2[_n]; ++B)
for (int i = 1; i + (1 << B) - 1 <= _n; ++i)
ST[B][i] = min(ST[B - 1][i], ST[B - 1][i + (1 << (B - 1))]);
}
int Getmin(int l, int r) {
int k = _log2[r - l + 1];
return min(ST[k][l], ST[k][r - (1 << k) + 1]);
}
int Dist(int u, int v) {
if (Beg[u] > Beg[v]) swap(u, v);
return dep[u] + dep[v] - 2 * Getmin(Beg[u], Beg[v]);
}
struct Node {
pair<int, int> pr[2];
int dis[2];
int tag;
} t[N << 2];
void Pushdown(int now) {
const int ls = now << 1, rs = now << 1 | 1;
if (t[now].tag)
swap(t[ls].pr[0], t[ls].pr[1]), swap(t[ls].dis[0], t[ls].dis[1]),
swap(t[rs].pr[0], t[rs].pr[1]), swap(t[rs].dis[0], t[rs].dis[1]),
t[ls].tag ^= 1, t[rs].tag ^= 1, t[now].tag = 0;
}
void Update(int now) {
const int ls = now << 1, rs = now << 1 | 1;
auto Check = [](int now, int C, int u, int v) -> void {
if (!(u && v)) return;
int dis = Dist(u, v);
if (dis >= t[now].dis[C])
t[now].pr[C] = make_pair(u, v), t[now].dis[C] = dis;
};
for (int C : {0, 1}) {
t[now].pr[C] = make_pair(0, 0), t[now].dis[C] = 0;
Check(now, C, t[ls].pr[C].first, t[ls].pr[C].second);
Check(now, C, t[rs].pr[C].first, t[rs].pr[C].second);
Check(now, C, t[ls].pr[C].first, t[rs].pr[C].first);
Check(now, C, t[ls].pr[C].first, t[rs].pr[C].second);
Check(now, C, t[ls].pr[C].second, t[rs].pr[C].first);
Check(now, C, t[ls].pr[C].second, t[rs].pr[C].second);
}
}
void Build(int now, int l, int r) {
if (l == r) return t[now].pr[col[seg[l]]] = make_pair(seg[l], seg[l]), void();
const int ls = now << 1, rs = now << 1 | 1, mid = (l + r) >> 1;
Build(ls, l, mid), Build(rs, mid + 1, r), Update(now);
}
void Modify(int now, int l, int r, int x, int y) {
if (l >= x && r <= y) {
swap(t[now].pr[0], t[now].pr[1]);
swap(t[now].dis[0], t[now].dis[1]);
t[now].tag ^= 1;
return;
}
Pushdown(now);
const int ls = now << 1, rs = now << 1 | 1, mid = (l + r) >> 1;
if (mid >= x) Modify(ls, l, mid, x, y);
if (mid < y) Modify(rs, mid + 1, r, x, y);
Update(now);
}
void Work() {
read(n);
for (int i = 1; i < n; ++i)
read(L[i].u), read(L[i].v), read(L[i].w), add(L[i].u, L[i].v, L[i].w);
Build(1, 0), Init(), Build(1, 1, n);
for (int i = 1; i < n; ++i)
if (Dfn[L[i].u] < Dfn[L[i].v]) swap(L[i].u, L[i].v);
read(q);
while (q--) {
int id;
read(id);
Modify(1, 1, n, Dfn[L[id].u], Dfn[L[id].u] + siz[L[id].u] - 1);
printf("%d\n", max(t[1].dis[0], t[1].dis[1]));
}
}
int main() { Work(); }
|
#include <bits/stdc++.h>
using namespace std;
int n, q, i, j, k, mxl[500005], g[500005], a[500005][2];
int em, e[500005 * 2], nx[500005 * 2], ls[500005], ec[500005 * 2];
void read(int &x) {
x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
void insert(int x, int y, int z) {
em++;
e[em] = y;
nx[em] = ls[x];
ls[x] = em;
ec[em] = z;
em++;
e[em] = x;
nx[em] = ls[y];
ls[y] = em;
ec[em] = z;
}
struct Tree {
int rt, v[500005], dfn[500005], sz[500005], tot, dep[500005], Idfn[500005];
void dfs(int x, int p) {
dfn[x] = ++tot, Idfn[tot] = x, sz[x] = 1, dep[x] = dep[p] + 1;
for (int i = ls[x]; i; i = nx[i])
if (e[i] != p) v[e[i]] = v[x] ^ ec[i], dfs(e[i], x), sz[x] += sz[e[i]];
}
int t[500005 * 4][2], tag[500005 * 4];
void maketree(int x, int l, int r) {
if (l == r) {
t[x][v[Idfn[l]]] = dep[Idfn[l]];
return;
}
int mid = (l + r) >> 1;
maketree(x << 1, l, mid), maketree(x << 1 ^ 1, mid + 1, r);
t[x][0] = max(t[x << 1][0], t[x << 1 ^ 1][0]);
t[x][1] = max(t[x << 1][1], t[x << 1 ^ 1][1]);
}
void downtag(int x, int l, int r) {
swap(t[x][0], t[x][1]);
if (l < r) tag[x << 1] ^= tag[x], tag[x << 1 ^ 1] ^= tag[x];
tag[x] = 0;
}
void change(int x, int l, int r, int L, int R) {
if (tag[x]) downtag(x, l, r);
if (l > R || r < L) return;
if (L <= l && r <= R) {
tag[x] ^= 1, downtag(x, l, r);
return;
}
int mid = (l + r) >> 1;
change(x << 1, l, mid, L, R), change(x << 1 ^ 1, mid + 1, r, L, R);
t[x][0] = max(t[x << 1][0], t[x << 1 ^ 1][0]);
t[x][1] = max(t[x << 1][1], t[x << 1 ^ 1][1]);
}
int find(int x, int l, int r, int L, int R) {
if (tag[x]) downtag(x, l, r);
if (l > R || r < L) return 0;
if (L <= l && r <= R) return t[x][0];
int mid = (l + r) >> 1;
return max(find(x << 1, l, mid, L, R), find(x << 1 ^ 1, mid + 1, r, L, R));
}
void prepare() { dfs(rt, 0), maketree(1, 1, n); }
void rev(int i) {
int x = a[i][0], y = a[i][1];
if (dfn[x] > dfn[y]) swap(x, y);
change(1, 1, n, dfn[y], dfn[y] + sz[y] - 1);
}
int get() { return t[1][0] - 1; }
} t1, t2;
int mx;
void dfs(int x, int p) {
mxl[x] = 0, g[x] = x;
for (int i = ls[x]; i; i = nx[i])
if (e[i] != p) {
dfs(e[i], x);
if (mxl[x] + mxl[e[i]] + 1 > mx)
mx = mxl[x] + mxl[e[i]] + 1, t1.rt = g[x], t2.rt = g[e[i]];
if (mxl[e[i]] + 1 > mxl[x]) mxl[x] = mxl[e[i]] + 1, g[x] = g[e[i]];
}
}
int main() {
read(n);
for (i = 1; i < n; i++) {
int x, y, z;
read(x), read(y), read(z);
insert(x, y, z), a[i][0] = x, a[i][1] = y;
}
dfs(1, 0);
t1.prepare(), t2.prepare();
read(q);
while (q--) {
read(k);
t1.rev(k), t2.rev(k);
printf("%d\n", max(t1.get(), t2.get()));
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
struct node {
int v0, v1, lazy;
};
vector<node> tree;
void init(int n) {
tree.resize(4 * n);
for (int i = 0; i < 4 * n; i++) {
tree[i].v0 = tree[i].v1 = tree[i].lazy = 0;
}
}
void push(int h, int tl, int tr) {
if (tl < tr) {
tree[h * 2].lazy ^= tree[h].lazy;
tree[h * 2 + 1].lazy ^= tree[h].lazy;
}
if (tree[h].lazy) {
swap(tree[h].v0, tree[h].v1);
tree[h].lazy = 0;
}
}
void build(int p, int b, int x, int tl, int tr, int h = 1) {
if (tr < p || p < tl) return;
if (tl == tr) {
if (b == 0)
tree[h].v0 = x;
else
tree[h].v1 = x;
return;
}
int mid = (tl + tr) / 2;
build(p, b, x, tl, mid, h * 2);
build(p, b, x, mid + 1, tr, h * 2 + 1);
tree[h].v0 = max(tree[h * 2].v0, tree[h * 2 + 1].v0);
tree[h].v1 = max(tree[h * 2].v1, tree[h * 2 + 1].v1);
}
void update(int l, int r, int tl, int tr, int h = 1) {
push(h, tl, tr);
if (l > r || r < tl || tr < l) return;
if (l <= tl && tr <= r) {
tree[h].lazy = 1;
push(h, tl, tr);
return;
}
int mid = (tl + tr) / 2;
update(l, r, tl, mid, h * 2);
update(l, r, mid + 1, tr, h * 2 + 1);
tree[h].v0 = max(tree[h * 2].v0, tree[h * 2 + 1].v0);
tree[h].v1 = max(tree[h * 2].v1, tree[h * 2 + 1].v1);
}
int query() { return tree[1].v0; }
} st[2];
int n, m;
int L[2][500010], R[2][500010], cur;
vector<pair<int, int> > g[500010];
vector<pair<int, int> > edges;
pair<int, int> far(int p, int u, int d) {
pair<int, int> ret = {d, u};
for (auto& it : g[u]) {
if (it.first == p) continue;
pair<int, int> v = far(u, it.first, d + 1);
if (ret.first < v.first) ret = v;
}
return ret;
}
void dfs(int p, int u, int b, int d, int t) {
L[t][u] = ++cur;
st[t].build(cur, b, d, 1, n);
for (auto& it : g[u]) {
if (it.first == p) continue;
dfs(u, it.first, b ^ (it.second), d + 1, t);
}
R[t][u] = cur;
}
void prepare(int t, int u) {
st[t].init(n);
cur = 0;
dfs(u, u, 0, 0, t);
}
void proc(int t, int u, int v) {
if (L[t][u] > L[t][v]) swap(u, v);
st[t].update(L[t][v], R[t][v], 1, n);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int i, j;
cin >> n;
for (i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
g[u].push_back({v, t});
g[v].push_back({u, t});
edges.push_back({u, v});
}
int A = far(1, 1, 0).second;
int B = far(A, A, 0).second;
prepare(0, A);
prepare(1, B);
cin >> m;
for (i = 0; i < m; i++) {
cin >> j;
j--;
int u = edges[j].first, v = edges[j].second;
proc(0, u, v);
proc(1, u, v);
cout << max(st[0].query(), st[1].query()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return x == 0 ? -1 : 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (maximum_mode ? values[b] < values[a] : values[a] < values[b]) ? a
: b;
}
void build(const vector<T> &_values) {
values = _values;
n = int(values.size());
int levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
struct LCA {
int n = 0;
vector<vector<int>> adj;
vector<int> parent, depth, subtree_size;
vector<int> euler, first_occurrence;
vector<int> tour_start, tour_end, postorder;
vector<int> tour_list, rev_tour_list;
vector<int> heavy_root;
RMQ<int> rmq;
bool built;
LCA(int _n = 0) { init(_n); }
LCA(const vector<vector<int>> &_adj) { init(_adj); }
void init(int _n) {
n = _n;
adj.assign(n, {});
parent.resize(n);
depth.resize(n);
subtree_size.resize(n);
first_occurrence.resize(n);
tour_start.resize(n);
tour_end.resize(n);
postorder.resize(n);
tour_list.resize(n);
heavy_root.resize(n);
built = false;
}
void init(const vector<vector<int>> &_adj) {
init(int(_adj.size()));
adj = _adj;
}
void add_edge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
int degree(int v) const {
return int(adj[v].size()) + (built && parent[v] >= 0);
}
void dfs(int node, int par) {
parent[node] = par;
depth[node] = par < 0 ? 0 : depth[par] + 1;
subtree_size[node] = 1;
adj[node].erase(remove(adj[node].begin(), adj[node].end(), par),
adj[node].end());
for (int child : adj[node]) {
dfs(child, node);
subtree_size[node] += subtree_size[child];
}
sort(adj[node].begin(), adj[node].end(),
[&](int a, int b) { return subtree_size[a] > subtree_size[b]; });
}
int tour, post_tour;
void tour_dfs(int node, bool heavy) {
heavy_root[node] = heavy ? heavy_root[parent[node]] : node;
first_occurrence[node] = int(euler.size());
euler.push_back(node);
tour_list[tour] = node;
tour_start[node] = tour++;
bool heavy_child = true;
for (int child : adj[node]) {
tour_dfs(child, heavy_child);
euler.push_back(node);
heavy_child = false;
}
tour_end[node] = tour;
postorder[node] = post_tour++;
}
void build(int root = -1) {
parent.assign(n, -1);
if (0 <= root && root < n) dfs(root, -1);
for (int i = 0; i < n; i++)
if (i != root && parent[i] < 0) dfs(i, -1);
tour = post_tour = 0;
euler.clear();
euler.reserve(2 * n);
for (int i = 0; i < n; i++)
if (parent[i] < 0) {
tour_dfs(i, false);
euler.push_back(-1);
}
rev_tour_list = tour_list;
reverse(rev_tour_list.begin(), rev_tour_list.end());
assert(int(euler.size()) == 2 * n);
vector<int> euler_depths;
euler_depths.reserve(euler.size());
for (int node : euler)
euler_depths.push_back(node < 0 ? node : depth[node]);
rmq.build(euler_depths);
built = true;
}
pair<int, int> find_farthest(int node, int par, int path) const {
pair<int, int> current = {path, node};
for (int neighbor : adj[node])
if (neighbor != par)
current = max(current, find_farthest(neighbor, node, path + 1));
return current;
}
pair<int, array<int, 2>> get_diameter() const {
int u = find_farthest(0, -1, 0).second;
pair<int, int> farthest = find_farthest(u, -1, 0);
int v = farthest.second;
return {farthest.first, {u, v}};
}
int get_lca(int a, int b) const {
a = first_occurrence[a];
b = first_occurrence[b];
if (a > b) swap(a, b);
return euler[rmq.query_index(a, b + 1)];
}
bool is_ancestor(int a, int b) const {
return tour_start[a] <= tour_start[b] && tour_start[b] < tour_end[a];
}
bool on_path(int x, int a, int b) const {
return (is_ancestor(x, a) || is_ancestor(x, b)) &&
is_ancestor(get_lca(a, b), x);
}
int get_dist(int a, int b) const {
return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
}
int child_ancestor(int a, int b) const {
assert(a != b);
assert(is_ancestor(a, b));
int child =
euler[rmq.query_index(first_occurrence[a], first_occurrence[b] + 1) +
1];
assert(parent[child] == a);
assert(is_ancestor(child, b));
return child;
}
int get_kth_ancestor(int a, int k) const {
while (a >= 0) {
int root = heavy_root[a];
if (depth[root] <= depth[a] - k) return tour_list[tour_start[a] - k];
k -= depth[a] - depth[root] + 1;
a = parent[root];
}
return a;
}
int get_kth_node_on_path(int a, int b, int k) const {
int anc = get_lca(a, b);
int first_half = depth[a] - depth[anc];
int second_half = depth[b] - depth[anc];
assert(0 <= k && k <= first_half + second_half);
if (k < first_half)
return get_kth_ancestor(a, k);
else
return get_kth_ancestor(b, first_half + second_half - k);
}
int get_common_node(int a, int b, int c) const {
int x = get_lca(a, b);
int y = get_lca(b, c);
int z = get_lca(c, a);
if (depth[y] > depth[x]) x = y;
if (depth[z] > depth[x]) x = z;
return x;
}
vector<pair<int, int>> compress_tree(vector<int> nodes) const {
if (nodes.empty()) return {};
auto &&compare_tour = [&](int a, int b) {
return tour_start[a] < tour_start[b];
};
sort(nodes.begin(), nodes.end(), compare_tour);
int k = int(nodes.size());
for (int i = 0; i < k - 1; i++)
nodes.push_back(get_lca(nodes[i], nodes[i + 1]));
sort(nodes.begin() + k, nodes.end(), compare_tour);
inplace_merge(nodes.begin(), nodes.begin() + k, nodes.end(), compare_tour);
nodes.erase(unique(nodes.begin(), nodes.end()), nodes.end());
vector<pair<int, int>> result = {{nodes[0], -1}};
for (int i = 1; i < int(nodes.size()); i++)
result.emplace_back(nodes[i], get_lca(nodes[i], nodes[i - 1]));
return result;
}
};
const int INF = 1e9 + 5;
struct segment_change {
bool flip;
segment_change(bool _flip = false) : flip(_flip) {}
void reset() { flip = false; }
bool has_change() const { return flip; }
segment_change combine(const segment_change &other) const {
return segment_change(flip ^ other.flip);
}
};
struct segment {
int deepest[2] = {-INF, -INF};
void apply(int, const segment_change &change) {
if (change.flip) swap(deepest[0], deepest[1]);
}
void join(const segment &other) {
for (int r = 0; r < 2; r++) deepest[r] = max(deepest[r], other.deepest[r]);
}
void join(const segment &a, const segment &b) {
*this = a;
join(b);
}
};
pair<int, int> right_half[32];
struct seg_tree {
int tree_n = 0;
vector<segment> tree;
vector<segment_change> changes;
seg_tree(int n = -1) {
if (n >= 0) init(n);
}
void init(int n) {
tree_n = 1;
while (tree_n < n) tree_n *= 2;
tree.assign(2 * tree_n, segment());
changes.assign(tree_n, segment_change());
}
void build(const vector<segment> &initial) {
int n = int(initial.size());
init(n);
assert(n <= tree_n);
for (int i = 0; i < n; i++) tree[tree_n + i] = initial[i];
for (int position = tree_n - 1; position > 0; position--)
tree[position].join(tree[2 * position], tree[2 * position + 1]);
}
void apply_and_combine(int position, int length,
const segment_change &change) {
tree[position].apply(length, change);
if (position < tree_n)
changes[position] = changes[position].combine(change);
}
void push_down(int position, int length) {
if (changes[position].has_change()) {
apply_and_combine(2 * position, length / 2, changes[position]);
apply_and_combine(2 * position + 1, length / 2, changes[position]);
changes[position].reset();
}
}
void push_all(int a, int b) {
assert(0 <= a && a < b && b <= tree_n);
a += tree_n;
b += tree_n - 1;
for (int up = 31 - __builtin_clz(tree_n); up > 0; up--) {
int x = a >> up, y = b >> up;
push_down(x, 1 << up);
if (x != y) push_down(y, 1 << up);
}
}
void join_and_apply(int position, int length) {
tree[position].join(tree[2 * position], tree[2 * position + 1]);
tree[position].apply(length, changes[position]);
}
void join_all(int a, int b) {
assert(0 <= a && a < b && b <= tree_n);
a += tree_n;
b += tree_n - 1;
int length = 1;
while (a > 1) {
a /= 2;
b /= 2;
length *= 2;
join_and_apply(a, length);
if (a != b) join_and_apply(b, length);
}
}
template <typename T_range_op>
void process_range(int a, int b, bool needs_join, T_range_op &&range_op) {
if (a == b) return;
push_all(a, b);
int original_a = a, original_b = b;
int length = 1, r_size = 0;
for (a += tree_n, b += tree_n; a < b; a /= 2, b /= 2, length *= 2) {
if (a & 1) range_op(a++, length);
if (b & 1) right_half[r_size++] = {--b, length};
}
for (int i = r_size - 1; i >= 0; i--)
range_op(right_half[i].first, right_half[i].second);
if (needs_join) join_all(original_a, original_b);
}
segment query(int a, int b) {
assert(0 <= a && a <= b && b <= tree_n);
segment answer;
process_range(a, b, false,
[&](int position, int) { answer.join(tree[position]); });
return answer;
}
void update(int a, int b, const segment_change &change) {
assert(0 <= a && a <= b && b <= tree_n);
process_range(a, b, true, [&](int position, int length) {
apply_and_combine(position, length, change);
});
}
vector<segment> to_array() {
for (int i = 1; i < tree_n; i++)
push_down(i, tree_n >> (31 - __builtin_clz(i)));
vector<segment> segs(tree_n);
for (int i = 0; i < tree_n; i++) segs[i] = tree[tree_n + i];
return segs;
}
void update_single(int index, const segment &seg);
template <typename T_bool>
int find_last_prefix(int n, T_bool &&should_join);
template <typename T_bool>
int find_last_subarray(int n, int start, T_bool &&should_join);
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
LCA lca[2] = {LCA(N), LCA(N)};
vector<array<int, 2>> edges(N - 1);
vector<bool> status(N - 1);
for (int e = 0; e < N - 1; e++) {
int u, v, s;
cin >> u >> v >> s;
u--;
v--;
edges[e] = {u, v};
status[e] = s;
for (int t = 0; t < 2; t++) lca[t].add_edge(u, v);
}
array<int, 2> diameter = lca[0].get_diameter().second;
for (int t = 0; t < 2; t++) lca[t].build(diameter[t]);
seg_tree tree[2] = {seg_tree(N), seg_tree(N)};
for (int t = 0; t < 2; t++) {
vector<segment> initial(N);
for (int node = 0; node < N; node++)
initial[lca[t].tour_start[node]].deepest[0] = lca[t].depth[node];
tree[t].build(initial);
}
auto query = [&] {
return max(tree[0].tree[1].deepest[0], tree[1].tree[1].deepest[0]);
};
auto flip_edge = [&](int a, int b) {
for (int t = 0; t < 2; t++) {
int v = lca[t].depth[a] > lca[t].depth[b] ? a : b;
tree[t].update(lca[t].tour_start[v], lca[t].tour_end[v],
segment_change(true));
}
};
for (int e = 0; e < N - 1; e++)
if (status[e]) flip_edge(edges[e][0], edges[e][1]);
int M;
cin >> M;
for (int q = 0; q < M; q++) {
int id;
cin >> id;
id--;
flip_edge(edges[id][0], edges[id][1]);
cout << query() << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(4)
using namespace std;
char _buf[100000], *_p1 = _buf, *_p2 = _buf;
inline int gi() {
int x = 0, f = 1;
char ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
}
return (f == 1) ? x : -x;
}
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
const int maxn = 5e5 + 5;
int n, p[maxn], sz, maxpos, maxdis, fa[maxn], Q;
struct node {
int u, v, w;
};
vector<node> edg;
struct edge {
int v, w, nxt;
edge(int vv = 0, int ww = 0, int nn = 0) { v = vv, w = ww, nxt = nn; }
} e[maxn << 1];
inline void add(int u, int v, int w) {
e[++sz] = edge(v, w, p[u]);
p[u] = sz;
}
struct segmentree {
static const int maxn = 2e6 + 5;
int rt;
int dep[maxn], tot, dfn[maxn], siz[maxn], len[maxn], rk[maxn];
bool tag[maxn];
int maxv[maxn][2];
inline void pushup(int u) {
for (int i = 0; i <= 1; ++i) {
if (maxv[u << 1][i] > maxv[u << 1 | 1][i])
maxv[u][i] = maxv[u << 1][i];
else
maxv[u][i] = maxv[u << 1 | 1][i];
}
}
inline void pushdown(int u) {
if (tag[u]) {
swap(maxv[u << 1][0], maxv[u << 1][1]);
swap(maxv[u << 1 | 1][0], maxv[u << 1 | 1][1]);
tag[u << 1] ^= 1, tag[u << 1 | 1] ^= 1, tag[u] = 0;
}
}
inline void dfs(int u, int fa) {
dfn[u] = ++tot;
siz[u] = 1;
rk[tot] = u;
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (e[i].w == 1)
len[v] = len[u] ^ 1;
else
len[v] = len[u];
dep[v] = dep[u] + 1;
dfs(v, u);
siz[u] += siz[v];
}
}
inline void build(int u, int l, int r) {
if (l == r) {
maxv[u][len[rk[l]]] = dep[rk[l]];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
inline int query(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) return maxv[u][0];
int mid = (l + r) >> 1, ret = 0;
pushdown(u);
if (x <= mid) ret = query(u << 1, l, mid, x, y);
if (y > mid) ret = max(ret, query(u << 1 | 1, mid + 1, r, x, y));
}
inline void update(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) {
tag[u] ^= 1;
swap(maxv[u][0], maxv[u][1]);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (x <= mid) update(u << 1, l, mid, x, y);
if (y > mid) update(u << 1 | 1, mid + 1, r, x, y);
pushup(u);
}
inline void change(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
update(1, 1, n, dfn[v], dfn[v] + siz[v] - 1);
}
} tree1, tree2;
inline void dfs2(int u, int f, int dis) {
if (dis > maxdis) {
maxpos = u, maxdis = dis;
}
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs2(v, u, dis + 1);
}
}
inline void init() {
dfs2(1, 0, 0);
tree1.rt = maxpos;
maxdis = 0;
dfs2(maxpos, 0, 0);
tree2.rt = maxpos;
tree1.dfs(tree1.rt, 0);
tree2.dfs(tree2.rt, 0);
tree1.build(1, 1, n);
tree2.build(1, 1, n);
}
inline void input() {
memset(p, -1, sizeof(p));
n = gi();
node x;
edg.push_back(x);
for (int i = 1; i <= n - 1; ++i) {
x.u = gi(), x.v = gi(), x.w = gi();
edg.push_back(x);
add(x.u, x.v, x.w);
add(x.v, x.u, x.w);
}
}
inline void solve() {
Q = gi();
while (Q--) {
int x = gi();
int u = edg[x].u, v = edg[x].v;
tree1.change(u, v);
tree2.change(u, v);
printf("%d\n", max(tree1.query(1, 1, n, 1, n), tree2.query(1, 1, n, 1, n)));
}
}
int main() {
input();
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, N = 5e5 + 10;
template <typename T>
void rd_(T &x) {
x = 0;
int f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
int n, m, a[N], b[N], d[N], root, par[N];
vector<pair<int, int> > g[N];
void dfs_(int u) {
d[u] = d[par[u]] + 1;
if (d[u] > d[root]) root = u;
for (int v, i = 0; i < (int)g[u].size(); i++) {
v = g[u][i].first;
if (par[u] == v) continue;
par[v] = u, dfs_(v);
}
}
struct Tree {
int par[N], dfn[N], tot, mx[N << 2][2], d[N], siz[N], ar[N], br[N];
bool rev[N << 2];
void pushup_(int o) {
mx[o][0] = max(mx[o << 1][0], mx[o << 1 | 1][0]);
mx[o][1] = max(mx[o << 1][1], mx[o << 1 | 1][1]);
}
void build_(int o, int l, int r) {
if (l == r) {
mx[o][ar[l]] = br[l];
mx[o][ar[l] ^ 1] = 0;
return;
}
int mid = (l + r) >> 1;
build_(o << 1, l, mid), build_(o << 1 | 1, mid + 1, r);
pushup_(o);
}
void dfs_(int u, int k = 0) {
d[u] = d[par[u]] + 1, dfn[u] = ++tot, siz[u] = 1, br[tot] = d[u] - 1,
ar[tot] = k;
for (int v, i = 0; i < (int)g[u].size(); i++) {
v = g[u][i].first;
if (v == par[u]) continue;
par[v] = u;
dfs_(v, k ^ g[u][i].second), siz[u] += siz[v];
}
}
void set_(int x) {
dfs_(x);
build_(1, 1, n);
}
void pushrev_(int o) {
swap(mx[o][0], mx[o][1]);
rev[o] ^= 1;
}
void pushdown_(int o) {
if (rev[o]) {
rev[o] = 0;
pushrev_(o << 1), pushrev_(o << 1 | 1);
}
}
void vrev_(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
pushrev_(o);
return;
}
int mid = (l + r) >> 1;
pushdown_(o);
if (x <= mid) vrev_(o << 1, l, mid, x, y);
if (mid < y) vrev_(o << 1 | 1, mid + 1, r, x, y);
pushup_(o);
}
void solve_(int x) {
if (d[a[x]] < d[b[x]]) swap(a[x], b[x]);
vrev_(1, 1, n, dfn[a[x]], dfn[a[x]] + siz[a[x]] - 1);
}
} A, B;
int main() {
rd_(n);
for (int x, i = 1; i < n; i++) {
rd_(a[i]), rd_(b[i]), rd_(x);
g[a[i]].push_back(pair<int, int>(b[i], x)),
g[b[i]].push_back(pair<int, int>(a[i], x));
}
dfs_(1);
A.set_(root);
par[root] = 0, dfs_(root);
B.set_(root);
rd_(m);
for (int x, i = 1; i <= m; i++) {
rd_(x);
A.solve_(x), B.solve_(x);
printf("%d\n", max(A.mx[1][0], B.mx[1][0]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, dep[500010], L[500010], R[500010], q[500010], l, r, hd[500010], cnt,
ans[500010], col[500010], c[500010], fa[500010], id[500010];
struct edg {
int to, next, val;
} e[1000010];
bool bo[500010];
struct node {
int l, r, val[2], laz;
} t[2000010];
void addedge(int x, int y, int z) {
e[++cnt] = (edg){y, hd[x], z}, hd[x] = cnt;
e[++cnt] = (edg){x, hd[y], z}, hd[y] = cnt;
}
void dfs(int x) {
L[x] = ++cnt, id[cnt] = x, dep[x] = dep[fa[x]] + 1;
for (int i = hd[x]; i; i = e[i].next)
if (e[i].to != fa[x])
col[e[i].to] = col[x] ^ e[i].val, fa[e[i].to] = x, dfs(e[i].to);
R[x] = cnt;
}
void build(int i, int l, int r) {
t[i].l = l, t[i].r = r, t[i].laz = 0, t[i].val[0] = t[i].val[1] = 0;
if (l == r) {
t[i].val[col[id[l]]] = dep[id[l]];
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid), build(i << 1 | 1, mid + 1, r);
t[i].val[0] = max(t[i << 1].val[0], t[i << 1 | 1].val[0]);
t[i].val[1] = max(t[i << 1].val[1], t[i << 1 | 1].val[1]);
}
void pushdown(int x) {
if (!t[x].laz) return;
t[x << 1].laz ^= 1, t[x << 1 | 1].laz ^= 1;
swap(t[x << 1].val[0], t[x << 1].val[1]);
swap(t[x << 1 | 1].val[0], t[x << 1 | 1].val[1]);
t[x].laz = 0;
}
void change(int i, int l, int r) {
if (t[i].l == l && t[i].r == r) {
swap(t[i].val[0], t[i].val[1]);
t[i].laz ^= 1;
return;
}
pushdown(i);
int mid = (t[i].l + t[i].r) >> 1;
if (r <= mid)
change(i << 1, l, r);
else if (l > mid)
change(i << 1 | 1, l, r);
else
change(i << 1, l, mid), change(i << 1 | 1, mid + 1, r);
t[i].val[0] = max(t[i << 1].val[0], t[i << 1 | 1].val[0]);
t[i].val[1] = max(t[i << 1].val[1], t[i << 1 | 1].val[1]);
}
void work(int rt) {
dep[0] = -1, col[rt] = 0, cnt = 0, fa[rt] = 0, dfs(rt);
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int x = e[c[i] * 2 - 1].to, y = e[c[i] * 2].to;
if (fa[x] == y) swap(x, y);
change(1, L[y], R[y]);
ans[i] = max(ans[i], t[1].val[0]);
}
}
int main() {
scanf("%d", &n), cnt = 0;
for (int i = 1; i < n; i++) {
int z;
scanf("%d%d%d", &l, &r, &z);
addedge(l, r, z);
}
q[l = r = 1] = 1;
memset(bo, 0, sizeof(bo));
bo[1] = 1;
while (l <= r) {
int x = q[l++];
for (int i = hd[x]; i; i = e[i].next)
if (!bo[e[i].to]) bo[e[i].to] = 1, q[++r] = e[i].to;
}
q[1] = q[r], l = r = 1;
memset(bo, 0, sizeof(bo));
bo[q[1]] = 1;
while (l <= r) {
int x = q[l++];
for (int i = hd[x]; i; i = e[i].next)
if (!bo[e[i].to]) bo[e[i].to] = 1, q[++r] = e[i].to;
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
work(q[1]), work(q[r]);
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long n;
vector<vector<pair<long long, long long>>> g;
long long far(long long v) {
vector<long long> d(n + 1, -1);
d[v] = 0;
queue<long long> q;
q.push(v);
while (!q.empty()) {
long long s = q.front();
q.pop();
for (auto x : g[s]) {
long long u = x.first;
if (d[u] == -1) {
d[u] = d[s] + 1;
q.push(u);
}
}
}
long long id = 1;
for (long long i = 2; i <= n; ++i) {
if (d[i] > d[id]) id = i;
}
return id;
}
void dfs(long long v, long long p, vector<long long>& tin,
vector<long long>& tout, vector<long long>& d, vector<long long>& h,
vector<long long>& e, long long& timer) {
tin[v] = timer++;
e.push_back(v);
for (auto x : g[v]) {
long long u = x.first, w = x.second;
if (u == p) continue;
d[u] = (d[v] + w) % 2;
h[u] = h[v] + 1;
dfs(u, v, tin, tout, d, h, e, timer);
}
tout[v] = timer;
}
struct segtree {
long long size;
vector<vector<long long>> tree;
vector<long long> modify;
segtree(long long n) {
size = 1;
while (size < n) size <<= 1;
tree.resize(2 * size - 1, vector<long long>(2));
modify.resize(2 * size - 1);
}
void get(long long v) {
tree[v][0] = max(tree[2 * v + 1][0], tree[2 * v + 2][0]);
tree[v][1] = max(tree[2 * v + 1][1], tree[2 * v + 2][1]);
}
void push(long long v) {
if (modify[v]) {
modify[2 * v + 1] ^= 1;
modify[2 * v + 2] ^= 1;
swap(tree[2 * v + 1][0], tree[2 * v + 1][1]);
swap(tree[2 * v + 2][0], tree[2 * v + 2][1]);
}
modify[v] = 0;
}
void upd(long long v, long long lx, long long rx, long long l, long long h,
long long d) {
if (lx + 1 == rx) {
tree[v][d] = h;
return;
}
long long m = (lx + rx) / 2;
if (l < m)
upd(2 * v + 1, lx, m, l, h, d);
else
upd(2 * v + 2, m, rx, l, h, d);
get(v);
}
void upd(long long l, long long h, long long d) { upd(0, 0, size, l, h, d); }
void rev(long long v, long long lx, long long rx, long long l, long long r) {
if (l <= lx and rx <= r) {
modify[v] ^= 1;
swap(tree[v][0], tree[v][1]);
return;
}
if (rx <= l or r <= lx) {
return;
}
push(v);
long long m = (lx + rx) / 2;
rev(2 * v + 1, lx, m, l, r);
rev(2 * v + 2, m, rx, l, r);
get(v);
}
void rev(long long l, long long r) { rev(0, 0, size, l, r); }
long long ans() { return tree[0][0]; }
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
g.resize(n + 1);
vector<vector<long long>> edges;
for (long long i = 0, u, v, w; i < n - 1; ++i) {
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
edges.push_back({u, v});
}
long long S = far(1), T = far(S);
vector<long long> tin1(n + 1), tin2(n + 1), h1(n + 1), h2(n + 1),
tout1(n + 1), tout2(n + 1), d1(n + 1), d2(n + 1), e1, e2;
long long timer = 0;
dfs(S, -1, tin1, tout1, d1, h1, e1, timer);
timer = 0;
dfs(T, -1, tin2, tout2, d2, h2, e2, timer);
segtree ST1(n), ST2(n);
for (long long i = 0; i < n; ++i) {
ST1.upd(i, h1[e1[i]], d1[e1[i]]);
ST2.upd(i, h2[e2[i]], d2[e2[i]]);
}
long long q;
cin >> q;
while (q-- > 0) {
long long id;
cin >> id;
id--;
long long u = edges[id][0], v = edges[id][1];
if (h1[u] > h1[v])
ST1.rev(tin1[u], tout1[u]);
else
ST1.rev(tin1[v], tout1[v]);
if (h2[u] > h2[v])
ST2.rev(tin2[u], tout2[u]);
else
ST2.rev(tin2[v], tout2[v]);
cout << max(ST1.ans(), ST2.ans()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(229);
inline void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
struct info {
long long m0 = 0, m1 = -1;
info() {}
info(long long a, long long b) : m0(a), m1(b) {}
void reverse() { swap(m0, m1); }
};
info operator+(const info &a, const info &b) {
return info(max(a.m0, b.m0), max(a.m1, b.m1));
}
struct segtree {
segtree *l = nullptr, *r = nullptr;
long long lb, rb;
info val;
long long need = 0;
void pull() {
if (lb + 1 < rb) {
val = l->val + r->val;
}
}
segtree() {}
segtree(long long L, long long R, const vector<long long> &vals,
const vector<long long> &d) {
lb = L, rb = R;
if (lb + 1 == rb) {
if (vals[lb] == 0) {
val = info(d[lb], -1);
} else {
val = info(-1, d[lb]);
}
} else {
long long m = (lb + rb) / 2;
l = new segtree(lb, m, vals, d);
r = new segtree(m, rb, vals, d);
pull();
}
}
void push() {
if (!need) return;
val.reverse();
if (lb + 1 < rb) {
l->need ^= 1;
r->need ^= 1;
}
need = 0;
}
void reverse(long long L, long long R) {
push();
if (L >= rb || lb >= R) return;
if (L <= lb && R >= rb) {
need ^= 1;
push();
return;
}
l->reverse(L, R);
r->reverse(L, R);
pull();
}
long long get() {
push();
return val.m0;
}
};
vector<vector<long long> > g;
vector<vector<pair<long long, long long> > > fullgraph;
vector<long long> d, d1;
vector<long long> eiler, eiler1;
vector<long long> tin, tin1, tout, tout1;
vector<long long> vals, vals1;
void dfs0(long long v, long long p = -1) {
for (auto u : g[v]) {
if (u == p) continue;
d[u] = d[v] + 1;
dfs0(u, v);
}
}
void dfs1(long long v, long long p = -1) {
tin[v] = (long long)eiler.size();
eiler.push_back(v);
for (auto u : g[v]) {
if (u == p) continue;
d[u] = d[v] + 1;
dfs1(u, v);
}
tout[v] = (long long)eiler.size();
}
void dfs11(long long v, long long p = -1) {
tin1[v] = (long long)eiler1.size();
eiler1.push_back(v);
for (auto u : g[v]) {
if (u == p) continue;
d1[u] = d1[v] + 1;
dfs11(u, v);
}
tout1[v] = (long long)eiler1.size();
}
pair<long long, long long> diameter(long long n) {
d.assign(n, 0);
eiler.clear();
dfs0(0);
long long root = 0;
for (long long i = 0; i < n; ++i) {
if (d[root] < d[i]) root = i;
}
tin.assign(n, 0);
tout.assign(n, 0);
d.assign(n, 0);
dfs1(root);
long long root1 = 0;
for (long long i = 0; i < n; ++i) {
if (d[root1] < d[i]) root1 = i;
}
eiler1.clear();
d1.assign(n, 0);
tin1.assign(n, 0);
tout1.assign(n, 0);
dfs11(root1);
return {root, root1};
}
void fulldfs(long long v, long long p = -1) {
for (auto u : fullgraph[v]) {
if (u.first == p) continue;
vals[u.first] = (vals[v] + u.second) % 2;
fulldfs(u.first, v);
}
}
void fulldfs1(long long v, long long p = -1) {
for (auto u : fullgraph[v]) {
if (u.first == p) continue;
vals1[u.first] = (vals1[v] + u.second) % 2;
fulldfs1(u.first, v);
}
}
void solve() {
long long n;
cin >> n;
g.assign(n, vector<long long>(0));
vector<pair<long long, long long> > e(n - 1);
fullgraph.assign(n, vector<pair<long long, long long> >(0));
for (long long i = 0; i < n - 1; ++i) {
long long a, b, c;
cin >> a >> b >> c;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
fullgraph[a].push_back({b, c});
fullgraph[b].push_back({a, c});
e[i] = {a, b};
}
vector<pair<long long, long long> > e1 = e;
pair<long long, long long> roots = diameter(n);
long long root = roots.first, root1 = roots.second;
vals.assign(n, 0);
vals1.assign(n, 0);
fulldfs(root);
fulldfs1(root1);
for (long long i = 0; i < n - 1; ++i) {
if (d[e[i].first] > d[e[i].second]) {
swap(e[i].first, e[i].second);
}
if (d1[e1[i].first] > d1[e1[i].second]) {
swap(e1[i].first, e1[i].second);
}
}
vector<long long> newvals(n, 0);
vector<long long> newdepths(n, 0);
for (long long i = 0; i < n; ++i) {
newvals[i] = vals[eiler[i]];
newdepths[i] = d[eiler[i]];
}
vector<long long> newvals1(n, 0);
vector<long long> newdepths1(n, 0);
for (long long i = 0; i < n; ++i) {
newvals1[i] = vals1[eiler1[i]];
newdepths1[i] = d1[eiler1[i]];
}
segtree *tree = new segtree(0, n, newvals, newdepths);
segtree *tree1 = new segtree(0, n, newvals1, newdepths1);
long long m;
cin >> m;
while (m--) {
long long index;
cin >> index;
index--;
long long vertex = e[index].second;
long long vertex1 = e1[index].second;
long long l = tin[vertex], r = tout[vertex];
long long l1 = tin1[vertex1], r1 = tout1[vertex1];
tree->reverse(l, r);
tree1->reverse(l1, r1);
cout << max(tree->get(), tree1->get()) << '\n';
}
}
signed main() {
fastio();
long long T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
const int MAXM = 4e6 + 10;
const long long MOD = 1e9 + 7;
const long long INF = 0x3f3f3f3f;
const unsigned long long BASE = 233;
const int base = 5;
mt19937_64 mt(time(0));
char rubbish[110];
bool GETDATA;
inline long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
inline void write(long long x, char con = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10, 0);
putchar(x % 10 + '0');
if (con) {
printf("%c", con);
}
}
long long N, M, K, Q;
pair<int, int> a[MAXN];
int con[MAXN];
vector<int> es[MAXN];
bool vis[MAXN];
struct SegmentTree {
int b[MAXN];
int depth[MAXN];
pair<int, int> idx[MAXN];
int ord[MAXN];
pair<int, int> seg[MAXN << 2];
int lz[MAXN << 2];
int cnt;
int root;
void dfs(int u, int fa, int floor) {
int v;
depth[u] = floor;
idx[u].first = ++cnt;
ord[cnt] = u;
for (int i : es[u]) {
v = a[i].first == u ? a[i].second : a[i].first;
if (v == fa) {
continue;
}
b[v] = con[i] ? (b[u] ^ 1) : b[u];
dfs(v, u, floor + 1);
}
idx[u].second = cnt;
}
void pushup(int o) {
seg[o].first = max(seg[(o << 1)].first, seg[(o << 1 | 1)].first);
seg[o].second = max(seg[(o << 1)].second, seg[(o << 1 | 1)].second);
}
void pushdown(int o) {
if (lz[o]) {
swap(seg[(o << 1)].first, seg[(o << 1)].second);
swap(seg[(o << 1 | 1)].first, seg[(o << 1 | 1)].second);
lz[(o << 1)] ^= 1;
lz[(o << 1 | 1)] ^= 1;
lz[o] ^= 1;
}
}
void build(int o, int l, int r) {
lz[o] = 0;
if (l == r) {
seg[o].first = b[ord[l]] ? 0 : depth[ord[l]];
seg[o].second = b[ord[l]] ? depth[ord[l]] : 0;
return;
}
int m = l + r >> 1;
build((o << 1), l, m);
build((o << 1 | 1), m + 1, r);
pushup(o);
}
void updata(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
lz[o] ^= 1;
swap(seg[o].first, seg[o].second);
return;
}
int m = l + r >> 1;
pushdown(o);
if (x <= m) {
updata((o << 1), l, m, x, y);
}
if (m < y) {
updata((o << 1 | 1), m + 1, r, x, y);
}
pushup(o);
}
void seg_init(int _root) {
cnt = 0;
root = _root;
b[root] = 0;
dfs(root, root, 0);
build(1, 1, cnt);
}
int query(int now) {
now = depth[a[now].first] > depth[a[now].second] ? a[now].first
: a[now].second;
updata(1, 1, N, idx[now].first, idx[now].second);
return seg[1].first;
}
} A, B;
int Find(int x) {
queue<pair<int, int> > q;
pair<int, int> now;
int u, v;
for (int i = 1; i <= N; i++) {
vis[i] = false;
}
while (!q.empty()) {
q.pop();
}
q.push(pair<int, int>(x, 0));
while (!q.empty()) {
now = q.front();
q.pop();
u = now.first;
vis[u] = true;
now.second++;
for (int i : es[u]) {
v = a[i].first == u ? a[i].second : a[i].first;
if (vis[v]) {
continue;
}
now.first = v;
q.push(now);
}
}
return u;
}
void init() {
for (int i = 1; i <= N; i++) {
es[i].clear();
}
}
void solve() {
long long ans = 0;
int now;
N = read();
init();
for (int i = 1; i < N; i++) {
a[i] = pair<int, int>{read(), read()};
con[i] = read();
es[a[i].first].push_back(i);
es[a[i].second].push_back(i);
}
now = Find(1);
A.seg_init(now);
now = Find(now);
B.seg_init(now);
M = read();
while (M--) {
now = read();
write(max(A.query(now), B.query(now)));
}
}
int main() {
int T;
T = 1;
for (int t = 1; t <= T; t++) {
GETDATA = false;
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 500005;
int N, Q;
int lnk[maxN];
int pre[maxN << 1], tgt[maxN << 1], cnt;
int val[maxN << 1];
int pos[maxN];
void add_E(int u, int v, int c) {
pre[++cnt] = lnk[u], tgt[cnt] = v, val[cnt] = c, lnk[u] = cnt;
}
int dep[maxN], wdep[maxN];
int Tin[maxN], Tout[maxN];
int dfn[maxN << 1], idx;
void dfs(int x, int f) {
dfn[++idx] = x;
Tin[x] = idx;
for (int e = lnk[x]; e; e = pre[e])
if (tgt[e] != f)
pos[(e + 1) >> 1] = tgt[e], dep[tgt[e]] = dep[x] + 1,
wdep[tgt[e]] = wdep[x] + val[e], dfs(tgt[e], x),
dfn[++idx] = x;
Tout[x] = idx;
}
int W[maxN << 3][2], M[maxN << 3], LM[maxN << 3][2], MR[maxN << 3][2],
LMR[maxN << 3][2], Lzy[maxN << 3];
void push_up(int x) {
M[x] = max(M[x << 1], M[x << 1 | 1]);
for (int k = 0; k < 2; k++) {
W[x][k] = max(W[x << 1][k], W[x << 1 | 1][k]);
LM[x][k] = max(LM[x << 1][k], LM[x << 1 | 1][k]);
MR[x][k] = max(MR[x << 1][k], MR[x << 1 | 1][k]);
LMR[x][k] = max(LMR[x << 1][k], LMR[x << 1 | 1][k]);
LM[x][k] = max(LM[x][k], W[x << 1][k] + M[x << 1 | 1]);
MR[x][k] = max(MR[x][k], M[x << 1] + W[x << 1 | 1][k]);
}
for (int k1 = 0; k1 < 2; k1++)
for (int k2 = 0; k2 < 2; k2++)
LMR[x][k1 ^ k2] =
max(LMR[x][k1 ^ k2], max(LM[x << 1][k1] + W[x << 1 | 1][k2],
W[x << 1][k1] + MR[x << 1 | 1][k2]));
}
void Rev(int x) {
swap(W[x][0], W[x][1]);
swap(LM[x][0], LM[x][1]);
swap(MR[x][0], MR[x][1]);
Lzy[x] ^= 1;
}
void push_down(int x) {
if (!Lzy[x]) return;
Rev(x << 1);
Rev(x << 1 | 1);
Lzy[x] = 0;
}
void Build(int x, int l, int r) {
if (l == r) {
int k = wdep[dfn[l]] & 1;
W[x][k] = dep[dfn[l]];
M[x] = -2 * dep[dfn[l]];
LM[x][k] = MR[x][k] = -dep[dfn[l]];
W[x][k ^ 1] = -0x3f3f3f3f;
LM[x][k ^ 1] = MR[x][k ^ 1] = -0x3f3f3f3f;
return;
}
int mid = (l + r) >> 1;
Build(x << 1, l, mid);
Build(x << 1 | 1, mid + 1, r);
push_up(x);
}
void Update(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
Rev(x);
return;
}
int mid = (l + r) >> 1;
push_down(x);
if (L <= mid) Update(x << 1, l, mid, L, R);
if (R > mid) Update(x << 1 | 1, mid + 1, r, L, R);
push_up(x);
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
add_E(u, v, c);
add_E(v, u, c);
}
dfs(1, 0);
Build(1, 1, idx);
scanf("%d", &Q);
while (Q--) {
int d;
scanf("%d", &d);
Update(1, 1, idx, Tin[pos[d]], Tout[pos[d]]);
printf("%d\n", LMR[1][0]);
}
}
|
#include <bits/stdc++.h>
#pragma optimize("SEX_ON_THE_BEACH")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
namespace someUsefull {
template <typename T1, typename T2>
inline void checkMin(T1& a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void checkMax(T1& a, T2 b) {
if (a < b) a = b;
}
const int _bitfunctions_size_ = 16;
const int _bitfunctions_mask_ = (1 << _bitfunctions_size_) - 1;
char* _bits_count_;
inline void _build_bits_count_() {
_bits_count_ = new char[1 << _bitfunctions_size_];
for (int i = 1; i < (1 << _bitfunctions_size_); ++i) {
_bits_count_[i] = _bits_count_[i >> 1];
if (i & 1) ++_bits_count_[i];
}
}
template <typename T1 = char, typename T2 = int>
inline T1 popcnt(T2 x) {
T1 ans = 0;
while (x) {
ans += _bits_count_[x & _bitfunctions_mask_];
x >>= _bitfunctions_size_;
}
return ans;
}
} // namespace someUsefull
namespace operators {
template <typename T1, typename T2>
std::istream& operator>>(std::istream& in, std::pair<T1, T2>& x) {
in >> x.first >> x.second;
return in;
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& out, std::pair<T1, T2> x) {
out << x.first << " " << x.second;
return out;
}
template <typename T1>
std::istream& operator>>(std::istream& in, std::vector<T1>& x) {
for (auto& i : x) in >> i;
return in;
}
template <typename T1>
std::ostream& operator<<(std::ostream& out, std::vector<T1>& x) {
for (auto& i : x) out << i << " ";
return out;
}
} // namespace operators
using namespace std;
using namespace operators;
using namespace someUsefull;
vector<vector<int>> gr;
vector<pair<int, int>> ed;
vector<int> d;
void dfs(int v, int _d = 0, int p = -1) {
d[v] = _d;
for (int to : gr[v]) {
if (to != p) dfs(to, _d + 1, v);
}
}
struct Tree {
const int _size = 1 << 19;
int n, t;
vector<pair<int, int>> tree;
vector<int> upd;
vector<int> d;
vector<int> pre;
vector<int> tin, tout, tos;
void dfs(int v, int _d = 0, int p = -1) {
d[v] = _d;
pre[v] = p;
tin[v] = tos.size();
tos.push_back(v);
for (int to : gr[v]) {
if (to != p) dfs(to, _d + 1, v);
}
tout[v] = tos.size();
}
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
return {max(a.first, b.first), max(a.second, b.second)};
}
Tree(int v) {
tree.resize(_size << 1, {0, 0});
upd.resize(_size << 1, 0);
n = gr.size();
t = 0;
d.resize(n);
tin.resize(n);
tout.resize(n);
pre.resize(n);
0;
;
dfs(v);
0;
;
for (int i = 0; i < n; ++i) tree[_size + i].first = d[tos[i]];
for (int i = _size - 1; i > 0; --i)
tree[i] = merge(tree[i << 1], tree[i << 1 | 1]);
}
void change(int v) {
upd[v] ^= 1;
swap(tree[v].first, tree[v].second);
}
void push(int v) {
if (!upd[v]) return;
change(v << 1);
change(v << 1 | 1);
upd[v] = 0;
}
void update(int v, int l, int r, int fl, int fr) {
if (r <= l || r <= fl || fr <= l) return;
if (fl <= l && r <= fr) {
change(v);
return;
}
push(v);
update(v << 1, l, (r + l) >> 1, fl, fr);
update(v << 1 | 1, (r + l) >> 1, r, fl, fr);
tree[v] = merge(tree[v << 1], tree[v << 1 | 1]);
}
int add(int a, int b) {
if (pre[a] != b) swap(a, b);
update(1, 0, _size, tin[a], tout[a]);
return tree[1].first;
}
};
void solve(int test) {
int n;
cin >> n;
gr.resize(n);
vector<int> type(n - 1);
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b >> type[i];
--a;
--b;
ed.push_back({a, b});
gr[a].push_back(b);
gr[b].push_back(a);
}
d.resize(n);
d.assign(n, -1);
dfs(0);
int v = 0;
for (int i = 0; i < n; ++i)
if (d[v] < d[i]) v = i;
dfs(v);
int L = v;
int R = 0;
for (int i = 0; i < n; ++i)
if (d[R] < d[i]) R = i;
0;
;
0;
;
Tree LT(L), RT(R);
0;
;
for (int i = 0; i < n - 1; ++i) {
if (type[i])
LT.add(ed[i].first, ed[i].second), RT.add(ed[i].first, ed[i].second);
}
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int x;
cin >> x;
--x;
int ans = 0;
checkMax(ans, LT.add(ed[x].first, ed[x].second));
checkMax(ans, RT.add(ed[x].first, ed[x].second));
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
_build_bits_count_();
cout << setprecision(12) << fixed;
int t = 1;
for (int i = 0; i < t; ++i) {
0;
;
solve(i + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
inline void err() { std::cerr << "\033[0m\n"; }
template <class T, class... U>
inline void err(const T &x, const U &...a) {
std::cerr << x << ' ';
err(a...);
}
template <class T>
inline void readInt(T &w) {
char c, p = 0;
while (!isdigit(c = getchar())) p = c == '-';
for (w = c & 15; isdigit(c = getchar());) w = w * 10 + (c & 15);
if (p) w = -w;
}
template <class T, class... U>
inline void readInt(T &w, U &...a) {
readInt(w), readInt(a...);
}
template <class T, class U>
inline bool smin(T &x, const U &y) {
return y < x ? x = y, 1 : 0;
}
template <class T, class U>
inline bool smax(T &x, const U &y) {
return x < y ? x = y, 1 : 0;
}
using Matrix = std::array<std::array<int, 4>, 4>;
Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix r;
r[0][0] = std::max({a[0][0] + b[0][0], a[0][1] + b[1][0], a[0][2] + b[2][0],
a[0][3] + b[3][0]});
r[0][1] = std::max({a[0][0] + b[0][1], a[0][1] + b[1][1], a[0][2] + b[2][1],
a[0][3] + b[3][1]});
r[0][2] = std::max({a[0][0] + b[0][2], a[0][1] + b[1][2], a[0][2] + b[2][2],
a[0][3] + b[3][2]});
r[0][3] = std::max({a[0][0] + b[0][3], a[0][1] + b[1][3], a[0][2] + b[2][3],
a[0][3] + b[3][3]});
r[1][0] = std::max({a[1][0] + b[0][0], a[1][1] + b[1][0], a[1][2] + b[2][0],
a[1][3] + b[3][0]});
r[1][1] = std::max({a[1][0] + b[0][1], a[1][1] + b[1][1], a[1][2] + b[2][1],
a[1][3] + b[3][1]});
r[1][2] = std::max({a[1][0] + b[0][2], a[1][1] + b[1][2], a[1][2] + b[2][2],
a[1][3] + b[3][2]});
r[1][3] = std::max({a[1][0] + b[0][3], a[1][1] + b[1][3], a[1][2] + b[2][3],
a[1][3] + b[3][3]});
r[2][0] = std::max({a[2][0] + b[0][0], a[2][1] + b[1][0], a[2][2] + b[2][0],
a[2][3] + b[3][0]});
r[2][1] = std::max({a[2][0] + b[0][1], a[2][1] + b[1][1], a[2][2] + b[2][1],
a[2][3] + b[3][1]});
r[2][2] = std::max({a[2][0] + b[0][2], a[2][1] + b[1][2], a[2][2] + b[2][2],
a[2][3] + b[3][2]});
r[2][3] = std::max({a[2][0] + b[0][3], a[2][1] + b[1][3], a[2][2] + b[2][3],
a[2][3] + b[3][3]});
r[3][0] = std::max({a[3][0] + b[0][0], a[3][1] + b[1][0], a[3][2] + b[2][0],
a[3][3] + b[3][0]});
r[3][1] = std::max({a[3][0] + b[0][1], a[3][1] + b[1][1], a[3][2] + b[2][1],
a[3][3] + b[3][1]});
r[3][2] = std::max({a[3][0] + b[0][2], a[3][1] + b[1][2], a[3][2] + b[2][2],
a[3][3] + b[3][2]});
r[3][3] = std::max({a[3][0] + b[0][3], a[3][1] + b[1][3], a[3][2] + b[2][3],
a[3][3] + b[3][3]});
return r;
}
constexpr int N(5e5 + 5), INF(1e9);
int n, m, val[N], fa[N], son[N], siz[N];
std::vector<int> g[N];
void dfs1(int x) {
siz[x] = 1;
for (int y : g[x]) {
if (y == fa[x]) continue;
fa[y] = x;
dfs1(y);
siz[x] += siz[y];
if (siz[y] > siz[son[x]]) son[x] = y;
}
}
struct Node {
Node *ls, *rs, *fa;
Matrix val, sum;
inline void pushup() {
sum = ls ? ls->sum * val : val;
if (rs) sum = sum * rs->sum;
}
} t[N];
std::multiset<int> vir[N][3];
void updateVal(int x) {
auto &v = t[x].val;
auto p0 = vir[x][0].rbegin(), p1 = vir[x][1].rbegin();
int k = val[son[x]], m0 = *p0, m1 = *p1;
v[0][k] = 1, v[0][!k] = v[0][2] = -INF, v[0][3] = m0;
v[1][!k] = 1, v[1][k] = v[1][2] = -INF, v[1][3] = m1;
v[2][k] = m0 + 1, v[2][!k] = m1 + 1, v[2][2] = 0;
v[2][3] = vir[x][0].size() > 1 ? std::max(m0 + *++p0, m1 + *++p1) : 0;
smax(v[2][3], *vir[x][2].rbegin());
v[3][0] = v[3][1] = v[3][2] = -INF, v[3][3] = 0;
}
int f[N][3];
void dfs2(int x) {
f[x][0] = f[x][2] = 0, f[x][1] = -INF;
vir[x][0].insert(0), vir[x][1].insert(-INF), vir[x][2].insert(0);
for (int y : g[x]) {
if (y == fa[x]) continue;
dfs2(y);
smax(f[x][2], f[y][2]);
smax(f[x][2], f[x][0] + f[y][val[y]] + 1);
smax(f[x][2], f[x][1] + f[y][!val[y]] + 1);
smax(f[x][0], f[y][val[y]] + 1);
smax(f[x][1], f[y][!val[y]] + 1);
if (y == son[x]) continue;
vir[x][0].insert(f[y][val[y]] + 1);
vir[x][1].insert(f[y][!val[y]] + 1);
vir[x][2].insert(f[y][2]);
}
updateVal(x);
}
int top[N], s[N], sum[N];
Node *build(int l, int r) {
if (l == r) return t[s[l]].pushup(), t + s[l];
int m = l, tot = sum[r] + sum[l - 1];
while (m < r && sum[m] << 1 < tot) m++;
Node *o = t + s[m];
if (l < m) o->ls = build(l, m - 1), o->ls->fa = o;
if (m < r) o->rs = build(m + 1, r), o->rs->fa = o;
o->pushup();
return o;
}
Node *root;
void dfs3(int x, int tp) {
top[x] = tp;
if (x == tp) {
int m = 0;
for (int i = x; i; i = son[i]) {
s[++m] = i;
sum[m] = sum[m - 1] + siz[i] - siz[son[i]];
}
if (x > 1)
build(1, m)->fa = t + fa[x];
else
root = build(1, m);
}
if (!son[x]) return;
dfs3(son[x], tp);
for (int y : g[x]) {
if (y == fa[x] || y == son[x]) continue;
dfs3(y, y);
}
}
inline void erase(std::multiset<int> &s, int x) {
if (x < 0)
assert(*s.begin() < 0), s.erase(s.begin());
else
s.erase(s.find(x));
}
int maxc;
void work(int x, int y) {
int c = 0;
assert(fa[y] == x);
Node *o = t + x;
int &v = val[y];
if (son[x] == y) {
v ^= 1;
} else {
Node *p = t + y;
while (p->fa != o) p = p->fa;
erase(vir[x][0], p->sum[v][3] + 1);
erase(vir[x][1], p->sum[!v][3] + 1);
v ^= 1;
vir[x][0].insert(p->sum[v][3] + 1);
vir[x][1].insert(p->sum[!v][3] + 1);
}
for (updateVal(x); o->fa; o = o->fa) {
if (o->fa->ls != o && o->fa->rs != o) {
x = o->fa - t, y = val[top[o - t]];
assert(x == fa[top[o - t]]);
erase(vir[x][0], o->sum[y][3] + 1);
erase(vir[x][1], o->sum[!y][3] + 1);
erase(vir[x][2], o->sum[2][3]);
o->pushup();
vir[x][0].insert(o->sum[y][3] + 1);
vir[x][1].insert(o->sum[!y][3] + 1);
vir[x][2].insert(o->sum[2][3]);
updateVal(x);
} else {
o->pushup();
}
c++;
}
o->pushup();
smax(maxc, c);
assert(c <= 50);
}
struct Edge {
int x, y, z;
} e[N];
int main() {
readInt(n);
double T = (double)clock() / CLOCKS_PER_SEC;
for (int i = 1; i < n; i++) {
auto &[x, y, z] = e[i];
readInt(x, y, z);
g[x].push_back(y), g[y].push_back(x);
}
dfs1(1);
for (int i = 1; i < n; i++) {
auto &[x, y, z] = e[i];
if (fa[y] != x) std::swap(x, y);
assert(fa[y] == x);
val[y] = z;
}
dfs2(1);
dfs3(1, 1);
readInt(m);
while (m--) {
int i;
readInt(i);
work(e[i].x, e[i].y);
printf("%d\n", root->sum[2][3]);
}
T = (double)clock() / CLOCKS_PER_SEC - T;
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
mt19937 mt(seed);
struct edge {
int to, w;
edge() {}
edge(int to, int w) : to(to), w(w) {}
};
const int MAXN = 500000;
int pp, cur, tmp, vv, ll, rr;
int used[MAXN], roots[2];
vector<vector<int> > d(MAXN, vector<int>(2)), cnt(MAXN, vector<int>(2)),
a(2 * MAXN, vector<int>(2));
vector<vector<vector<int> > > place(MAXN, vector<vector<int> >(2));
vector<vector<edge> > g(MAXN);
void dfs(int v, int x, short p) {
used[v] = 1;
if (p) {
a[pp][x] = v;
cnt[v][x] = cur;
place[v][x].push_back(pp);
pp++;
}
for (auto &e : g[v]) {
if (!used[e.to]) {
d[e.to][x] = d[v][x] + 1;
if (e.w == 1) cur ^= 1;
dfs(e.to, x, p);
if (e.w == 1) cur ^= 1;
}
}
if (p) {
a[pp][x] = v;
cnt[v][x] = cur;
place[v][x].push_back(pp);
pp++;
}
}
struct node {
short swp;
int ans[2];
node() {
swp = 0;
ans[0] = 0;
ans[1] = 0;
}
};
struct tree {
vector<node> t;
tree(short x, int n) {
t.resize(4 * n);
build(0, 0, n, x);
}
void pull() {
t[vv].ans[0] = max(t[vv + vv + 1].ans[0], t[vv + vv + 2].ans[0]);
t[vv].ans[1] = max(t[vv + vv + 1].ans[1], t[vv + vv + 2].ans[1]);
}
void push(int x) {
if (!t[vv].swp) return;
t[vv].swp = 0;
tmp = t[vv].ans[0];
t[vv].ans[0] = t[vv].ans[1];
t[vv].ans[1] = tmp;
if (x == 1) return;
t[vv + vv + 1].swp ^= 1;
t[vv + vv + 2].swp ^= 1;
}
void build(int bv, int bl, int br, short x) {
if (br - bl == 1) {
t[bv].ans[cnt[a[bl][x]][x]] = d[a[bl][x]][x];
return;
}
int m = (bl + br) >> 1;
build(bv + bv + 1, bl, m, x);
build(bv + bv + 2, m, br, x);
vv = bv;
pull();
}
void update(int vl, int vr) {
push(vr - vl);
if (rr <= vl || vr <= ll) return;
if (ll <= vl && vr <= rr) {
t[vv].swp = 1;
push(vr - vl);
return;
}
tmp = (vl + vr) >> 1;
vv = vv + vv + 1;
update(vl, tmp);
tmp = (vl + vr) >> 1;
vv++;
update(tmp, vr);
vv = vv / 2 - 1;
pull();
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, i, j;
cin >> n;
vector<pair<int, int> > e(n);
for (i = 1; i < n; i++) {
int v, u, w;
cin >> v >> u >> w;
g[v - 1].emplace_back(u - 1, w);
g[u - 1].emplace_back(v - 1, w);
e[i] = {v - 1, u - 1};
}
cin >> m;
for (i = 0; i < n; i++) used[i] = 0;
roots[0] = 0;
roots[1] = 0;
for (i = 0; i < 2; i++) {
d[roots[0]][0] = 0;
dfs(roots[0], 0, 0);
for (j = 0; j < n; j++) {
if (d[roots[i]][0] < d[j][0]) roots[i] = j;
used[j] = 0;
}
}
for (i = 0; i < 2; i++) {
pp = 0;
cur = 0;
d[roots[i]][i] = 0;
dfs(roots[i], i, 1);
for (j = 0; j < n; j++) used[j] = 0;
}
vector<tree> t = {tree(0, 2 * n), tree(1, 2 * n)};
for (i = 0; i < m; i++) {
int x, ans = 0;
cin >> x;
for (j = 0; j < 2; j++) {
int v = e[x].first;
if (d[e[x].first][j] < d[e[x].second][j]) v = e[x].second;
vv = 0;
ll = place[v][j][0];
rr = place[v][j][1] + 1;
t[j].update(0, 2 * n);
ans = max(ans, t[j].t[0].ans[0]);
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
node* tmp = v;
while (!tmp->is_root()) tmp = tmp->p;
swap(v->parent, tmp->parent);
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
virtual void update() {}
virtual void push() {}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
update();
}
};
template <typename pnode>
struct splay_tree_lct : splay_tree<pnode> {
using splay_tree<pnode>::ch;
bool rev;
splay_tree_lct() : splay_tree<pnode>() { rev = 0; }
virtual void update() override {}
virtual void push() override {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
virtual void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() override {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() override {}
static void push_back(splay_tree_vchs*& u, const pnode& key) {
if (!u) {
u = new splay_tree_vchs(key);
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = new splay_tree_vchs(key);
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
}
static void erase(splay_tree_vchs*& u, splay_tree_vchs* v) {
v->splay();
if (!v->ch[0]) {
u = v->ch[1];
} else if (!v->ch[1]) {
u = v->ch[0];
} else {
u = v->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = v->ch[1];
v->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
delete v;
}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
splay_tree_vchs<node*>*root, *parent;
node() : splay_tree_lct() {
root = parent = NULL;
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() override {
splay_tree::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void update_vsub(node* v, bool add) {
if (add) {
splay_tree_vchs<node*>::push_back(root, v);
v->parent = root;
} else {
splay_tree_vchs<node*>::erase(root, v->parent);
v->parent = NULL;
}
}
void push() override { splay_tree_lct::push(); }
void reverse() override {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int get_random() {
static uniform_int_distribution<int> dist(0, 1e9 + 6);
return dist(rng);
}
template <class T>
void make_unique(T& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int geti() {
int x;
cin >> x;
return x;
}
long long getll() {
long long x;
cin >> x;
return x;
}
double getd() {
double x;
cin >> x;
return x;
}
const int MAXN = 5e5 + 100;
void solve(int tt) {}
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct segment_tree {
int _l, _r;
vector<S> a;
vector<S> tree;
vector<F> lazy;
void push(int l, int r, int node) {
if (lazy[node] != id()) {
int mid = (l + r) / 2;
int rnode = node + (mid - l + 1) * 2;
tree[node + 1] = mapping(lazy[node], tree[node + 1]);
lazy[node + 1] = composition(lazy[node], lazy[node + 1]);
tree[rnode] = mapping(lazy[node], tree[rnode]);
lazy[rnode] = composition(lazy[node], lazy[rnode]);
lazy[node] = id();
}
}
void build(int l, int r, int node) {
if (l == r)
tree[node] = a[l];
else {
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
build(l, mid, node + 1);
build(mid + 1, r, rnode);
tree[node] = op(tree[node + 1], tree[rnode]);
}
}
void update(F v, int left, int right, int l, int r, int node) {
if (left > right) return;
if (right < l || r < left) return;
if (left <= l && r <= right) {
tree[node] = mapping(v, tree[node]);
lazy[node] = composition(v, lazy[node]);
} else {
push(l, r, node);
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
update(v, left, right, l, mid, node + 1);
update(v, left, right, mid + 1, r, rnode);
tree[node] = op(tree[node + 1], tree[rnode]);
}
}
S query(int left, int right, int l, int r, int node) {
if (left > right) return e();
if (right < l || r < left) return e();
if (left <= l && r <= right) return tree[node];
push(l, r, node);
int mid = l + (r - l) / 2;
int rnode = node + (mid - l + 1) * 2;
S r1 = query(left, right, l, mid, node + 1);
S r2 = query(left, right, mid + 1, r, rnode);
return op(r1, r2);
}
vector<S> get_tree() {
vector<S> res;
for (int i = _l; i <= _r; i++) {
res.push_back(query(i, i));
}
return res;
}
void init(int l, int r) {
_l = l;
_r = r;
a.assign(r + 1, e());
tree.assign(2 * r + 1, e());
lazy.assign(2 * r + 1, id());
}
S& operator[](int idx) { return a[idx]; }
void build() { build(_l, _r, 0); }
void update(F v, int left, int right) { update(v, left, right, _l, _r, 0); }
S query(int left, int right) { return query(left, right, _l, _r, 0); }
};
long long zero() { return 0; }
long long int_max() { return INT_MAX; }
long long int_min() { return INT_MIN; }
long long get_min(long long x, long long y) { return min(x, y); }
long long get_max(long long x, long long y) { return max(x, y); }
long long add(long long x, long long y) { return x + y; }
long long mul(long long x, long long y) { return x * y; }
pair<int, int> f1(pair<int, int> x, pair<int, int> y) {
return pair<int, int>({min(x.first, y.first), max(x.second, y.second)});
};
pair<int, int> f2() { return pair<int, int>({1e9, -1e9}); };
pair<int, int> f3(int x, pair<int, int> y) {
return pair<int, int>(
{min(y.second * x, y.first * x), max(y.second * x, y.first * x)});
};
int f4(int x, int y) { return x * y; };
int f5() { return 1; };
segment_tree<pair<int, int>, f1, f2, int, f3, f4, f5> segt;
unordered_map<int, int> graph[MAXN];
int in[MAXN], out[MAXN], level[MAXN], t = 1;
int cnt[MAXN];
int n;
void dfs(int i, int p, int c, int l) {
;
;
in[i] = t++;
cnt[in[i]] = c;
segt[in[i]] = (c % 2 ? pair<int, int>({-l, -l}) : pair<int, int>({l, l}));
level[i] = l;
for (auto q : graph[i]) {
int j = q.first, tp = q.second;
if (j == p) continue;
dfs(j, i, c + tp, l + 1);
}
out[i] = t;
}
pair<int, int> find_root() {
queue<int> q({1});
vector<int> vis(n + 1);
vis[1] = 1;
int res1 = 1;
while (q.size()) {
int len = q.size();
while (len--) {
auto f = q.front();
q.pop();
for (auto p : graph[f]) {
if (!vis[p.first]) {
q.push(p.first);
res1 = p.first;
vis[p.first] = 1;
}
}
}
}
int res2 = res1;
q.push(res1);
vis = vector<int>(n + 1);
vis[res1] = 1;
while (q.size()) {
int len = q.size();
while (len--) {
auto f = q.front();
q.pop();
for (auto p : graph[f]) {
if (!vis[p.first]) {
q.push(p.first);
res2 = p.first;
vis[p.first] = 1;
}
}
}
}
return {res1, res2};
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
int u, v, tp;
vector<int> us, vs;
for (auto i = (0); i < (n - 1); i++) {
cin >> u >> v >> tp;
graph[u][v] = tp;
graph[v][u] = tp;
us.push_back(u);
vs.push_back(v);
}
pair<int, int> roots = find_root();
segt.init(1, n);
t = 1;
dfs(roots.first, -1, 0, 0);
segt.build();
int m;
cin >> m;
vector<int> idxs;
for (auto i = (0); i < (m); i++) {
int idx;
cin >> idx;
idx--;
idxs.push_back(idx);
}
vector<int> res1(m), res2(m);
for (auto i = (0); i < (m); i++) {
int idx = idxs[i];
u = us[idx], v = vs[idx];
if (level[u] > level[v]) swap(u, v);
;
;
segt.update(-1, in[v], out[v] - 1);
res1[i] = segt.query(1, n).second;
}
segt.init(1, n);
t = 1;
dfs(roots.second, -1, 0, 0);
segt.build();
;
;
;
;
for (auto i = (0); i < (m); i++) {
int idx = idxs[i];
u = us[idx], v = vs[idx];
if (level[u] > level[v]) swap(u, v);
;
;
segt.update(-1, in[v], out[v] - 1);
res2[i] = segt.query(1, n).second;
}
for (auto i = (0); i < (m); i++) {
cout << max(res1[i], res2[i]) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
namespace fastio {
char rbuf[1 << 23], *p1 = rbuf, *p2 = rbuf, wbuf[1 << 23], *p3 = wbuf;
inline char getc() {
return p1 == p2 &&
(p2 = (p1 = rbuf) + fread(rbuf, 1, 1 << 23, stdin), p1 == p2)
? -1
: *p1++;
}
inline void putc(char x) { (*p3++ = x); }
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
T neg = 0;
while (!isdigit(c)) neg |= !(c ^ '-'), c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (neg) x = (~x) + 1;
}
template <typename T>
void recursive_print(T x) {
if (!x) return;
recursive_print(x / 10);
putc(x % 10 ^ 48);
}
template <typename T>
void print(T x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = ~x + 1;
recursive_print(x);
}
void print_final() { fwrite(wbuf, 1, p3 - wbuf, stdout); }
} // namespace fastio
const int MAXN = 5e5;
int n, qu, hd[MAXN + 5], to[MAXN * 2 + 5], val[MAXN * 2 + 5], nxt[MAXN * 2 + 5],
ec = 0;
void adde(int u, int v, int w) {
to[++ec] = v;
val[ec] = w;
nxt[ec] = hd[u];
hd[u] = ec;
}
namespace getdia {
int dep1[MAXN + 5], dep2[MAXN + 5], rt1 = 1, rt2 = 1;
void dfs1(int x, int f) {
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == f) continue;
dep1[y] = dep1[x] + 1;
dfs1(y, x);
}
}
void dfs2(int x, int f) {
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e];
if (y == f) continue;
dep2[y] = dep2[x] + 1;
dfs2(y, x);
}
}
void finddia() {
dfs1(1, 0);
for (int i = 1; i <= n; i++)
if (dep1[i] > dep1[rt1]) rt1 = i;
dfs2(rt1, 0);
for (int i = 1; i <= n; i++)
if (dep2[i] > dep2[rt2]) rt2 = i;
}
} // namespace getdia
struct solver {
int rt, dfn[MAXN + 5], edt[MAXN + 5], tim = 0, rid[MAXN + 5];
int par[MAXN + 5], dw[MAXN + 5], dep[MAXN + 5];
void dfs(int x, int f) {
dfn[x] = ++tim;
rid[tim] = x;
for (int e = hd[x]; e; e = nxt[e]) {
int y = to[e], z = val[e];
if (y == f) continue;
dw[e + 1 >> 1] = y;
par[y] = par[x] ^ z;
dep[y] = dep[x] + 1;
dfs(y, x);
}
edt[x] = tim;
}
struct node {
int l, r, mx[2], flp;
} s[MAXN * 4 + 5];
void pushup(int k) {
s[k].mx[0] = max(s[k << 1].mx[0], s[k << 1 | 1].mx[0]);
s[k].mx[1] = max(s[k << 1].mx[1], s[k << 1 | 1].mx[1]);
}
void build(int k, int l, int r) {
s[k].l = l;
s[k].r = r;
if (l == r) {
s[k].mx[par[rid[l]]] = dep[rid[l]];
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
pushup(k);
}
void pushdown(int k) {
if (s[k].flp) {
swap(s[k << 1].mx[0], s[k << 1].mx[1]);
s[k << 1].flp ^= 1;
swap(s[k << 1 | 1].mx[0], s[k << 1 | 1].mx[1]);
s[k << 1 | 1].flp ^= 1;
s[k].flp = 0;
}
}
void modify(int k, int l, int r) {
if (l <= s[k].l && s[k].r <= r) {
s[k].flp ^= 1;
swap(s[k].mx[0], s[k].mx[1]);
return;
}
pushdown(k);
int mid = s[k].l + s[k].r >> 1;
if (r <= mid)
modify(k << 1, l, r);
else if (l > mid)
modify(k << 1 | 1, l, r);
else
modify(k << 1, l, mid), modify(k << 1 | 1, mid + 1, r);
pushup(k);
}
int query() { return s[1].mx[0]; }
void init() {
dfs(rt, 0);
build(1, 1, n);
}
void toggle(int x) { modify(1, dfn[dw[x]], edt[dw[x]]); }
} t[2];
int main() {
scanf("%d", &n);
for (int i = 1, u, v, w; i < n; i++)
scanf("%d%d%d", &u, &v, &w), adde(u, v, w), adde(v, u, w);
getdia::finddia();
t[0].rt = getdia::rt1;
t[1].rt = getdia::rt2;
t[0].init();
t[1].init();
int qu;
scanf("%d", &qu);
while (qu--) {
int x;
scanf("%d", &x);
t[0].toggle(x);
t[1].toggle(x);
printf("%d\n", max(t[0].query(), t[1].query()));
}
return 0;
}
|
#include <bits/stdc++.h>
int gi() {
char cc = getchar();
int cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
using namespace std;
struct Edge {
int to;
int tp;
int index;
};
int timer = 0;
vector<vector<Edge> > gr;
vector<pair<int, int> > seg;
vector<int> tin;
vector<int> val;
vector<int> euler;
void dfs(int vertex, int last, int W) {
tin[vertex] = timer++;
val[vertex] = W;
euler.push_back(vertex);
for (auto ed : gr[vertex]) {
if (ed.to == last) continue;
int index = ed.index;
seg[index].first = timer;
dfs(ed.to, vertex, W ^ ed.tp);
seg[index].second = timer - 1;
}
}
int mx = -1;
int opt;
void dfs2(int vertex, int last, int d) {
if (d > mx) {
mx = d;
opt = vertex;
}
for (auto ed : gr[vertex]) {
int to = ed.to;
if (to == last) continue;
dfs2(to, vertex, d + 1);
}
}
pair<int, int> find_diameter() {
dfs2(0, -1, 0);
int kek = opt;
mx = -1;
dfs2(kek, -1, 0);
return make_pair(kek, opt);
}
int n;
vector<int> dist;
void dfs3(int vertex, int last, int d) {
dist[vertex] = d;
for (auto ed : gr[vertex]) {
int to = ed.to;
if (to == last) continue;
dfs3(to, vertex, d + 1);
}
}
struct Vertex {
int max[2];
bool need_push;
};
vector<Vertex> rmq;
void build(int i, int l, int r) {
if (r - l == 1) {
int W = euler[l];
rmq[i].need_push = false;
rmq[i].max[val[W]] = dist[W];
rmq[i].max[1 - val[W]] = -1;
return;
}
int mid = (l + r) / 2;
build(2 * i + 1, l, mid), build(2 * i + 2, mid, r);
rmq[i].need_push = false;
for (int j = 0; j < 2; ++j) {
rmq[i].max[j] = max(rmq[2 * i + 1].max[j], rmq[2 * i + 2].max[j]);
}
}
void push(int i, int l, int r) {
if (r - l <= 1) return;
if (!rmq[i].need_push) return;
rmq[i].need_push = false;
for (int j = 2 * i + 1; j <= 2 * i + 2; ++j) {
rmq[j].need_push ^= 1;
swap(rmq[j].max[0], rmq[j].max[1]);
}
}
void upd(int i, int l, int r, int l1, int r1) {
push(i, l, r);
if (l1 >= r1) return;
if (l == l1 && r == r1) {
swap(rmq[i].max[0], rmq[i].max[1]);
rmq[i].need_push = true;
return;
}
int mid = (l + r) / 2;
upd(2 * i + 1, l, mid, l1, min(r1, mid));
upd(2 * i + 2, mid, r, max(l1, mid), r1);
for (int j = 0; j < 2; ++j) {
rmq[i].max[j] = max(rmq[2 * i + 1].max[j], rmq[2 * i + 2].max[j]);
}
}
int get_val(int i, int l, int r, int index) {
push(i, l, r);
if (r - l == 1) {
if (rmq[i].max[0] == -1) return 1;
return 0;
}
int mid = (l + r) / 2;
if (index < mid) return get_val(2 * i + 1, l, mid, index);
return get_val(2 * i + 2, mid, r, index);
}
vector<int> solve(int vertex, vector<int> queries) {
vector<int> ans;
dist.assign(n, -1);
dfs3(vertex, -1, 0);
rmq.assign(4 * n, {});
build(0, 0, n);
for (auto first : queries) {
upd(0, 0, n, seg[first].first, seg[first].second + 1);
int T = get_val(0, 0, n, tin[vertex]);
ans.push_back(rmq[0].max[T]);
}
return ans;
}
signed main() {
cin.tie(0), cin >> n;
gr.assign(n, {});
for (register int i = (0); i <= (n - 2); ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
gr[u].push_back({v, w, i});
gr[v].push_back({u, w, i});
}
seg.assign(n - 1, make_pair(-1, -1));
tin.assign(n, -1), val.assign(n, -1);
dfs(0, -1, 0);
pair<int, int> p = find_diameter();
vector<int> queries;
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int first;
cin >> first, first--, queries.push_back(first);
}
auto a = solve(p.first, queries);
auto b = solve(p.second, queries);
for (int i = 0; i < q; ++i) cout << max(a[i], b[i]) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1e9, 1e9);
vector<vector<int>> g[500009];
int rt = 0, d1[500005], f1[500005], s1[500005], c1[500005], p1[500005],
d2[500005], f2[500005], s2[500005], p2[500005], c2[500005];
vector<int> v, w;
void dfs(vector<int>& v, int f[], int d[], int p[], int s[], int c[], int x,
int px, int cx, int fx) {
if (fx) {
f[x] = v.size();
v.push_back(x);
c[x] = cx;
}
d[x] = d[px] + 1;
if (d[x] > d[rt]) rt = x;
for (auto& i : g[x])
if (i[0] != px) {
p[i[2]] = i[0];
dfs(v, f, d, p, s, c, i[0], x, (cx + i[1]) % 2, fx);
}
if (fx) s[x] = v.size();
}
struct segtree {
int sz;
vector<int> a;
vector<pair<int, int>> t;
segtree(vector<int>& v, int d[], int c[]) {
sz = v.size();
a.assign(4 * sz, 0);
t.assign(4 * sz, {0, 0});
build(d, c, v, 0, 0, sz);
}
void push(int x, int lx, int rx) {
if (!a[x]) return;
a[x] = 0;
swap(t[x].first, t[x].second);
if (lx + 1 != rx) a[2 * x + 1] ^= 1, a[2 * x + 2] ^= 1;
}
void build(int d[], int c[], vector<int>& v, int x, int lx, int rx) {
if (lx + 1 == rx) {
if (!c[v[lx]])
t[x] = {d[v[lx]], 0};
else
t[x] = {0, d[v[lx]]};
return;
}
int mx = (lx + rx) / 2;
build(d, c, v, 2 * x + 1, lx, mx);
build(d, c, v, 2 * x + 2, mx, rx);
t[x].first = max(t[2 * x + 1].first, t[2 * x + 2].first);
t[x].second = max(t[2 * x + 1].second, t[2 * x + 2].second);
}
void modify(int l, int r, int x, int lx, int rx) {
if (l <= lx && rx <= r) {
a[x] ^= 1;
push(x, lx, rx);
return;
}
push(x, lx, rx);
if (rx <= l || r <= lx) return;
int mx = (lx + rx) / 2;
modify(l, r, 2 * x + 1, lx, mx);
modify(l, r, 2 * x + 2, mx, rx);
t[x].first = max(t[2 * x + 1].first, t[2 * x + 2].first);
t[x].second = max(t[2 * x + 1].second, t[2 * x + 2].second);
}
int query(int l, int r, int x, int lx, int rx) {
push(x, lx, rx);
if (l <= lx && rx <= r) return t[x].first;
if (r <= lx || rx <= l) return 0;
int mx = (lx + rx) / 2;
return max(query(l, r, 2 * x + 1, lx, mx), query(l, r, 2 * x + 2, mx, rx));
}
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, y, q;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y >> q;
--x, --y;
g[x].push_back({y, q, i});
g[y].push_back({x, q, i});
}
d1[0] = -1;
dfs(v, f1, d1, p1, s1, c1, 0, 0, 0, 0);
d1[rt] = -1;
dfs(v, f1, d1, p1, s1, c1, rt, rt, 0, 1);
d2[rt] = -1;
dfs(w, f2, d2, p2, s2, c2, rt, rt, 0, 1);
segtree st1(v, d1, c1), st2(w, d2, c2);
cin >> q;
while (q--) {
cin >> x;
--x;
st1.modify(f1[p1[x]], s1[p1[x]], 0, 0, st1.sz);
st2.modify(f2[p2[x]], s2[p2[x]], 0, 0, st2.sz);
cout << max(st1.query(0, st1.sz, 0, 0, st1.sz),
st2.query(0, st2.sz, 0, 0, st2.sz))
<< '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<pair<int, int>> graph[500005];
bool typ[500005];
int dist[500005];
void dfs(int n, int p) {
for (auto e : graph[n]) {
if (e.first != p) {
dist[e.first] = dist[n] + 1;
dfs(e.first, n);
}
}
}
struct EulerTourSegTree {
struct Node {
int l, r, lzy;
int mx[2];
};
vector<Node> seg;
vector<int> lft;
vector<int> rht;
vector<int> et;
vector<int> dep;
int t, rt;
void dfs(int n, int p) {
lft[p] = ++t;
et[t] = n;
for (auto e : graph[n]) {
if (e.second == p) {
continue;
}
dep[e.first] = dep[n] + 1;
dfs(e.first, e.second);
}
rht[p] = t;
}
void build(int l, int r, int idx) {
seg[idx].l = l;
seg[idx].r = r;
if (l == r) {
seg[idx].mx[0] = dep[et[l]];
return;
}
int mid = l + r >> 1;
build(l, mid, 2 * idx);
build(mid + 1, r, 2 * idx + 1);
seg[idx].mx[0] = max(seg[2 * idx].mx[0], seg[2 * idx + 1].mx[0]);
}
void upd(int l, int r, int idx) {
if (seg[idx].l == l && seg[idx].r == r) {
seg[idx].lzy ^= 1;
swap(seg[idx].mx[0], seg[idx].mx[1]);
return;
}
if (seg[idx].lzy) {
for (int i = 2 * idx; i <= 2 * idx + 1; i++) {
seg[i].lzy ^= 1;
swap(seg[i].mx[0], seg[i].mx[1]);
}
seg[idx].lzy = 0;
}
int mid = seg[idx].l + seg[idx].r >> 1;
if (r <= mid) {
upd(l, r, 2 * idx);
} else if (l > mid) {
upd(l, r, 2 * idx + 1);
} else {
upd(l, mid, 2 * idx);
upd(mid + 1, r, 2 * idx + 1);
}
seg[idx].mx[0] = max(seg[2 * idx].mx[0], seg[2 * idx + 1].mx[0]);
seg[idx].mx[1] = max(seg[2 * idx].mx[1], seg[2 * idx + 1].mx[1]);
}
void updhelper(int ed) { upd(lft[ed], rht[ed], 1); }
EulerTourSegTree(int R) {
rt = R;
seg.resize(4 * N + 5);
lft.resize(N + 5);
rht.resize(N + 5);
dep.resize(N + 5);
et.resize(N + 5);
t = 0;
dfs(R, 0);
build(1, N, 1);
}
EulerTourSegTree() {}
};
EulerTourSegTree etseg[2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 1; i < N; i++) {
int a, b, t;
cin >> a >> b >> t;
typ[i] = t;
graph[a].emplace_back(b, i);
graph[b].emplace_back(a, i);
}
dfs(1, 0);
int d1 = max_element(dist, dist + 1 + N) - dist;
etseg[0] = EulerTourSegTree(d1);
int d2 = max_element(etseg[0].dep.begin(), etseg[0].dep.end()) -
etseg[0].dep.begin();
etseg[1] = EulerTourSegTree(d2);
for (int i = 1; i < N; i++) {
if (typ[i]) {
etseg[0].updhelper(i);
etseg[1].updhelper(i);
}
}
int Q;
cin >> Q;
while (Q--) {
int ed;
cin >> ed;
etseg[0].updhelper(ed);
etseg[1].updhelper(ed);
cout << max(etseg[0].seg[1].mx[0], etseg[1].seg[1].mx[0]) << "\n";
}
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
const int T = 1 << 20;
const int N = 5e5 + 500;
int n, q, a, b, c;
pair<int, int> e[N];
vector<pair<int, int>> G[N];
pair<int, int> farest(int v = 0, int p = -1) {
pair<int, int> mx = {0, v};
for (auto [u, w] : G[v])
if (u != p) {
auto cur = farest(u, v);
cur.first++;
mx = max(mx, cur);
}
return mx;
}
struct tree {
struct node {
int x, y, flag;
} s[T + T];
node combine(node a, node b) { return {max(a.x, b.x), max(a.y, b.y)}; }
void change(int v) {
s[v].flag ^= 1;
swap(s[v].x, s[v].y);
}
void push(int v) {
if (!s[v].flag) return;
for (auto u : {2 * v, 2 * v + 1}) change(u);
s[v].flag = 0;
}
void modify(int x, int y, int v = 1, int l = 0, int r = n - 1) {
if (y < l || r < x) return;
if (x <= l && r <= y) {
change(v);
return;
}
push(v);
int m = l + r >> 1;
modify(x, y, 2 * v, l, m);
modify(x, y, 2 * v + 1, m + 1, r);
s[v] = combine(s[2 * v], s[2 * v + 1]);
}
int par[N], dis[N], time = -1, in[N], out[N], ord[N];
void dfs(int v, int p = -1) {
in[v] = ++time;
ord[time] = v;
for (auto [u, w] : G[v]) {
if (u != p) {
dis[u] = dis[v] + 1;
par[u] = par[v] ^ w;
dfs(u, v);
}
}
out[v] = time;
}
void build(int v = 1, int l = 0, int r = n - 1) {
if (l == r) {
int u = ord[l];
if (par[u] % 2 == 0)
s[v].x = dis[u];
else
s[v].y = dis[u];
return;
}
int m = l + r >> 1;
build(2 * v, l, m);
build(2 * v + 1, m + 1, r);
s[v] = combine(s[2 * v], s[2 * v + 1]);
}
void flip(int u, int v) {
if (dis[u] > dis[v]) swap(u, v);
modify(in[v], out[v]);
}
} D[2];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d%d", &a, &b, &c);
a--;
b--;
e[i] = {a, b};
G[a].push_back({b, c});
G[b].push_back({a, c});
}
int x = farest().second;
int y = farest(x).second;
D[0].dfs(x);
D[1].dfs(y);
D[0].build();
D[1].build();
scanf("%d", &q);
while (q--) {
scanf("%d", &a);
for (int i = 0; i <= 1; ++i) D[i].flip(e[a].first, e[a].second);
printf("%d\n", max(D[0].s[1].x, D[1].s[1].x));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using cd = complex<double>;
using ul = unsigned long;
void f_io() {
ios_base ::sync_with_stdio(false);
cin.tie(nullptr);
}
int cc = 0, hi[(ll)(5e5 + 7)][2], bin[(ll)(5e5 + 7) * 2][2];
bool la[8 * (ll)(5e5 + 7)][2];
pair<int, int> ar[(ll)(5e5 + 7)][2], seg[8 * (ll)(5e5 + 7)][2];
vector<pair<int, bool>> gr[(ll)(5e5 + 7)];
vector<int> ve[2];
vector<pair<int, pair<int, int>>> vp;
bool ch = 0;
void dfs(int node, int par, bool fl) {
hi[node][ch] = hi[par][ch] + 1;
ve[ch].push_back(node);
ar[node][ch].first = ve[ch].size();
bin[ve[ch].size()][ch] = fl;
for (pair<int, int> x : gr[node]) {
if (x.first != par) {
dfs(x.first, node, fl ^ x.second);
}
}
ve[ch].push_back(node);
ar[node][ch].second = ve[ch].size();
bin[ve[ch].size()][ch] = fl;
}
pair<int, int> dfs(int node, int par) {
pair<int, int> m1, m2;
for (pair<int, int> x : gr[node]) {
if (x.first != par) {
pair<int, int> p = dfs(x.first, node);
if (p > m1) {
m2 = m1;
m1 = p;
} else if (p > m2) {
m2 = p;
}
}
}
if (m1.first == 0) {
return make_pair(1, node);
} else if (m2.first) {
vp.push_back(
make_pair(m1.first + m2.first, make_pair(m1.second, m2.second)));
}
vp.push_back(make_pair(m1.first, make_pair(node, m1.second)));
return make_pair(m1.first + 1, m1.second);
}
void laz(int ind, int l, int r, bool fl) {
if (la[ind][fl]) {
swap(seg[ind][fl].first, seg[ind][fl].second);
if (l < r) {
la[ind << 1][fl] ^= 1;
la[ind << 1 | 1][fl] ^= 1;
}
la[ind][fl] = 0;
}
}
void build(int ind, int l, int r) {
if (l == r) {
seg[ind][ch].first = (bin[l][ch] == 0) * hi[ve[ch][l - 1]][ch];
seg[ind][ch].second = (bin[l][ch] == 1) * hi[ve[ch][l - 1]][ch];
return;
}
int x = ind << 1, y = ind << 1 | 1, m = (l + r) / 2;
build(x, l, m), build(y, m + 1, r);
seg[ind][ch].first = max(seg[x][ch].first, seg[y][ch].first);
seg[ind][ch].second = max(seg[x][ch].second, seg[y][ch].second);
}
void rup(int ind, int l, int r, int st, int en, bool fl) {
laz(ind, l, r, fl);
if (r < st || en < l) {
return;
}
if (l >= st && r <= en) {
la[ind][fl] ^= 1;
laz(ind, l, r, fl);
return;
}
int x = ind << 1, y = ind << 1 | 1, m = (l + r) / 2;
rup(x, l, m, st, en, fl);
rup(y, m + 1, r, st, en, fl);
seg[ind][fl].first = max(seg[x][fl].first, seg[y][fl].first);
seg[ind][fl].second = max(seg[x][fl].second, seg[y][fl].second);
}
int main() {
f_io();
int n;
cin >> n;
vector<pair<int, int>> ed;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
ed.push_back(make_pair(u, v));
gr[u].push_back(make_pair(v, w));
gr[v].push_back(make_pair(u, w));
}
dfs(1, 0);
sort(vp.begin(), vp.end());
ch = 0;
dfs(vp.back().second.first, 0, 0);
for (int i = 0; i < ve[0].size(); i++) {
}
int nn = ve[0].size();
build(1, 1, nn);
ch = 1;
dfs(vp.back().second.second, 0, 0);
build(1, 1, nn);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
x--;
int n1 =
hi[ed[x].first][0] < hi[ed[x].second][0] ? ed[x].second : ed[x].first;
int n2 =
hi[ed[x].first][1] < hi[ed[x].second][1] ? ed[x].second : ed[x].first;
rup(1, 1, nn, ar[n1][0].first, ar[n1][0].second, 0);
rup(1, 1, nn, ar[n2][1].first, ar[n2][1].second, 1);
laz(1, 1, nn, 0);
laz(1, 1, nn, 1);
cout << max(seg[1][0].first, seg[1][1].first) - 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5;
vector<pair<long long, long long>> g[maxn];
long long v1 = 0;
long long v2 = 0;
vector<pair<pair<long long, long long>, long long>> t1(maxn * 4);
vector<pair<pair<long long, long long>, long long>> t2(maxn * 4);
vector<long long> pp1;
vector<pair<pair<long long, long long>, long long>> op1(maxn);
vector<long long> pp2;
vector<pair<pair<long long, long long>, long long>> op2(maxn);
long long n;
long long dist[maxn];
void push(vector<pair<pair<long long, long long>, long long>> &t, long long v) {
if (t[v].second == 1) {
t[v].second = 0;
t[v * 2].second ^= 1;
swap(t[v * 2].first.first, t[v * 2].first.second);
t[v * 2 + 1].second ^= 1;
swap(t[v * 2 + 1].first.first, t[v * 2 + 1].first.second);
}
}
void upd(vector<pair<pair<long long, long long>, long long>> &t, long long v,
long long tl, long long tr, long long pos, long long dist,
long long T) {
if (tl == tr) {
if (T == 0) {
t[v].first.first = dist;
t[v].first.second = 0;
} else {
t[v].first.first = 0;
t[v].first.second = dist;
}
return;
}
long long tm = (tl + tr) / 2;
if (pos <= tm) {
upd(t, v * 2, tl, tm, pos, dist, T);
} else {
upd(t, v * 2 + 1, tm + 1, tr, pos, dist, T);
}
t[v].first.first = max(t[v * 2].first.first, t[v * 2 + 1].first.first);
t[v].first.second = max(t[v * 2].first.second, t[v * 2 + 1].first.second);
}
void update(vector<pair<pair<long long, long long>, long long>> &t, long long v,
long long tl, long long tr, long long l, long long r) {
if (tl > r || tr < l) return;
if (l <= tl && tr <= r) {
swap(t[v].first.first, t[v].first.second);
t[v].second ^= 1;
return;
}
push(t, v);
long long tm = (tl + tr) / 2;
update(t, v * 2, tl, tm, l, r);
update(t, v * 2 + 1, tm + 1, tr, l, r);
t[v].first.first = max(t[v * 2].first.first, t[v * 2 + 1].first.first);
t[v].first.second = max(t[v * 2].first.second, t[v * 2 + 1].first.second);
}
long long get(vector<pair<pair<long long, long long>, long long>> &t,
long long v, long long tl, long long tr, long long l,
long long r) {
if (tl > r || tr < l) return 0;
if (l <= tl && tr <= r) {
if (t[v].second == 1) {
return t[v].first.second;
} else
return t[v].first.first;
}
push(t, v);
long long tm = (tl + tr) / 2;
return max(get(t, v * 2, tl, tm, l, r), get(t, v * 2 + 1, tm + 1, tr, l, r));
}
void dfs(vector<pair<pair<long long, long long>, long long>> &t,
vector<long long> &pp,
vector<pair<pair<long long, long long>, long long>> &op, long long v,
long long p, long long sum, long long H) {
upd(t, 1, 0, n - 1, pp.size(), H, sum % 2);
op[v].first.first = pp.size();
op[v].second = H;
pp.push_back(v);
for (long long i = 0; i < g[v].size(); ++i) {
long long to = g[v][i].first;
if (to == p) continue;
dfs(t, pp, op, to, v, sum + g[v][i].second, H + 1);
}
op[v].first.second = pp.size() - 1;
}
void jupaS(long long v, long long p) {
for (long long i = 0; i < g[v].size(); ++i) {
long long to = g[v][i].first;
if (to == p) continue;
dist[to] = dist[v] + 1;
jupaS(to, v);
}
}
signed main() {
cin.tie();
cout.tie();
ios_base::sync_with_stdio(false);
cin >> n;
vector<pair<long long, long long>> y;
for (long long i = 0; i < n - 1; ++i) {
long long a, b, t;
cin >> a >> b >> t;
a--;
b--;
y.push_back({a, b});
g[a].push_back({b, t});
g[b].push_back({a, t});
}
jupaS(0, -1);
long long mx = 0;
for (long long k = 0; k < n; ++k) {
if (dist[mx] < dist[k]) mx = k;
}
v1 = mx;
dist[v1] = 0;
jupaS(v1, -1);
mx = 0;
for (long long k = 0; k < n; ++k) {
if (dist[mx] < dist[k]) mx = k;
}
v2 = mx;
dfs(t1, pp1, op1, v1, -1, 0, 0);
dfs(t2, pp2, op2, v2, -1, 0, 0);
long long q;
cin >> q;
for (long long j = 0; j < q; ++j) {
long long id;
cin >> id;
id--;
long long a = y[id].first;
long long b = y[id].second;
if (op1[a].second > op1[b].second) swap(a, b);
update(t1, 1, 0, n - 1, op1[b].first.first, op1[b].first.second);
if (op2[a].second > op2[b].second) swap(a, b);
update(t2, 1, 0, n - 1, op2[b].first.first, op2[b].first.second);
long long mx = get(t1, 1, 0, n - 1, 0, n - 1);
long long mx1 = get(t2, 1, 0, n - 1, 0, n - 1);
cout << max(mx, mx1) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > g;
vector<int> h, hmax;
int w = 0;
void dfs(int v, int p = -1) {
if (h[v] > h[w]) {
w = v;
}
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
if (to != p) {
h[to] = h[v] + 1;
dfs(to, v);
}
}
}
vector<int> tree0, tree1, upd;
vector<pair<int, int> > mass;
vector<int> tin, tout;
bool pred(int a, int b) { return tin[a] <= tin[b] && tout[a] >= tout[b]; }
int w1 = 0;
void dfs1(int v, int m = 0, int p = -1) {
mass.push_back({m, h[v]});
if (h[v] > h[w1]) {
w1 = v;
}
tin[v] = mass.size() - 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
if (to != p) {
h[to] = h[v] + 1;
dfs1(to, m ^ g[v][i].second, v);
}
}
tout[v] = mass.size() - 1;
}
void build(int v, int l, int r) {
upd[v] = 0;
if (l == r) {
tree0[v] = tree1[v] = 0;
if (mass[l].first == 0) {
tree0[v] = mass[l].second;
} else {
tree1[v] = mass[l].second;
}
return;
}
build(v * 2, l, (r + l) / 2);
build(v * 2 + 1, (r + l) / 2 + 1, r);
tree0[v] = max(tree0[v * 2], tree0[v * 2 + 1]);
tree1[v] = max(tree1[v * 2], tree1[v * 2 + 1]);
}
void push(int v, int l, int r) {
if (upd[v]) {
upd[v * 2] ^= 1;
upd[v * 2 + 1] ^= 1;
upd[v] = 0;
swap(tree0[v * 2], tree1[v * 2]);
swap(tree0[v * 2 + 1], tree1[v * 2 + 1]);
}
}
void update(int v, int l, int r, int al, int ar) {
if (l >= al && r <= ar) {
upd[v] ^= 1;
swap(tree0[v], tree1[v]);
} else if (l <= ar && r >= al) {
push(v, l, r);
update(v * 2, l, (r + l) / 2, al, ar);
update(v * 2 + 1, (r + l) / 2 + 1, r, al, ar);
tree0[v] = max(tree0[v * 2], tree0[v * 2 + 1]);
tree1[v] = max(tree1[v * 2], tree1[v * 2 + 1]);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
h.resize(n);
tin.resize(n);
tout.resize(n);
g.resize(n);
tree0.resize(4 * n);
tree1.resize(4 * n);
upd.resize(4 * n);
vector<pair<int, int> > mass1(n);
for (int i = 0; i < n - 1; i++) {
int a, b, t;
cin >> a >> b >> t;
a--;
b--;
mass1[i] = {a, b};
g[a].push_back({b, t});
g[b].push_back({a, t});
}
dfs(0);
h[w] = 0;
dfs1(w);
build(1, 0, n - 1);
int m;
cin >> m;
vector<int> ans(m);
vector<int> quer(m);
for (int i = 0; i < m; i++) {
int a;
cin >> a;
a--;
quer[i] = a;
int u = mass1[a].first;
int v = mass1[a].second;
if (pred(v, u)) {
swap(u, v);
}
update(1, 0, n - 1, tin[v], tout[v]);
ans[i] = tree0[1];
}
while (mass.size() > 0) {
mass.pop_back();
}
h[w1] = 0;
dfs1(w1);
build(1, 0, n - 1);
for (int i = 0; i < m; i++) {
int a = quer[i];
int u = mass1[a].first;
int v = mass1[a].second;
if (pred(v, u)) {
swap(u, v);
}
update(1, 0, n - 1, tin[v], tout[v]);
ans[i] = max(ans[i], tree0[1]);
cout << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v[500007];
pair<int, int> edge_list[500007];
int diam[2];
class Tree {
int root;
vector<int> ord;
int st[500007], en[500007];
int rev[500007];
int depth[500007], parity[500007];
void dfs(int vertex, int prv) {
ord.push_back(vertex);
st[vertex] = ord.size();
rev[st[vertex]] = vertex;
int sz = v[vertex].size();
for (int i = 0; i < sz; ++i) {
int to, cost;
to = v[vertex][i].first;
cost = v[vertex][i].second;
if (to == prv) {
continue;
}
depth[to] = depth[vertex] + 1;
parity[to] = parity[vertex] ^ cost;
dfs(to, vertex);
}
en[vertex] = ord.size();
}
int tr[4 * 500007][2];
int lazy[4 * 500007];
void unite(int where) {
for (int i = 0; i < 2; ++i) {
tr[where][i] = max(tr[2 * where][i], tr[2 * where + 1][i]);
}
}
void init_segtree(int where, int IL, int IR) {
lazy[where] = 0;
if (IL == IR) {
int x = rev[IL];
tr[where][parity[x]] = depth[x];
tr[where][parity[x] ^ 1] = 0;
return;
}
int mid = (IL + IR) / 2;
init_segtree(2 * where, IL, mid);
init_segtree(2 * where + 1, mid + 1, IR);
unite(where);
}
void push_lazy(int where, int IL, int IR) {
if (lazy[where] == 0) {
return;
}
swap(tr[where][0], tr[where][1]);
if (IL != IR) {
lazy[2 * where] ^= 1;
lazy[2 * where + 1] ^= 1;
}
lazy[where] = 0;
}
void update(int where, int IL, int IR, int CURL, int CURR) {
push_lazy(where, IL, IR);
if (IL > IR || CURL > CURR) {
return;
}
if (CURR < IL || IR < CURL) {
return;
}
if (CURL <= IL && IR <= CURR) {
lazy[where] ^= 1;
push_lazy(where, IL, IR);
return;
}
int mid = (IL + IR) / 2;
update(2 * where, IL, mid, CURL, CURR);
update(2 * where + 1, mid + 1, IR, CURL, CURR);
unite(where);
}
public:
void init(int _root) {
root = _root;
depth[root] = parity[root] = 0;
ord.clear();
dfs(root, -1);
init_segtree(1, 1, n);
}
void handle(int id) {
int x = edge_list[id].first;
int y = edge_list[id].second;
if (st[x] < st[y]) {
swap(x, y);
}
update(1, 1, n, st[x], en[x]);
}
int query() { return tr[1][0]; }
};
Tree w[2];
int len[500007];
int bfs(int ori) {
for (int i = 1; i <= n; ++i) {
len[i] = 500007;
}
len[ori] = 0;
queue<int> q;
q.push(ori);
while (q.empty() == false) {
int x = q.front();
q.pop();
int sz = v[x].size();
for (int i = 0; i < sz; ++i) {
int to = v[x][i].first;
if (len[to] == 500007) {
len[to] = len[x] + 1;
q.push(to);
}
}
}
int mx, id;
mx = id = 0;
for (int i = 1; i <= n; ++i) {
if (mx < len[i]) {
mx = len[i];
id = i;
}
}
return id;
}
void input() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
v[x].push_back({y, z});
v[y].push_back({x, z});
edge_list[i] = {x, y};
}
diam[0] = bfs(1);
diam[1] = bfs(diam[0]);
}
void solve() {
for (int i = 0; i < 2; ++i) {
w[i].init(diam[i]);
}
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
w[0].handle(x);
w[1].handle(x);
printf("%d\n", max(w[0].query(), w[1].query()));
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 Rand(seed);
uniform_int_distribution<long long> range(0, 1ll << 32);
inline void ucin() {
ios::sync_with_stdio(0);
cin.tie(0);
}
template <class T>
inline void chkmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
if (x > y) x = y;
}
const int N = 5e5 + 10;
const int INF = 2e9 + 10;
struct Edge {
int v, w;
};
int n, m, u1[N], u2[N], ans, U1, U2;
vector<Edge> G[N];
int dfs(int u, int fa = 0) {
int f = 0, g = 0;
u1[u] = u2[u] = u;
for (auto &x : G[u])
if (x.v ^ fa) {
int h = dfs(x.v, u) + 1;
if (h > f) {
g = f;
u2[u] = u1[u];
f = h;
u1[u] = u1[x.v];
} else if (h > g) {
g = h;
u2[u] = u1[x.v];
}
}
if (f + g > ans) {
ans = f + g;
U1 = u1[u];
U2 = u2[u];
}
return f;
}
struct QAQ {
int rt, idx, dfn[N], pos[N], dr[N], w[N], d[N];
void dfs(int u, int fa = 0) {
dfn[u] = ++idx;
pos[idx] = u;
for (auto &x : G[u])
if (x.v ^ fa) {
w[x.v] = x.w ^ w[u];
d[x.v] = 1 + d[u];
dfs(x.v, u);
}
dr[u] = idx;
}
int Max[N << 2][2];
bool flip[N << 2];
void addtag(int u) {
flip[u] ^= 1;
swap(Max[u][0], Max[u][1]);
}
void pushd(int u) {
if (!flip[u]) return;
addtag(u << 1);
addtag(u << 1 | 1);
flip[u] = 0;
}
void build(int u, int l, int r) {
if (l == r) {
int x = pos[l];
Max[u][w[x]] = d[x];
Max[u][w[x] ^ 1] = 0;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
for (int i = 0; i <= 1; ++i)
Max[u][i] = max(Max[u << 1][i], Max[u << 1 | 1][i]);
}
void modify(int u, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
addtag(u);
return;
}
int mid = (l + r) >> 1;
pushd(u);
if (qr <= mid)
modify(u << 1, l, mid, ql, qr);
else if (ql > mid)
modify(u << 1 | 1, mid + 1, r, ql, qr);
else {
modify(u << 1, l, mid, ql, mid);
modify(u << 1 | 1, mid + 1, r, mid + 1, qr);
}
for (int i = 0; i <= 1; ++i)
Max[u][i] = max(Max[u << 1][i], Max[u << 1 | 1][i]);
}
void build() {
dfs(rt);
build(1, 1, n);
}
} qaq[2];
int main() {
scanf("%d", &n);
static int uu[N], vv[N], u, v, w;
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d%d", &u, &v, &w);
uu[i] = u;
vv[i] = v;
G[u].push_back({v, w});
G[v].push_back({u, w});
}
dfs(1);
qaq[0].rt = U1;
qaq[1].rt = U2;
for (int i = 0; i <= 1; ++i) qaq[i].build();
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int id;
scanf("%d", &id);
u = uu[id];
v = vv[id];
for (int j = 0; j <= 1; ++j) {
int z = qaq[j].dfn[u] < qaq[j].dfn[v] ? v : u;
qaq[j].modify(1, 1, n, qaq[j].dfn[z], qaq[j].dr[z]);
}
printf("%d\n", max(qaq[0].Max[1][0], qaq[1].Max[1][0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10, INF = 0x3f3f3f3f;
vector<pair<int, int> > e[maxn];
int dep[maxn];
void dfs(int u, int fa, int& mxu) {
dep[u] = dep[fa] + 1;
if (dep[u] > dep[mxu]) mxu = u;
for (auto v : e[u])
if (v.first != fa) dfs(v.first, u, mxu);
}
int f[2][maxn][2], dfn[2][maxn], sz[2][maxn], tot;
void dfs(int u, int fa, int w, int d, int o) {
dfn[o][u] = ++tot;
sz[o][u] = 1;
f[o][tot][w & 1] = d;
f[o][tot][(w & 1) ^ 1] = -INF;
for (auto v : e[u])
if (v.first != fa) {
dfs(v.first, u, w + v.second, d + 1, o);
sz[o][u] += sz[o][v.first];
}
}
struct node {
int mx[2], lz;
} tr[2][maxn << 2];
inline void pushup(int rt, int o) {
tr[o][rt].mx[0] = max(tr[o][rt << 1].mx[0], tr[o][rt << 1 | 1].mx[0]);
tr[o][rt].mx[1] = max(tr[o][rt << 1].mx[1], tr[o][rt << 1 | 1].mx[1]);
}
inline void dw(int rt, int o) {
swap(tr[o][rt].mx[0], tr[o][rt].mx[1]);
tr[o][rt].lz ^= 1;
}
inline void pushdw(int rt, int o) {
if (tr[o][rt].lz) {
dw(rt << 1, o);
dw(rt << 1 | 1, o);
tr[o][rt].lz = 0;
}
}
void build(int l, int r, int rt) {
if (l == r) {
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j) tr[i][rt].mx[j] = f[i][l][j];
return;
}
int m = l + r >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt, 0);
pushup(rt, 1);
}
void upd(int L, int R, int l, int r, int rt, int o) {
if (L <= l && r <= R) {
dw(rt, o);
return;
}
pushdw(rt, o);
int m = l + r >> 1;
if (L <= m) upd(L, R, l, m, rt << 1, o);
if (R > m) upd(L, R, m + 1, r, rt << 1 | 1, o);
pushup(rt, o);
}
pair<int, int> p[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
p[i].first = u, p[i].second = v;
e[u].push_back(make_pair(v, w));
e[v].push_back(make_pair(u, w));
}
int A = 0, B = 0;
dfs(1, 0, A);
dfs(A, 0, B);
dfs(A, 0, 0, 0, 0);
tot = 0;
dfs(B, 0, 0, 0, 1);
build(1, n, 1);
int q;
cin >> q;
while (q--) {
int id;
scanf("%d", &id);
int x = p[id].first, y = p[id].second;
for (int o = 0; o < 2; ++o) {
if (dfn[o][x] < dfn[o][y]) swap(x, y);
upd(dfn[o][x], dfn[o][x] + sz[o][x] - 1, 1, n, 1, o);
}
printf("%d\n", max(tr[0][1].mx[0], tr[1][1].mx[0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const double EPS = 1e-9;
const double PI = acos(-1.);
const long long LL_INF = 1e17 + 16;
const int INF = 1e9 + 10;
const long long MOD = 1e9 + 7;
const int MAXN = 5e5 + 5;
struct edge {
int s, to, t;
edge() {}
edge(int _s, int _to, int _t) { s = _s, to = _to, t = _t; }
int get_to(int from) { return from == s ? to : s; }
} ee[MAXN];
vector<int> g[MAXN];
int used[MAXN];
int dis[2][MAXN];
void dfs1(int ind, int s) {
used[s] = 1;
for (int i = (0); i < (int)((int)(g[s]).size()); i++) {
int to = ee[g[s][i]].get_to(s);
if (!used[to]) {
dis[ind][to] = dis[ind][s] + 1;
dfs1(ind, to);
}
}
}
int tin[2][MAXN], tout[2][MAXN], _timer[2];
int ee_to[2][MAXN];
void dfs2(int ind, int s) {
used[s] = 1;
tin[ind][s] = tout[ind][s] = _timer[ind]++;
for (int i = (0); i < (int)((int)(g[s]).size()); i++) {
int to = ee[g[s][i]].get_to(s);
if (!used[to]) {
ee_to[ind][g[s][i]] = to;
dfs2(ind, to);
tout[ind][s] = tout[ind][to];
}
}
}
struct item {
int val[2];
int t;
item() { val[0] = val[1] = t = 0; }
void swap() {
t ^= 1;
std::swap(val[0], val[1]);
}
};
template <typename temp_type>
struct segment_tree {
int n;
int vals[MAXN];
temp_type tt[4 * MAXN];
temp_type combine(const temp_type &v1, const temp_type &v2) {
temp_type res;
res.t = 0;
for (int i = (0); i < (int)(2); i++) {
res.val[i] = max(v1.val[i], v2.val[i]);
}
return res;
}
void push(int ind) {
if (tt[ind].t) {
tt[ind].swap();
tt[ind << 1].swap();
tt[(ind << 1) + 1].swap();
}
}
void build(int ind, int tl, int tr) {
if (tl == tr) {
tt[ind].t = 0;
tt[ind].val[0] = vals[tl];
tt[ind].val[1] = -1;
return;
}
int tm = (tl + tr) >> 1;
build(ind << 1, tl, tm);
build((ind << 1) + 1, tm + 1, tr);
tt[ind] = combine(tt[ind << 1], tt[(ind << 1) + 1]);
}
temp_type get_val(int ind, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
return tt[ind];
}
push(ind);
int tm = (tl + tr) >> 1;
temp_type result;
if (r <= tm) {
result = get_val(ind << 1, tl, tm, l, r);
} else if (l > tm) {
result = get_val((ind << 1) + 1, tm + 1, tr, l, r);
} else {
result = combine(get_val(ind << 1, tl, tm, l, tm),
get_val((ind << 1) + 1, tm + 1, tr, tm + 1, r));
}
return result;
}
void upd_val(int ind, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
tt[ind].swap();
return;
}
push(ind);
int tm = (tl + tr) >> 1;
if (r <= tm) {
upd_val(ind << 1, tl, tm, l, r);
} else if (l > tm) {
upd_val((ind << 1) + 1, tm + 1, tr, l, r);
} else {
upd_val(ind << 1, tl, tm, l, tm);
upd_val((ind << 1) + 1, tm + 1, tr, tm + 1, r);
}
tt[ind] = combine(tt[ind << 1], tt[(ind << 1) + 1]);
}
void build() { build(1, 0, n - 1); }
temp_type get_val(int l, int r) { return get_val(1, 0, n - 1, l, r); }
void upd_val(int l, int r) { upd_val(1, 0, n - 1, l, r); }
};
segment_tree<item> tt[2];
void solve() {
int n;
scanf("%d", &n);
for (int i = (1); i < (int)(n); i++) {
scanf("%d%d%d", &ee[i].s, &ee[i].to, &ee[i].t);
g[ee[i].s].push_back(i);
g[ee[i].to].push_back(i);
}
dfs1(0, 1);
int s = 1;
for (int i = (1); i <= (int)(n); i++) {
if (dis[0][s] < dis[0][i]) {
s = i;
}
used[i] = 0;
}
dis[0][s] = 0;
dfs1(0, s);
int f = 1;
for (int i = (1); i <= (int)(n); i++) {
if (dis[0][f] < dis[0][i]) {
f = i;
}
used[i] = 0;
}
dfs1(1, f);
for (int i = (1); i <= (int)(n); i++) {
used[i] = 0;
}
dfs2(0, s);
for (int i = (1); i <= (int)(n); i++) {
used[i] = 0;
}
dfs2(1, f);
for (int k = (0); k < (int)(2); k++) {
tt[k].n = n;
for (int i = (1); i <= (int)(n); i++) {
tt[k].vals[tin[k][i]] = dis[k][i];
}
tt[k].build();
}
for (int i = (1); i < (int)(n); i++) {
if (ee[i].t) {
for (int k = (0); k < (int)(2); k++) {
int l = tin[k][ee_to[k][i]];
int r = tout[k][ee_to[k][i]];
tt[k].upd_val(l, r);
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
for (int k = (0); k < (int)(2); k++) {
int l = tin[k][ee_to[k][x]];
int r = tout[k][ee_to[k][x]];
tt[k].upd_val(l, r);
}
int ans =
max(tt[0].get_val(0, n - 1).val[0], tt[1].get_val(0, n - 1).val[0]);
printf("%d\n", ans);
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int inf = 5e8;
int n, dfn[N], low[N], seq[N], tim, col[N], dep[N], mx[N << 2], mxn[N << 2][2],
mxl[N << 2][2], mxr[N << 2][2], mnm[N << 2], sub[N];
bool s[N], tag[N << 2];
vector<pair<int, int> > E[N];
void dfs(int u, int ff) {
seq[dfn[u] = ++tim] = u;
dep[u] = dep[ff] + 1;
for (auto e : E[u]) {
int v = e.first;
if (v != ff)
sub[e.second] = v, s[v] = s[u] ^ col[e.second], dfs(v, u), seq[++tim] = u;
}
low[u] = tim;
}
void chkmax(int &a, int b) { a = max(a, b); }
void up(int x) {
mx[x] = mxn[x][0] = mxn[x][1] = mxl[x][0] = mxl[x][1] = mxr[x][0] =
mxr[x][1] = -inf;
mnm[x] = min(mnm[(x << 1)], mnm[(x << 1 | 1)]);
mx[x] = max(mx[(x << 1)], mx[(x << 1 | 1)]);
for (int i = 0; i < 2; i++) {
chkmax(mxn[x][i], max(mxn[(x << 1)][i], mxn[(x << 1 | 1)][i]));
chkmax(mxl[x][i], max(mxl[(x << 1)][i],
max(mxl[(x << 1 | 1)][i],
mxn[(x << 1 | 1)][i] - 2 * mnm[(x << 1)])));
chkmax(mxr[x][i], max(mxr[(x << 1)][i],
max(mxr[(x << 1 | 1)][i],
mxn[(x << 1)][i] - 2 * mnm[(x << 1 | 1)])));
}
for (int i = 0; i < 2; i++)
chkmax(mx[x], max(mxr[(x << 1)][i] + mxn[(x << 1 | 1)][i],
mxn[(x << 1)][i] + mxl[(x << 1 | 1)][i]));
}
void mdf(int x) {
swap(mxn[x][0], mxn[x][1]);
swap(mxl[x][0], mxl[x][1]);
swap(mxr[x][0], mxr[x][1]);
tag[x] ^= 1;
}
void down(int x) {
if (tag[x]) mdf((x << 1)), mdf((x << 1 | 1)), tag[x] = 0;
}
void build(int x = 1, int l = 1, int r = tim) {
if (l == r) {
mnm[x] = dep[seq[l]];
if (dfn[seq[l]] == l) {
bool f = s[seq[l]];
int d = dep[seq[l]];
mxn[x][f] = d;
mxl[x][f] = mxr[x][f] = -d;
mx[x] = 0;
mxn[x][f ^ 1] = mxl[x][f ^ 1] = mxr[x][f ^ 1] = -inf;
} else {
mx[x] = mxn[x][0] = mxn[x][1] = mxl[x][0] = mxl[x][1] = mxr[x][0] =
mxr[x][1] = -inf;
}
return;
}
int mid = (l + r) >> 1;
build((x << 1), l, mid);
build((x << 1 | 1), mid + 1, r);
up(x);
}
void modify(int L, int R, int x = 1, int l = 1, int r = tim) {
if (L <= l && r <= R) return mdf(x);
down(x);
int mid = (l + r) >> 1;
if (L <= mid) modify(L, R, (x << 1), l, mid);
if (R > mid) modify(L, R, (x << 1 | 1), mid + 1, r);
up(x);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v >> col[i];
E[u].push_back(make_pair(v, i));
E[v].push_back(make_pair(u, i));
}
dfs(1, 0);
build();
int m;
cin >> m;
while (m--) {
int id;
cin >> id;
int u = sub[id];
modify(dfn[u], low[u]);
cout << mx[1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
}
return x * w;
}
inline long long readl() {
char ch = getchar();
long long x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0', ch = getchar();
}
return x * w;
}
const int N = 5e5 + 7;
struct edge {
int u, v;
} e[N];
int n, m, hed[N], to[N << 1], nxt[N << 1], cnt = 0, tr[N << 2][2], lazy[N << 2],
W[N << 1];
int X, Y, dep[N], mx, Q[N], tim = 0, ru[N], rev[N], chu[N], ans[N], fa[N];
bool cla[N];
inline void add(int u, int v, int w) {
to[++cnt] = v, nxt[cnt] = hed[u], hed[u] = cnt, W[cnt] = w;
}
inline void dfs1(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) X = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs1(v, u);
}
}
inline void dfs2(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) Y = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs2(v, u);
}
}
inline void dfs(int u, int fat) {
int v;
ru[u] = ++tim;
rev[tim] = u;
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) {
fa[v] = u;
dep[v] = dep[u] + 1;
if (W[i])
cla[v] = cla[u] ^ 1;
else
cla[v] = cla[u];
dfs(v, u);
}
}
chu[u] = tim;
}
inline void up(int now, int h, int t) {
tr[now][0] = max(tr[now << 1][0], tr[now << 1 | 1][0]);
tr[now][1] = max(tr[now << 1][1], tr[now << 1 | 1][1]);
}
inline void build(int now, int h, int t) {
if (h == t) {
tr[now][cla[rev[h]]] = dep[rev[h]];
return;
}
build(now << 1, h, ((h + t) >> 1)),
build(now << 1 | 1, ((h + t) >> 1) + 1, t);
up(now, h, t);
}
inline void spread(int now, int h, int t) {
if (lazy[now]) {
(tr[now << 1][0] ^= tr[now << 1][1] ^= tr[now << 1][0] ^= tr[now << 1][1]);
(tr[now << 1 | 1][0] ^= tr[now << 1 | 1][1] ^= tr[now << 1 | 1][0] ^=
tr[now << 1 | 1][1]);
lazy[now << 1] ^= 1, lazy[now << 1 | 1] ^= 1;
lazy[now] = 0;
}
}
inline void updata(int now, int h, int t, int H, int T) {
if (h > T || H > t) return;
if (H <= h && t <= T) {
lazy[now] ^= 1;
(tr[now][0] ^= tr[now][1] ^= tr[now][0] ^= tr[now][1]);
return;
}
spread(now, h, t);
if (H <= ((h + t) >> 1)) updata(now << 1, h, ((h + t) >> 1), H, T);
if (((h + t) >> 1) + 1 <= T)
updata(now << 1 | 1, ((h + t) >> 1) + 1, t, H, T);
up(now, h, t);
}
inline void work(int rt) {
memset(dep, 0, sizeof(dep));
cla[rt] = 0;
memset(tr, 0, sizeof(tr));
memset(fa, 0, sizeof(fa));
tim = 0;
dfs(rt, 0);
memset(lazy, 0, sizeof(lazy));
build(1, 1, n);
int u, v;
for (int i = 1; i <= m; ++i) {
u = e[Q[i]].u;
v = e[Q[i]].v;
if (fa[u] == v) (u ^= v ^= u ^= v);
updata(1, 1, n, ru[v], chu[v]);
ans[i] = max(ans[i], tr[1][0]);
}
}
int main() {
n = read();
int u, v, w;
for (int i = 1; i <= n - 1; ++i) {
u = read(), v = read(), w = read();
add(u, v, w), add(v, u, w);
e[i] = (edge){u, v};
}
memset(dep, 0, sizeof(dep));
mx = -1;
dfs1(1, 0);
memset(dep, 0, sizeof(dep)), mx = -1, dep[0] = -1;
dfs2(X, 0);
m = read();
for (int i = 1; i <= m; ++i) Q[i] = read();
memset(ans, 0, sizeof(ans));
work(X), work(Y);
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int ne[N << 1], fi[N], zz[N << 1], Id, sl[N << 1], tot, in[N], out[N], num[N],
x[N], y[N], z[N], n, m, s, t, dis1[N], dis2[N], id[N];
queue<int> q;
struct Tree {
int l, r, num1, num2, num3, num4, flag1, flag2;
} T[N * 4];
inline int pd(int x, int y) { return in[x] <= in[y] && out[x] >= out[y]; }
inline void jb(int x, int y, int z) {
ne[++tot] = fi[x];
fi[x] = tot;
zz[tot] = y;
sl[tot] = z;
}
void dfs(int x, int y, int z) {
num[x] = z;
in[x] = ++tot;
id[tot] = x;
for (int i = fi[x]; i; i = ne[i])
if (zz[i] != y) dfs(zz[i], x, z ^ sl[i]);
out[x] = tot;
}
inline void update(int x) {
T[x].num1 = max(T[x * 2].num1, T[x * 2 + 1].num1);
T[x].num2 = max(T[x * 2].num2, T[x * 2 + 1].num2);
T[x].num3 = max(T[x * 2].num3, T[x * 2 + 1].num3);
T[x].num4 = max(T[x * 2].num4, T[x * 2 + 1].num4);
}
inline void filp1(int x) {
T[x].flag1 ^= 1;
swap(T[x].num1, T[x].num2);
}
inline void filp2(int x) {
T[x].flag2 ^= 1;
swap(T[x].num3, T[x].num4);
}
inline void down(int x) {
if (T[x].flag1) {
filp1(x * 2);
filp1(x * 2 + 1);
}
if (T[x].flag2) {
filp2(x * 2);
filp2(x * 2 + 1);
}
T[x].flag1 = T[x].flag2 = 0;
}
void build(int x, int l, int r) {
T[x].l = l;
T[x].r = r;
if (l == r) {
if (num[id[l]] == num[s])
T[x].num1 = dis1[id[l]];
else
T[x].num2 = dis1[id[l]];
if (num[id[l]] == num[t])
T[x].num3 = dis2[id[l]];
else
T[x].num4 = dis2[id[l]];
return;
}
int mid = (l + r) / 2;
build(x * 2, l, mid);
build(x * 2 + 1, mid + 1, r);
update(x);
}
void insert(int x, int l, int r) {
if (T[x].l > r || l > T[x].r) return;
if (T[x].l >= l && T[x].r <= r) {
filp1(x);
filp2(x);
return;
}
down(x);
insert(x * 2, l, r);
insert(x * 2 + 1, l, r);
update(x);
}
void bfs(int x, int dis[]) {
for (int i = 1; i <= n; i++) dis[i] = -1;
dis[x] = 0;
q.push(x);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = fi[x]; i; i = ne[i])
if (dis[zz[i]] == -1) {
dis[zz[i]] = dis[x] + 1;
q.push(zz[i]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x[i], &y[i], &z[i]);
jb(x[i], y[i], z[i]);
jb(y[i], x[i], z[i]);
}
tot = 0;
dfs(1, 0, 0);
for (int i = 1; i < n; i++)
if (in[x[i]] > in[y[i]]) swap(x[i], y[i]);
bfs(1, dis1);
s = 1;
for (int i = 2; i <= n; i++)
if (dis1[i] > dis1[s]) s = i;
t = 1;
bfs(s, dis2);
for (int i = 2; i <= n; i++)
if (dis2[i] > dis2[t]) t = i;
bfs(t, dis1);
swap(dis1, dis2);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d", &Id);
if (pd(y[Id], s)) filp1(1);
if (pd(y[Id], t)) filp2(1);
insert(1, in[y[Id]], out[y[Id]]);
printf("%d\n", max(T[1].num1, T[1].num3));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
template <class T>
void rd(T &x) {
x = 0;
int f = 0;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
}
int n;
int cnt, al[500005 << 1], bl[500005 << 1], cl[500005 << 1], kk[500005];
int su1[2][500005 << 2], su0[2][500005 << 2], ss[2][500005 << 2];
int cs[500005], se[500005];
int df, dfn[500005], dnf[500005], dpf[500005];
int qe[500005], voa[500005];
int Q, P, V, F;
int Mx(int x, int y) { return x > y ? x : y; }
void jia(int x, int y, int z) {
al[++cnt] = y;
bl[cnt] = z;
cl[cnt] = kk[x];
kk[x] = cnt;
}
int bfs(int u) {
int q = 0, p = 0;
qe[p++] = u;
for (int i = 1; i <= n; ++i) voa[i] = 0;
voa[u] = 1;
while (q < p) {
u = qe[q++];
for (int i = kk[u]; i; i = cl[i])
if (!voa[al[i]]) qe[p++] = al[i], voa[al[i]] = 1;
}
return qe[p - 1];
}
void dfs(int x, int y) {
dfn[x] = ++df;
dpf[df] = x;
for (int i = kk[x]; i; i = cl[i])
if (al[i] != y) {
dfs(al[i], x);
}
dnf[x] = df;
}
void dfs1(int x, int y) {
for (int i = kk[x]; i; i = cl[i])
if (al[i] != y) {
cs[al[i]] = cs[x] ^ bl[i];
se[al[i]] = se[x] + 1;
dfs1(al[i], x);
}
}
void pushd(int bao) {
int l = bao << 1, r = bao << 1 | 1;
ss[F][l] ^= 1;
ss[F][r] ^= 1;
swap(su0[F][l], su1[F][l]);
swap(su0[F][r], su1[F][r]);
ss[F][bao] = 0;
}
void pushup(int bao) {
su1[F][bao] = Mx(su1[F][bao << 1], su1[F][bao << 1 | 1]);
su0[F][bao] = Mx(su0[F][bao << 1], su0[F][bao << 1 | 1]);
}
void init(int l, int r, int bao) {
if (l == r) {
if (cs[dpf[l]])
su1[F][bao] = se[dpf[l]];
else
su0[F][bao] = se[dpf[l]];
return;
}
int mid = l + r >> 1;
init(l, mid, bao << 1);
init(mid + 1, r, bao << 1 | 1);
pushup(bao);
}
void cg(int l, int r, int bao) {
if (Q <= l && P >= r) {
ss[F][bao] ^= 1;
swap(su0[F][bao], su1[F][bao]);
return;
}
if (ss[F][bao]) pushd(bao);
int mid = l + r >> 1;
if (Q <= mid) cg(l, mid, bao << 1);
if (P > mid) cg(mid + 1, r, bao << 1 | 1);
pushup(bao);
}
int main() {
int q, x, y, z, u, v;
rd(n);
for (int i = 1; i < n; ++i) {
rd(x);
rd(y);
rd(z);
jia(x, y, z);
jia(y, x, z);
}
u = bfs(1);
v = bfs(u);
dfs(u, 0);
F = 0;
cs[u] = 0;
se[u] = 0;
dfs1(u, 0);
init(1, n, 1);
F = 1;
cs[v] = 0;
se[v] = 0;
dfs1(v, 0);
init(1, n, 1);
rd(q);
while (q--) {
rd(x);
y = al[x << 1];
z = al[(x << 1) - 1];
if (dfn[y] < dfn[z]) y = z;
F = 0;
Q = dfn[y];
P = dnf[y];
cg(1, n, 1);
F = 1;
if (dfn[v] <= dnf[y] && dfn[v] >= dfn[y]) {
Q = 1;
P = dfn[y] - 1;
if (Q <= P) cg(1, n, 1);
Q = dnf[y] + 1;
P = n;
if (Q <= P) cg(1, n, 1);
} else
cg(1, n, 1);
printf("%d\n", Mx(su0[0][1], su0[1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
const string FILENAME = "input";
const int MAXN = 500228;
int n, q;
vector<pair<int, int> > g[MAXN];
int c[MAXN];
int dep[MAXN];
int last = 0;
int ft[MAXN];
int sums[MAXN];
unordered_map<int, int> in[MAXN];
vector<int> out[MAXN];
int timer;
vector<int> who[MAXN];
vector<int> score[MAXN][2];
struct rmq {
vector<pair<int, int> > d;
vector<int> mod;
int ss = 1;
void init(int n) {
while (ss < n) {
ss <<= 1;
}
d.resize(2 * ss);
mod.resize(2 * ss);
for (auto &x : d) {
x = make_pair(0, 0);
}
for (auto &x : mod) {
x = 0;
}
}
void relax() {
for (int v = ss - 1; v >= 0; v--) {
d[v].first = max(d[v * 2].first, d[v * 2 + 1].first);
d[v].second = max(d[v * 2].second, d[v * 2 + 1].second);
}
}
void push(int v) {
if (mod[v] != 0) {
swap(d[v].first, d[v].second);
if (v < ss) {
mod[v * 2] ^= mod[v];
mod[v * 2 + 1] ^= mod[v];
}
mod[v] = 0;
}
}
void add(int v, int vl, int vr, int l, int r, int x) {
if (vl > r || vr < l) {
push(v);
return;
}
if (l <= vl && vr <= r) {
mod[v] ^= x;
push(v);
return;
}
push(v);
add(v * 2, vl, (vl + vr) / 2, l, r, x);
add(v * 2 + 1, (vl + vr) / 2 + 1, vr, l, r, x);
d[v].first = max(d[v * 2].first, d[v * 2 + 1].first);
d[v].second = max(d[v * 2].second, d[v * 2 + 1].second);
}
int curadd = 0;
int getmax(int v, int vl, int vr, int l, int r, int dd) {
if (vl > r || vr < l) {
return 0LL;
}
if (l <= vl && vr <= r) {
int need = dd ^ mod[v] ^ curadd;
return (need == 0 ? d[v].first : d[v].second);
}
curadd ^= mod[v];
auto res = max(getmax(v * 2, vl, (vl + vr) / 2, l, r, dd),
getmax(v * 2 + 1, (vl + vr) / 2 + 1, vr, l, r, dd));
curadd ^= mod[v];
return res;
}
} kek[MAXN];
multiset<int> keks[MAXN][2];
vector<int> deps[MAXN];
int cs[MAXN];
int root;
int deep[MAXN];
void dfs(int u, int pr = -1) {
timer++;
in[root][u] = timer;
int pos = timer - 1;
for (auto h : g[u]) {
if (h.first == pr) {
continue;
}
if (deep[h.first]) {
continue;
}
if (u == root) {
who[root][timer] = timer;
} else {
who[root][timer] = who[root][pos];
}
deps[root][timer] = deps[root][pos] + 1;
cs[timer] = cs[pos] ^ c[h.second];
int gg = timer;
dfs(h.first, u);
if (u == root) {
for (int d = 0; d < 2; d++) {
if (score[root][d][gg]) {
keks[root][d].insert(score[root][d][gg]);
}
}
}
}
out[root][pos] = timer;
chkmax(score[root][cs[pos]][who[root][pos]], deps[root][pos]);
if (cs[pos] == 0) {
kek[root].d[kek[root].ss + pos].first = deps[root][pos];
kek[root].d[kek[root].ss + pos].second = 0;
} else {
kek[root].d[kek[root].ss + pos].second = deps[root][pos];
kek[root].d[kek[root].ss + pos].first = 0;
}
}
int ft1[MAXN];
void updateDistsForRoot(int root, int id, int diff) {
int x = ft[id];
int y = ft1[id];
if (in[root].find(x) == in[root].end() ||
in[root].find(y) == in[root].end()) {
return;
}
int fts = in[root][x] - 1;
int fts1 = in[root][y] - 1;
if (deps[root][fts] < deps[root][fts1]) {
swap(x, y);
swap(fts, fts1);
}
kek[root].add(1, 1, kek[root].ss, fts + 1, out[root][fts], diff);
int ff = who[root][fts];
for (int tt = 0; tt < 2; tt++) {
auto &value = score[root][tt][ff];
if (value != 0) {
keks[root][tt].erase(keks[root][tt].find(value));
}
value = kek[root].getmax(1, 1, kek[root].ss, ff + 1, out[root][ff], tt);
if (value != 0) {
keks[root][tt].insert(value);
}
}
}
multiset<int> kekr;
int findAnsForRoot(int root) {
int res = 0;
for (int t = 0; t < 2; t++) {
if (keks[root][t].empty()) {
continue;
}
auto x = keks[root][t].rbegin();
int ans = 0;
int cp = 0;
for (int it = 0; it < 2; it++) {
if (x == keks[root][t].rend()) {
break;
}
ans += *x;
cp += t;
x++;
}
if (cp % 2 == 0) {
chkmax(res, ans);
}
}
return res;
}
void change(int root, int id, int diff) {
kekr.erase(kekr.find(findAnsForRoot(root)));
updateDistsForRoot(root, id, diff);
kekr.insert(findAnsForRoot(root));
}
int sz[MAXN];
int cng;
int PRcentroid[MAXN];
vector<int> v[MAXN];
vector<int> sts;
int d[MAXN];
void dfs2(int u, int pr = -1) {
sz[u] = 1;
sts.push_back(u);
for (auto h : g[u]) {
if (!deep[h.first] && h.first != pr) {
d[h.first] = d[u] + 1;
dfs2(h.first, u);
sz[u] += sz[h.first];
}
}
}
int curcentre;
vector<int> st[MAXN];
void dfs1(int u, int pr = -1) {
st[curcentre].push_back(u);
for (auto h : g[u]) {
if (!deep[h.first] && h.first != pr) {
dfs1(h.first, u);
}
}
}
inline int find_centroid() {
int ans = -1;
for (auto u : sts) {
if (sz[u] >= cng / 2) {
if (ans == -1 || d[u] > d[ans]) {
ans = u;
}
}
}
return ans;
}
void centroid_decomposition(int s) {
curcentre = s;
cng = n;
dfs1(s);
root = s;
kek[root].init(cng);
timer = 0;
deps[root].resize(cng);
out[root].resize(cng);
who[root].resize(cng);
score[root][1].resize(cng);
score[root][0].resize(cng);
cs[root] = 0;
dfs(root);
kek[root].relax();
kekr.insert(findAnsForRoot(root));
}
int roots, root1;
void trys(int u, int id, int diff) {
change(roots, id, diff);
change(root1, id, diff);
}
int dist[MAXN];
void dfsk(int u, int pr = -1) {
for (auto h : g[u]) {
if (h.first != pr) {
dist[h.first] = dist[u] + 1;
dfsk(h.first, u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b >> c[i];
a--, b--;
g[a].push_back({b, i});
g[b].push_back({a, i});
if (a > b) {
swap(a, b);
}
ft[i] = b;
ft1[i] = a;
}
dfsk(0);
int cur = 0;
for (int i = 0; i < n; i++) {
if (dist[i] > dist[cur]) {
cur = i;
}
}
roots = cur;
dist[roots] = 0;
dfsk(roots);
cur = 0;
for (int i = 0; i < n; i++) {
if (dist[i] > dist[cur]) {
cur = i;
}
}
root1 = cur;
centroid_decomposition(roots);
centroid_decomposition(root1);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int d;
cin >> d;
d--;
c[d] ^= 1;
trys(ft[d], d, 1);
if (kekr.empty()) {
cout << 0 << '\n';
} else {
cout << *kekr.rbegin() << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
struct empty_splay_tree {};
template <typename pnode, class base = empty_splay_tree>
struct splay_tree : base {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <class splay_tree_vchs>
struct vnode_splay_tree {
splay_tree_vchs vnode;
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode, vnode_splay_tree<splay_tree_vchs>> {
using splay_tree<pnode, vnode_splay_tree<splay_tree_vchs>>::ch;
bool rev;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode, vnode_splay_tree<splay_tree_vchs>>() {
root = NULL;
rev = 0;
}
void update() {}
void push() {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
void rotate() {
swap(this->vnode, this->p->vnode);
splay_tree<pnode, vnode_splay_tree<splay_tree_vchs>>::rotate();
}
void splay() {
bool r = !this->is_root();
splay_tree<pnode, vnode_splay_tree<splay_tree_vchs>>::splay();
if (r && this->p) {
auto v = &this->vnode;
if (v->p)
v->p->ch[v->p->ch[1] &&
!reinterpret_cast<pnode>(v->p->ch[1])->is_root()] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
}
}
void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs();
v->vnode.build();
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
int x;
array<int, 4> y;
void build() {
auto key = reinterpret_cast<pnode>(this);
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() { splay_tree_lct::push(); }
void reverse() {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(4)
using namespace std;
char _buf[100000], *_p1 = _buf, *_p2 = _buf;
inline int gi() {
int x = 0, f = 1;
char ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = (_p1 == _p2 && (_p2 = (_p1 = _buf) + fread(_buf, 1, 100000, stdin),
_p1 == _p2)
? EOF
: *_p1++);
}
return (f == 1) ? x : -x;
}
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
const int maxn = 5e5 + 5;
int n, p[maxn], sz, maxpos, maxdis, fa[maxn], Q;
struct node {
int u, v, w;
};
vector<node> edg;
struct edge {
int v, w, nxt;
edge(int vv = 0, int ww = 0, int nn = 0) { v = vv, w = ww, nxt = nn; }
} e[maxn << 1];
inline void add(int u, int v, int w) {
e[++sz] = edge(v, w, p[u]);
p[u] = sz;
}
struct segmentree {
static const int maxn = 2e6 + 5;
int rt;
int dep[maxn], tot, dfn[maxn], siz[maxn], len[maxn], rk[maxn];
bool tag[maxn];
int maxv[maxn][2];
inline void pushup(int u) {
for (int i = 0; i <= 1; ++i) {
if (maxv[u << 1][i] > maxv[u << 1 | 1][i])
maxv[u][i] = maxv[u << 1][i];
else
maxv[u][i] = maxv[u << 1 | 1][i];
}
}
inline void pushdown(int u) {
if (tag[u]) {
swap(maxv[u << 1][0], maxv[u << 1][1]);
swap(maxv[u << 1 | 1][0], maxv[u << 1 | 1][1]);
tag[u << 1] ^= 1, tag[u << 1 | 1] ^= 1, tag[u] = 0;
}
}
inline void dfs(int u, int fa) {
dfn[u] = ++tot;
siz[u] = 1;
rk[tot] = u;
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (e[i].w == 1)
len[v] = len[u] ^ 1;
else
len[v] = len[u];
dep[v] = dep[u] + 1;
dfs(v, u);
siz[u] += siz[v];
}
}
inline void build(int u, int l, int r) {
if (l == r) {
maxv[u][len[rk[l]]] = dep[rk[l]];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
inline int query(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) return maxv[u][0];
int mid = (l + r) >> 1, ret = 0;
pushdown(u);
if (x <= mid) ret = query(u << 1, l, mid, x, y);
if (y > mid) ret = max(ret, query(u << 1 | 1, mid + 1, r, x, y));
}
inline void update(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) {
tag[u] ^= 1;
swap(maxv[u][0], maxv[u][1]);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (x <= mid) update(u << 1, l, mid, x, y);
if (y > mid) update(u << 1 | 1, mid + 1, r, x, y);
pushup(u);
}
inline void change(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
update(1, 1, n, dfn[v], dfn[v] + siz[v] - 1);
}
} tree1, tree2;
inline void dfs2(int u, int f, int dis) {
if (dis > maxdis) {
maxpos = u, maxdis = dis;
}
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs2(v, u, dis + 1);
}
}
inline void init() {
dfs2(1, 0, 0);
tree1.rt = maxpos;
maxdis = 0;
dfs2(maxpos, 0, 0);
tree2.rt = maxpos;
tree1.dfs(tree1.rt, 0);
tree2.dfs(tree2.rt, 0);
tree1.build(1, 1, n);
tree2.build(1, 1, n);
}
inline void input() {
memset(p, -1, sizeof(p));
n = gi();
node x;
edg.push_back(x);
for (int i = 1; i <= n - 1; ++i) {
x.u = gi(), x.v = gi(), x.w = gi();
edg.push_back(x);
add(x.u, x.v, x.w);
add(x.v, x.u, x.w);
}
}
inline void solve() {
Q = gi();
while (Q--) {
int x = gi();
int u = edg[x].u, v = edg[x].v;
tree1.change(u, v);
tree2.change(u, v);
printf("%d\n", max(tree1.query(1, 1, n, 1, n), tree2.query(1, 1, n, 1, n)));
}
}
int main() {
input();
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 5e5 + 5;
vector<pair<int, int> > g[mxn];
int n, m, root;
int bg[mxn], ed[mxn], cur;
int dep[mxn];
int pari[mxn];
int ord[mxn];
pair<int, int> edge[mxn];
inline void dfs(int x, int par, int Pa, int deep) {
Pa %= 2;
bg[x] = ++cur;
dep[x] = deep;
pari[x] = Pa;
ord[cur] = x;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) dfs(y, x, Pa + g[x][i].second, deep + 1);
}
ed[x] = cur;
}
struct Segt {
int val1[mxn << 3], val2[mxn << 3];
int lazy[mxn << 3];
int le[mxn << 3], ri[mxn << 3];
inline void init() {
memset(val1, -1, sizeof(val1));
memset(val2, -1, sizeof(val2));
memset(lazy, 0, sizeof(lazy));
}
inline void pushdown(int x) {
if (lazy[x]) {
lazy[x] = 0;
swap(val1[x << 1], val2[x << 1]);
swap(val1[x << 1 | 1], val2[x << 1 | 1]);
lazy[x << 1] ^= 1;
lazy[x << 1 | 1] ^= 1;
}
}
inline void pushup(int x) {
pushdown(x);
pushdown(x << 1);
pushdown(x << 1 | 1);
val1[x] = -1, val2[x] = -1;
if (val1[x << 1] != -1) val1[x] = max(val1[x], val1[x << 1]);
if (val2[x << 1] != -1) val2[x] = max(val2[x], val2[x << 1]);
if (val1[x << 1 | 1] != -1) val1[x] = max(val1[x], val1[x << 1 | 1]);
if (val2[x << 1 | 1] != -1) val2[x] = max(val2[x], val2[x << 1 | 1]);
}
inline void build(int x, int l, int r) {
le[x] = l, ri[x] = r;
if (l == r) {
if (pari[ord[l]])
val2[x] = dep[ord[l]];
else
val1[x] = dep[ord[l]];
return;
}
int md = l + r >> 1;
build(x << 1, l, md);
build(x << 1 | 1, md + 1, r);
pushup(x);
}
inline void upd(int x, int l, int r, int a, int b) {
if (r < a or b < l) return;
pushdown(x);
if (a <= l and r <= b) {
swap(val1[x], val2[x]);
lazy[x] = 1;
pushdown(x);
return;
}
int md = l + r >> 1;
upd(x << 1, l, md, a, b);
upd(x << 1 | 1, md + 1, r, a, b);
pushup(x);
}
inline int ask() { return val1[1]; }
} seg;
int dist[mxn];
inline void getd(int x, int par = -1, int dis = 0) {
dist[x] = dis;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i].first;
if (y != par) getd(y, x, dis + 1);
}
}
int root1, root2;
int tans[mxn];
int asks[mxn];
inline void solve() {
scanf("%d", &n);
for (int i = 1, u, v, t; i < n; ++i) {
scanf("%d%d%d", &u, &v, &t);
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
edge[i] = make_pair(u, v);
}
for (int i = 1; i <= n; ++i) {
if (g[i].size() == 1) {
root = i;
break;
}
}
memset(dist, 0, sizeof(dist));
int mw = root;
getd(root, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] > dist[mw]) mw = i;
root1 = mw;
memset(dist, 0, sizeof(dist));
mw = root1;
getd(root1, -1, 0);
for (int i = 1; i <= n; ++i)
if (dist[i] >= dist[mw]) mw = i;
root2 = mw;
scanf("%d", &m);
dfs(root1, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
asks[i] = x;
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
tans[i] = seg.ask();
}
cur = 0;
memset(bg, 0, sizeof(bg));
memset(ed, 0, sizeof(ed));
memset(dep, 0, sizeof(dep));
memset(pari, 0, sizeof(pari));
memset(ord, 0, sizeof(ord));
dfs(root2, -1, 0, 0);
seg.init();
seg.build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x = asks[i];
int u = edge[x].first, v = edge[x].second;
if (dep[u] > dep[v]) swap(u, v);
seg.upd(1, 1, n, bg[v], ed[v]);
printf("%d\n", max(seg.ask(), tans[i]));
}
}
int main() {
ios_base::sync_with_stdio(false);
int T = 1;
for (; T--;) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T> &v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
using tp = tuple<int, int, int>;
const int maxn = 5e5 + 7;
struct Edge {
int to, w;
};
vc<Edge> G[maxn];
vc<tp> Edge;
int n;
pair<int, int> dfs(int u, int fa = -1) {
pair<int, int> ret = {1, u};
for (auto &e : G[u])
if (e.to != fa) {
int v = e.to;
auto cur = dfs(v, u);
cur.first++;
ret = max(ret, cur);
}
return ret;
}
pair<int, int> diameter() {
pair<int, int> tar = dfs(1);
pair<int, int> tt = dfs(tar.second);
return make_pair(tar.second, tt.second);
}
struct Solver {
int dfn[maxn], dep[maxn], ti = 0, out[maxn];
int rev[maxn];
int val[maxn];
int rt;
void dfs(int u, int fa = -1) {
dfn[u] = ++ti;
rev[ti] = u;
for (auto &e : G[u])
if (e.to != fa) {
int v = e.to;
val[v] = val[u] ^ e.w;
dep[v] = dep[u] + 1;
dfs(v, u);
}
out[u] = ti;
}
void setrt(int u) {
rt = u;
dfs(rt);
assert(ti == n);
build();
}
int mx[maxn << 2][2];
int lz[maxn << 2];
void build(int L = 1, int R = n, int o = 1) {
if (L == R) {
int pt = rev[L];
mx[o][val[pt]] = dep[pt];
mx[o][val[pt] ^ 1] = -1e9;
return;
}
int mid = L + R >> 1;
build(L, mid, o << 1);
build(mid + 1, R, o << 1 | 1);
mx[o][0] = max(mx[o << 1][0], mx[o << 1 | 1][0]);
mx[o][1] = max(mx[o << 1][1], mx[o << 1 | 1][1]);
}
void pushdown(int o) {
if (lz[o]) {
swap(mx[o << 1][0], mx[o << 1][1]);
swap(mx[o << 1 | 1][0], mx[o << 1 | 1][1]);
lz[o << 1] ^= 1;
lz[o << 1 | 1] ^= 1;
lz[o] = 0;
}
}
void update(int l, int r, int L = 1, int R = n, int o = 1) {
if (l <= L && r >= R) {
swap(mx[o][0], mx[o][1]);
lz[o] ^= 1;
return;
}
pushdown(o);
int mid = L + R >> 1;
if (l <= mid) update(l, r, L, mid, o << 1);
if (r > mid) update(l, r, mid + 1, R, o << 1 | 1);
mx[o][0] = max(mx[o << 1][0], mx[o << 1 | 1][0]);
mx[o][1] = max(mx[o << 1][1], mx[o << 1 | 1][1]);
}
void change(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
update(dfn[u], out[u]);
}
int getans() { return mx[1][0]; }
} s1, s2;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, t;
cin >> u >> v >> t;
Edge.emplace_back(u, v, t);
G[u].push_back({v, t});
G[v].push_back({u, t});
}
pair<int, int> rt = diameter();
;
s1.setrt(rt.first);
s2.setrt(rt.second);
int m;
cin >> m;
while (m--) {
int id;
cin >> id;
id--;
auto cur = Edge[id];
int u, v, t;
tie(u, v, t) = cur;
s1.change(u, v);
s2.change(u, v);
print(max(s1.getans(), s2.getans()));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int hea[maxn], nxt[maxn << 1], to[maxn << 1], w[maxn << 1], S, T, tot, n;
int a[maxn], b[maxn], dep[maxn];
void add(int a, int b, int c) {
nxt[++tot] = hea[a];
hea[a] = tot;
to[tot] = b;
w[tot] = c;
}
struct Tree {
int r[maxn << 2], o[maxn << 2], e[maxn << 2], dep[maxn], f[maxn], dfn[maxn],
pos[maxn], siz[maxn], dfns;
void tag(int p) {
r[p] ^= 1;
swap(o[p], e[p]);
}
void pushdown(int p) {
if (r[p]) {
tag(p << 1);
tag(p << 1 | 1);
r[p] = 0;
}
}
void pushup(int p) {
o[p] = max(o[p << 1], o[p << 1 | 1]);
e[p] = max(e[p << 1], e[p << 1 | 1]);
}
void reverse(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return tag(p);
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) reverse(p << 1, l, mid, x, y);
if (y > mid) reverse(p << 1 | 1, mid + 1, r, x, y);
pushup(p);
}
void build(int p, int l, int r) {
if (l == r) {
if (f[pos[l]])
o[p] = dep[pos[l]];
else
e[p] = dep[pos[l]];
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pushup(p);
}
void dfs(int x, int fa) {
pos[dfn[x] = ++dfns] = x;
siz[x] = 1;
for (int i = hea[x]; i; i = nxt[i])
if (to[i] != fa) {
dep[to[i]] = dep[x] + 1;
f[to[i]] = f[x] ^ w[i];
dfs(to[i], x);
siz[x] += siz[to[i]];
}
}
void reverse(int p, int q) {
if (dep[p] < dep[q]) swap(p, q);
reverse(1, 1, n, dfn[p], dfn[p] + siz[p] - 1);
}
} A, B;
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
if (!S || dep[S] < dep[x]) S = x;
for (int i = hea[x]; i; i = nxt[i])
if (to[i] != fa) dfs(to[i], x);
}
int main() {
int q, c;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", a + i, b + i, &c);
add(a[i], b[i], c);
add(b[i], a[i], c);
}
dfs(1, 0);
T = S, S = 0;
dfs(T, 0);
A.dfs(S, 0);
B.dfs(T, 0);
A.build(1, 1, n);
B.build(1, 1, n);
scanf("%d", &q);
while (q--) {
scanf("%d", &c);
A.reverse(a[c], b[c]);
B.reverse(a[c], b[c]);
printf("%d\n", max(A.e[1], B.e[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 500000;
std::vector<std::pair<int, int> > G[N + 5];
void adde(int u, int v, int w) {
G[u].push_back(std::make_pair(v, w));
G[v].push_back(std::make_pair(u, w));
}
int a[N + 5];
int dl[N + 5], dr[N + 5], dfn[N + 5], dcnt;
int dep[N + 5], fir[N + 5], arr[2 * N + 5], cnta;
void dfs1(int x, int fa) {
dep[x] = dep[fa] + 1, dfn[dl[x] = (++dcnt)] = x, arr[fir[x] = (++cnta)] = x;
for (auto to : G[x])
if (to.first != fa)
a[to.first] = a[x] ^ to.second, dfs1(to.first, x), arr[++cnta] = x;
dr[x] = dcnt;
}
int st[22][2 * N + 5], lg[2 * N + 5];
void build() {
for (int i = 2; i <= cnta; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= cnta; i++) st[0][i] = arr[i];
for (int j = 1; j < 22; j++) {
int t = (1 << (j - 1));
for (int i = 1; i + t <= cnta; i++)
st[j][i] = (dep[st[j - 1][i]] < dep[st[j - 1][i + t]] ? st[j - 1][i]
: st[j - 1][i + t]);
}
}
int lca(int u, int v) {
u = fir[u], v = fir[v];
if (u > v) std::swap(u, v);
int p = lg[v - u + 1], q = (1 << p);
return dep[st[p][u]] < dep[st[p][v - q + 1]] ? st[p][u] : st[p][v - q + 1];
}
int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
struct type {
int u, v;
friend type operator+(const type &a, const type &b) {
if (a.u == -1) return b;
if (b.u == -1) return a;
int t[4] = {a.u, a.v, b.u, b.v}, mx = 0, p = 0, q = 0;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++)
if (dist(t[i], t[j]) > mx) mx = dist(t[i], t[j]), p = t[i], q = t[j];
return (type){p, q};
}
};
namespace segtree {
int le[4 * N + 5], ri[4 * N + 5];
bool tag[4 * N + 5];
type mx[4 * N + 5][2];
void addtag(int x) { tag[x] ^= 1, std::swap(mx[x][0], mx[x][1]); }
void pushup(int x) {
mx[x][0] = mx[(x << 1)][0] + mx[(x << 1 | 1)][0],
mx[x][1] = mx[(x << 1)][1] + mx[(x << 1 | 1)][1];
}
void pushdown(int x) {
if (tag[x]) addtag((x << 1)), addtag((x << 1 | 1));
tag[x] = 0;
}
void build(int x, int l, int r) {
le[x] = l, ri[x] = r, tag[x] = 0;
if (l == r) {
mx[x][a[dfn[l]]] = (type){dfn[l], dfn[l]};
mx[x][!a[dfn[l]]] = (type){-1, -1};
return;
}
int m = (l + r) >> 1;
build((x << 1), l, m), build((x << 1 | 1), m + 1, r), pushup(x);
}
void rev(int x, int ql, int qr) {
if (ql <= le[x] && ri[x] <= qr) {
addtag(x);
return;
}
if (le[x] > qr || ri[x] < ql) return;
pushdown(x), rev((x << 1), ql, qr), rev((x << 1 | 1), ql, qr), pushup(x);
}
int ans() {
return std::max(dist(mx[1][0].u, mx[1][0].v), dist(mx[1][1].u, mx[1][1].v));
}
} // namespace segtree
const int SZ = 1 << 19;
char buf[SZ], *ie = buf + SZ, *ip = ie - 1;
inline int read() {
if (++ip == ie) fread(ip = buf, 1, SZ, stdin);
while (*ip < '-')
if (++ip == ie) fread(ip = buf, 1, SZ, stdin);
bool f = *ip == '-';
if (f)
if (++ip == ie) fread(ip = buf, 1, SZ, stdin);
int x = *ip & 15;
if (++ip == ie) fread(ip = buf, 1, SZ, stdin);
while (*ip > '-') {
x *= 10;
x += *ip & 15;
if (++ip == ie) fread(ip = buf, 1, SZ, stdin);
}
return f ? -x : x;
}
int u[N + 5], v[N + 5];
int main() {
int n = read();
for (int i = 1, w; i < n; i++)
u[i] = read(), v[i] = read(), w = read(), adde(u[i], v[i], w);
dfs1(1, 0), build(), segtree::build(1, 1, n);
int m = read();
for (int i = 1, x; i <= m; i++) {
x = read();
x = (dep[u[x]] < dep[v[x]] ? v[x] : u[x]);
segtree::rev(1, dl[x], dr[x]);
printf("%d\n", segtree::ans());
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-all-loops")
#pragma GCC target("sse4.2")
using namespace std;
ifstream in;
ofstream out;
const long long kk = 1000;
const long long ml = kk * kk;
const long long mod = ml * kk + 7;
const long long inf = ml * ml * ml + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
int r1, r2;
vector<vector<int>> e;
vector<pair<int, int>> all_e;
vector<pair<int, int>> act;
bool viv = false;
struct Tree {
int s = 1;
int n = 0;
vector<pair<int, int>> t;
vector<bool> swp;
void build(vector<int> dist, vector<pair<int, int>> seg) {
if (viv) {
for (auto i : dist) cout << i << ' ';
cout << endl;
for (auto p : seg) cout << p.first << ' ' << p.second << "; ";
cout << endl;
}
n = dist.size();
s = 1;
while (s < n) s <<= 1;
t.resize(2 * s);
swp.resize(2 * s, false);
for (int i = 0; i < n; i++) t[s + i] = {dist[i], 0};
for (int i = s - 1; i > 0; i--) upd(i);
if (viv) show();
}
void upd(int v) {
if (v >= s) return;
t[v].first = max(t[2 * v + 0].first, t[2 * v + 1].first);
t[v].second = max(t[2 * v + 0].second, t[2 * v + 1].second);
}
void push(int v) {
if (v >= s) return;
if (!swp[v]) return;
swp[2 * v + 0] = swp[2 * v + 0] ^ true;
swp[2 * v + 1] = swp[2 * v + 1] ^ true;
swap(t[2 * v + 0].first, t[2 * v + 0].second);
swap(t[2 * v + 1].first, t[2 * v + 1].second);
swp[v] = false;
}
void _xor(int l, int r, int v, int tl, int tr) {
if (r <= tl || tr <= l) return;
push(v);
if (l <= tl && tr <= r) {
swap(t[v].first, t[v].second);
swp[v] = swp[v] ^ true;
return;
}
int _time = tl + tr >> 1;
_xor(l, r, 2 * v + 0, tl, _time);
_xor(l, r, 2 * v + 1, _time, tr);
upd(v);
}
void _xor(pair<int, int> p) {
int l = p.first, r = p.second;
r++;
_xor(l, r, 1, 0, s);
}
int get_ans() {
if (viv) show();
return t[1].first;
}
void show() {
for (long long i = 1; i < 2 * s; i++) {
cout << '\t' << '{' << t[i].first << ' ' << t[i].second << "} ";
if ((i & (i + 1)) == 0) cout << endl;
}
}
} t[2];
vector<int> d;
void DFS1(int v, int c = 0) {
d[v] = c;
for (auto u : e[v])
if (d[u] == -1) DFS1(u, c + 1);
}
int far(int v) {
d.clear();
d.resize(n, -1);
DFS1(v);
int u = 0;
for (int i = 0; i < n; i++)
if (d[i] > d[u]) u = i;
return u;
}
vector<int> dist[2];
vector<pair<int, int>> seg[2];
int _time;
void DFS2(int v, int root, int c = 0) {
dist[root == r2][_time] = c;
seg[root == r2][v].first = _time++;
for (auto u : e[v])
if (seg[root == r2][u].first == -1) DFS2(u, root, c + 1);
dist[root == r2][_time] = c;
seg[root == r2][v].second = _time++;
}
void work(int root) {
dist[root == r2].resize(2 * n, -1);
seg[root == r2].resize(n, (pair<int, int>){-1, -1});
_time = 0;
DFS2(root, root);
t[root == r2].build(dist[root == r2], seg[root == r2]);
}
void prepare() {
r1 = far(0);
r2 = far(r1);
work(r1);
work(r2);
}
int dis(int root, int v) {
int tp = (root == r2);
int pl = seg[tp][v].first;
return dist[tp][pl];
}
void change(pair<int, int> p, int root) {
int down = p.first;
int up = p.second;
if (dis(root, up) > dis(root, down)) swap(down, up);
auto sg = seg[root == r2][down];
t[root == r2]._xor(sg);
}
void change(pair<int, int> p) {
change(p, r1);
change(p, r2);
}
void get_ans() {
int ans = 0;
ans = max(ans, t[0].get_ans());
ans = max(ans, t[1].get_ans());
cout << ans << '\n';
}
void solve() {
cin >> n;
e.resize(n);
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
e[a].push_back(b);
e[b].push_back(a);
if (c) act.push_back({a, b});
all_e.push_back((pair<int, int>){a, b});
}
prepare();
for (auto p : act) change(p);
int q;
cin >> q;
while (q--) {
int num;
cin >> num;
num--;
change(all_e[num]);
get_ans();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline", "-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
using namespace std;
int n, q, loc, maxv, root[2], cnt[2], l[2][500010], r[2][500010],
val[2][500010], pos[2][500010], dep[2][500010];
int mx0[2][2000010], mx1[2][2000010], rev[2][2000010];
vector<pair<int, int> > v[500010], e;
inline int getint() {
int r = 0;
char c;
c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
r = r * 10 + c - '0';
c = getchar();
}
return r;
}
inline void dfs(int x, int pr, int dist) {
if (dist > maxv) {
maxv = dist;
loc = x;
}
for (int i = 0; i < v[x].size(); i++)
if (v[x][i].first != pr) {
dfs(v[x][i].first, x, dist + 1);
}
}
inline void calc(int id, int x, int pr) {
l[id][x] = ++cnt[id];
pos[id][cnt[id]] = x;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i].first != pr) {
val[id][v[x][i].first] = val[id][x] ^ v[x][i].second;
dep[id][v[x][i].first] = dep[id][x] + 1;
calc(id, v[x][i].first, x);
}
r[id][x] = cnt[id];
}
inline void build(int id, int o, int l, int r) {
rev[id][o] = 0;
if (l == r) {
if (val[id][pos[id][l]] == 0) {
mx0[id][o] = dep[id][pos[id][l]];
mx1[id][o] = -1000000007;
} else {
mx0[id][o] = -1000000007;
mx1[id][o] = dep[id][pos[id][l]];
}
} else {
int mid = (l + r) / 2;
build(id, o * 2, l, mid);
build(id, o * 2 + 1, mid + 1, r);
mx0[id][o] = max(mx0[id][o * 2], mx0[id][o * 2 + 1]);
mx1[id][o] = max(mx1[id][o * 2], mx1[id][o * 2 + 1]);
}
}
inline void pushdown(int id, int o, int l, int r) {
int lc = o * 2, rc = o * 2 + 1;
if (l < r) {
if (rev[id][o]) {
swap(mx0[id][lc], mx1[id][lc]);
rev[id][lc] ^= 1;
swap(mx0[id][rc], mx1[id][rc]);
rev[id][rc] ^= 1;
rev[id][o] = 0;
}
}
}
inline void pushup(int id, int o, int l, int r) {
int lc = o * 2, rc = o * 2 + 1;
if (l < r) {
mx0[id][o] = max(mx0[id][lc], mx0[id][rc]);
mx1[id][o] = max(mx1[id][lc], mx1[id][rc]);
}
}
inline void update(int id, int o, int l, int r, int xx, int yy) {
if (r < xx || l > yy) return;
if (xx <= l && r <= yy) {
swap(mx0[id][o], mx1[id][o]);
rev[id][o] ^= 1;
return;
}
pushdown(id, o, l, r);
int mid = (l + r) / 2;
update(id, o * 2, l, mid, xx, yy);
update(id, o * 2 + 1, mid + 1, r, xx, yy);
pushup(id, o, l, r);
}
signed main() {
n = getint();
for (int i = 1; i < n; i++) {
int x, y, c;
x = getint();
y = getint();
c = getint();
v[x].push_back(make_pair(y, c));
v[y].push_back(make_pair(x, c));
e.push_back(make_pair(x, y));
}
loc = 0;
maxv = 0;
dfs(1, -1, 0);
root[0] = loc;
loc = 0;
maxv = 0;
dfs(root[0], -1, 0);
root[1] = loc;
calc(0, root[0], -1);
calc(1, root[1], -1);
build(0, 1, 1, cnt[0]);
build(1, 1, 1, cnt[1]);
q = getint();
for (int i = 1; i <= q; i++) {
int x;
x = getint();
int xx = e[x - 1].first, yy = e[x - 1].second;
if (dep[0][xx] < dep[0][yy])
update(0, 1, 1, cnt[0], l[0][yy], r[0][yy]);
else
update(0, 1, 1, cnt[0], l[0][xx], r[0][xx]);
if (dep[1][xx] < dep[1][yy])
update(1, 1, 1, cnt[1], l[1][yy], r[1][yy]);
else
update(1, 1, 1, cnt[1], l[1][xx], r[1][xx]);
printf("%d\n", max(mx0[0][1], mx0[1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MOD = 998244353;
const long double PI = acosl(-1.0);
const long double E = 1e-15;
mt19937_64 rnd(time(0));
int n, m, k, T, in1[1100001], in2[1100001], out1[1100001], out2[1100001];
pair<int, int> zn[500001];
vector<int> c[500001], z1, z2;
long long binpow(long long h, long long r, long long md) {
long long l = 1;
while (r) {
if (r & 1) l *= h, l %= md;
h *= h;
h %= md;
r /= 2;
}
return l;
}
struct segment_tree {
pair<int, int> d[5000001];
bool leaf[5000001], tt[5000001];
void push(int h) {
if (tt[h] && !leaf[h]) {
tt[h * 2] ^= tt[h];
swap(d[h * 2].first, d[h * 2].second);
tt[h * 2 + 1] ^= tt[h];
swap(d[h * 2 + 1].first, d[h * 2 + 1].second);
}
tt[h] = 0;
}
void build(int h, int l, int r, vector<int>& v) {
if (l == r) {
leaf[h] = 1;
d[h] = make_pair(v[l], 0);
return;
}
int w = (l + r) / 2;
build(h * 2, l, w, v);
build(h * 2 + 1, w + 1, r, v);
d[h].first = max(d[h * 2].first, d[h * 2 + 1].first);
d[h].second = max(d[h * 2].second, d[h * 2 + 1].second);
}
void update(int h, int l, int r, int x, int y) {
if (x > y) return;
push(h);
if (l == x && y == r) {
tt[h] = 1;
swap(d[h].first, d[h].second);
push(h);
return;
}
int w = (l + r) / 2;
update(h * 2, l, w, x, min(y, w));
update(h * 2 + 1, w + 1, r, max(x, w + 1), y);
d[h].first = max(d[h * 2].first, d[h * 2 + 1].first);
d[h].second = max(d[h * 2].second, d[h * 2 + 1].second);
}
};
segment_tree g1, g2;
long long mx, p1, p2;
void dfs(int h, int p = -1) {
pair<int, int> o1 = make_pair(0, h), o2 = make_pair(0, h);
for (int i = 0; i < c[h].size(); i++)
if (c[h][i] != p) {
dfs(c[h][i], h);
if (zn[c[h][i]].first + 1 > o1.first)
swap(o1, o2), o1 = zn[c[h][i]], o1.first++;
else if (zn[c[h][i]].first + 1 > o2.first)
o2 = zn[c[h][i]], o2.first++;
}
if (o1.first + o2.first > mx)
mx = o1.first + o2.first, p1 = o1.second, p2 = o2.second;
zn[h] = o1;
}
void dfs1(int h, int k = 0, int p = -1) {
in1[h] = z1.size();
z1.push_back(k);
for (int i = 0; i < c[h].size(); i++)
if (c[h][i] != p) {
dfs1(c[h][i], k + 1, h);
}
out1[h] = z1.size();
z1.push_back(k);
}
void dfs2(int h, int k = 0, int p = -1) {
in2[h] = z2.size();
z2.push_back(k);
for (int i = 0; i < c[h].size(); i++)
if (c[h][i] != p) {
dfs2(c[h][i], k + 1, h);
}
out2[h] = z2.size();
z2.push_back(k);
}
void solve() {
cin >> n;
long long tt = 0;
vector<pair<int, int> > v, zpr;
for (int i = 1; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
c[x].push_back(y);
c[y].push_back(x);
v.push_back(make_pair(x, y));
if (z) zpr.push_back(make_pair(x, y));
tt = z;
}
if (n == 2) {
long long q;
cin >> q;
for (int i = 0; i < q; i++) {
long long x;
cin >> x;
tt ^= 1;
cout << (tt ? 0 : 1) << "\n";
}
exit(0);
}
dfs(1);
dfs1(p1);
dfs2(p2);
g1.build(1, 0, z1.size() - 1, z1);
g2.build(1, 0, z2.size() - 1, z2);
for (int i = 0; i < zpr.size(); i++) {
int x = zpr[i].first, y = zpr[i].second;
if (in1[x] > in1[y]) swap(x, y);
g1.update(1, 0, z1.size() - 1, in1[y], out1[y]);
if (in2[x] > in2[y]) swap(x, y);
g2.update(1, 0, z2.size() - 1, in2[y], out2[y]);
}
long long q;
cin >> q;
while (q--) {
long long h;
cin >> h;
h--;
int x = v[h].first, y = v[h].second;
if (in1[x] > in1[y]) swap(x, y);
g1.update(1, 0, z1.size() - 1, in1[y], out1[y]);
if (in2[x] > in2[y]) swap(x, y);
g2.update(1, 0, z2.size() - 1, in2[y], out2[y]);
cout << max(g1.d[1].first, g2.d[1].first) << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 500005;
int n, ex[N], ey[N], ez[N];
vector<int> G[N];
int Timest, st[N << 1][20], Log[N << 1], idst[N];
int Timedfn, dfn[N], node[N], tl[N], tr[N], dpt[N], fa[N];
inline int Mn(int x, int y) { return dpt[x] < dpt[y] ? x : y; }
inline int LCA(int x, int y) {
static int t;
x = idst[x], y = idst[y];
if (x > y) swap(x, y);
t = Log[y - x + 1];
return Mn(st[x][t], st[y - (1 << t) + 1][t]);
}
int val[N];
inline void dfs(int x) {
dpt[x] = dpt[fa[x]] + 1;
tl[x] = dfn[x] = ++Timedfn;
st[idst[x] = ++Timest][0] = x;
node[Timedfn] = x;
for (int y, e, i = 0; i < G[x].size(); ++i) {
e = G[x][i];
if ((y = ex[e] + ey[e] - x) ^ fa[x]) {
fa[y] = x;
val[y] = val[x] ^ ez[e];
dfs(y);
st[++Timest][0] = x;
}
}
tr[x] = Timedfn;
}
inline int Dist(int x, int y) {
if (!x || !y) return 0;
return dpt[x] + dpt[y] - (dpt[LCA(x, y)] << 1);
}
struct data {
int x, y, d;
int get() { return d; }
};
data operator+(data A, data B) {
static data Ans;
static int dd;
Ans = A;
if (B.d > A.d) Ans = B;
if (!B.x && !B.y) Ans = A;
if (!A.x && !A.y) Ans = B;
if ((dd = Dist(A.x, B.x)) > Ans.d) Ans.x = A.x, Ans.y = B.x, Ans.d = dd;
if ((dd = Dist(A.x, B.y)) > Ans.d) Ans.x = A.x, Ans.y = B.y, Ans.d = dd;
if ((dd = Dist(A.y, B.x)) > Ans.d) Ans.x = A.y, Ans.y = B.x, Ans.d = dd;
if ((dd = Dist(A.y, B.y)) > Ans.d) Ans.x = A.y, Ans.y = B.y, Ans.d = dd;
return Ans;
}
data f0[N << 2], f1[N << 2];
bool rev[N << 2];
inline void up(int o) {
f1[o] = f1[o << 1] + f1[o << 1 | 1], f0[o] = f0[o << 1] + f0[o << 1 | 1];
}
inline void Build(int o, int l, int r) {
if (l == r) {
if (val[node[l]])
f1[o].x = node[l];
else
f0[o].x = node[l];
return;
}
int mid = l + r >> 1;
Build(o << 1, l, mid), Build(o << 1 | 1, mid + 1, r), up(o);
}
inline void Rev(int o) { rev[o] ^= 1, swap(f0[o], f1[o]); }
inline void down(int o) {
if (rev[o]) rev[o] = 0, Rev(o << 1), Rev(o << 1 | 1);
}
int ll, rr;
inline void Modify(int o, int l, int r) {
if (ll <= l && rr >= r) {
Rev(o);
return;
}
down(o);
int mid = l + r >> 1;
if (ll <= mid) Modify(o << 1, l, mid);
if (rr > mid) Modify(o << 1 | 1, mid + 1, r);
up(o);
}
int main() {
int i, j;
read(n);
for (i = 1; i < n; ++i)
read(ex[i]), read(ey[i]), read(ez[i]), G[ex[i]].push_back(i),
G[ey[i]].push_back(i);
dfs(1);
for (i = 1; i <= Timest; ++i) {
Log[i] = Log[i - 1];
while ((1 << Log[i] + 1) < i) ++Log[i];
}
for (j = 1; j <= Log[Timest]; ++j)
for (i = 1; i + (1 << j) - 1 <= Timest; ++i)
st[i][j] = Mn(st[i][j - 1], st[i + (1 << j - 1)][j - 1]);
Build(1, 1, n);
for (i = 1; i < n; ++i)
if (fa[ey[i]] == ex[i]) swap(ey[i], ex[i]);
int q, z;
read(q);
while (q--) {
read(z), ll = tl[ex[z]], rr = tr[ex[z]], Modify(1, 1, n);
cout << max(f1[1].get(), f0[1].get()) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
namespace atcoder {
namespace internal {
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
int bsf(unsigned int n) { return __builtin_ctz(n); }
} // namespace internal
} // namespace atcoder
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)(), class F, S (*mapping)(F, S),
F (*composition)(F, F), F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++) update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <bool (*g)(S)>
int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; i--) push(l >> i);
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)>
int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G>
int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; i--) push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size) lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
using namespace std;
using namespace atcoder;
using ll = long long;
using P = pair<int, int>;
using VI = vector<int>;
using VVI = vector<VI>;
struct HLD {
std::vector<std::vector<int>>& to;
int root, n;
std::vector<int> sz, parent, depth, idx, ridx, head;
HLD(std::vector<std::vector<int>>& to, int root = 0)
: to(to),
root(root),
n(to.size()),
sz(n),
parent(n),
depth(n),
idx(n),
ridx(n),
head(n) {
init_tree_data(root);
int x = 0;
assign_idx(root, root, x);
}
void init_tree_data(int u, int p = -1, int d = 0) {
parent[u] = p;
depth[u] = d;
int s = 1;
for (int v : to[u]) {
if (v == p) continue;
init_tree_data(v, u, d + 1);
s += sz[v];
}
sz[u] = s;
}
void assign_idx(int u, int h, int& nxt, int p = -1) {
head[u] = h;
idx[u] = nxt++;
if (sz[u] == 1) {
ridx[u] = nxt;
return;
}
int mxsize = 0;
int mi;
for (int v : to[u]) {
if (v == p) continue;
if (sz[v] > mxsize) {
mxsize = sz[v];
mi = v;
}
}
assign_idx(mi, h, nxt, u);
for (int v : to[u]) {
if (v == p || v == mi) continue;
assign_idx(v, v, nxt, u);
}
ridx[u] = nxt;
}
};
struct S {
int even, odd;
};
S op(S x, S y) { return {max(x.even, y.even), max(x.odd, y.odd)}; }
S e() { return {-1, -1}; }
S mapping(bool f, S x) {
if (f)
return {x.odd, x.even};
else
return x;
}
bool composition(bool f, bool g) { return f ^ g; }
bool id() { return false; }
struct E {
int u, v, state;
};
VVI to;
P dfs(int u, int p = -1, int depth = 0) {
P ret = {u, depth};
for (int v : to[u]) {
if (v == p) continue;
P r = dfs(v, u, depth + 1);
if (r.second > ret.second) ret = r;
}
return ret;
}
int main() {
int n;
cin >> n;
to.resize(n);
vector<E> es(n - 1);
for (int i = 0; i < (n - 1); ++i) {
int u, v, t;
cin >> u >> v >> t;
--u, --v;
es[i] = {u, v, t};
to[u].push_back(v);
to[v].push_back(u);
}
int m;
cin >> m;
VI query(m);
for (int i = 0; i < (m); ++i) {
cin >> query[i];
query[i]--;
}
VI ab(2);
ab[0] = dfs(0).first;
ab[1] = dfs(ab[0]).first;
VVI ans(2, VI(m));
for (int tt = 0; tt < (2); ++tt) {
int a = ab[tt];
HLD hld(to, a);
vector<S> init_vec(n);
for (int i = 0; i < (n); ++i) {
init_vec[hld.idx[i]] = {hld.depth[i], -1};
}
lazy_segtree<S, op, e, bool, mapping, composition, id> seg(init_vec);
for (int i = 0; i < (n - 1); ++i) {
int u = es[i].u, v = es[i].v, s = es[i].state;
if (!s) continue;
if (hld.parent[u] == v) swap(u, v);
int vin = hld.idx[v], vout = hld.ridx[v];
seg.apply(vin, vout, true);
}
for (int i = 0; i < (m); ++i) {
int qi = query[i];
int u = es[qi].u, v = es[qi].v;
if (hld.parent[u] == v) swap(u, v);
int vin = hld.idx[v], vout = hld.ridx[v];
seg.apply(vin, vout, true);
ans[tt][i] = seg.all_prod().even;
}
}
for (int i = 0; i < (m); ++i) cout << max(ans[0][i], ans[1][i]) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
int A[500006];
vector<pair<int, int> > G[500006];
pair<int, int> E[500006];
struct sgt {
int L[500006], R[500006], clo, fa[500006];
int dm, rt, dw[500006], dis[500006], bc[500006];
void dfs(int u, int f) {
fa[u] = f;
L[u] = ++clo, bc[clo] = u;
if (dis[u] > dm) dm = dis[u], rt = u;
for (auto [v, w] : ::G[u])
if (v != f) dw[v] = dw[u] ^ w, dis[v] = dis[u] + 1, dfs(v, u);
R[u] = clo;
}
int T[2][500006 << 2], mx[500006 << 2], c[500006 << 2], lc[500006 << 2];
void doit(int rt) {
c[rt] ^= 1, lc[rt] ^= 1;
swap(T[0][rt], T[1][rt]);
}
void pd(int rt) {
if (lc[rt]) {
doit(rt << 1), doit(rt << 1 | 1);
lc[rt] = 0;
}
}
void pu(int rt) {
T[0][rt] = max(T[0][rt << 1], T[0][rt << 1 | 1]);
T[1][rt] = max(T[1][rt << 1], T[1][rt << 1 | 1]);
}
void build(int rt, int l, int r) {
if (l == r) {
T[dw[bc[l]]][rt] = dis[bc[l]];
return;
}
int m = l + r >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
pu(rt);
}
void rever(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) {
doit(rt);
return;
}
pd(rt);
int m = l + r >> 1;
if (L <= m) rever(rt << 1, l, m, L, R);
if (R > m) rever(rt << 1 | 1, m + 1, r, L, R);
pu(rt);
}
void mdf(int u, int v) {
if (fa[v] == u) swap(u, v);
rever(1, 1, n, L[u], R[u]);
}
} T1, T2;
void solve() {
cin >> n;
for (int i = (1), iend = (n - 1); i <= iend; ++i) {
static int u, v, w;
scanf("%d%d%d", &u, &v, &w);
G[u].emplace_back(make_pair(v, w)), G[v].emplace_back(make_pair(u, w));
E[i] = make_pair(u, v);
}
T1.dfs(1, 1);
T1.dm = T1.dw[T1.rt] = T1.dis[T1.rt] = 0;
T1.clo = 0;
T1.dfs(T1.rt, 0);
T1.build(1, 1, n);
T2.dfs(T1.rt, 0);
T2.build(1, 1, n);
cin >> q;
for (int i = (1), iend = (q); i <= iend; ++i) {
static int idx;
scanf("%d", &idx);
T1.mdf(E[idx].first, E[idx].second), T2.mdf(E[idx].first, E[idx].second);
printf("%d\n", max(T1.T[0][1], T2.T[0][1]));
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 99;
int n, m, c, rt, fa, q[N], ans[N], h[N], a[N], s[N], t[N], w[N], edge[N][2];
vector<pair<int, int> > g[N];
int lazy[4 * N];
pair<int, int> seg[4 * N];
void shift(int, int, int);
void build(int id = 1, int L = 1, int R = n + 1) {
if (R <= L) return;
if (L + 1 == R) {
seg[id].second = 0;
seg[id].first = h[a[L]];
if (w[a[L]]) swap(seg[id].first, seg[id].second);
return;
}
int mid = (L + R + 1) >> 1;
build(id * 2 + 0, L, mid);
build(id * 2 + 1, mid, R);
seg[id].first = max(seg[id * 2 + 0].first, seg[id * 2 + 1].first);
seg[id].second = max(seg[id * 2 + 0].second, seg[id * 2 + 1].second);
}
void swich(int id, int L, int R, int l, int r) {
if (R <= l || r <= L) return;
if (l <= L && R <= r) {
lazy[id] ^= 1;
swap(seg[id].first, seg[id].second);
return;
}
int mid = (L + R + 1) >> 1;
shift(id, L, R);
swich(id * 2 + 0, L, mid, l, r);
swich(id * 2 + 1, mid, R, l, r);
seg[id].first = max(seg[id * 2 + 0].first, seg[id * 2 + 1].first);
seg[id].second = max(seg[id * 2 + 0].second, seg[id * 2 + 1].second);
}
void shift(int id, int L, int R) {
int mid = (L + R + 1) >> 1;
if (lazy[id] == 0) return;
swich(id * 2 + 0, L, mid, L, mid);
swich(id * 2 + 1, mid, R, mid, R);
lazy[id] = 0;
}
void dfs1(int x, int dist, int par = 0) {
if (fa < dist) fa = dist, rt = x;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i].first != par) dfs1(g[x][i].first, dist + 1, x);
}
void dfs2(int x, int dist, int par, int second) {
h[x] = dist;
a[++c] = x;
s[x] = c;
for (int i = 0; i < g[x].size(); i++)
if (g[x][i].first != par)
dfs2(g[x][i].first, dist + 1, x, second ^ g[x][i].second);
t[x] = c + 1;
w[x] = second;
}
void solve(int rt) {
for (int i = 0; i < 4 * N; i++) seg[i].first = seg[i].second = lazy[i] = 0;
c = 0;
dfs2(rt, 0, 0, 0);
build();
for (int i = 0; i < m; i++) {
int u;
if (h[edge[q[i]][1]] < h[edge[q[i]][0]])
u = edge[q[i]][0];
else
u = edge[q[i]][1];
swich(1, 1, n + 1, s[u], t[u]);
ans[i] = max(ans[i], seg[1].first);
;
}
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, t;
scanf("%d%d", &u, &v);
;
scanf("%d", &t);
;
edge[i][0] = u;
edge[i][1] = v;
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
}
cin >> m;
for (int i = 0; i < m; i++) cin >> q[i];
fa = 0;
dfs1(1, 0);
solve(rt);
fa = 0;
dfs1(rt, 0);
solve(rt);
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 100;
const int inf = 1e9 + 100;
int dis[maxn];
vector<int> side[maxn], W[maxn];
int dfn[maxn], idx, dep[maxn], sta[maxn], size[maxn];
pair<int, int> ori[maxn];
struct segment_tree {
int mx[2][maxn << 2], tag[maxn << 2];
void clear() {
memset(mx, 0, sizeof(mx));
memset(tag, 0, sizeof(tag));
}
void push_up(int rt) {
mx[0][rt] = max(mx[0][(rt << 1)], mx[0][(rt << 1 | 1)]);
mx[1][rt] = max(mx[1][(rt << 1)], mx[1][(rt << 1 | 1)]);
}
void build(int l, int r, int rt) {
if (l == r) {
mx[sta[l]][rt] = dep[l];
mx[sta[l] ^ 1][rt] = 0;
return;
}
int mid = (l + r) >> 1;
build(l, mid, (rt << 1));
build(mid + 1, r, (rt << 1 | 1));
push_up(rt);
}
void push_down(int rt) {
if (tag[rt]) {
tag[(rt << 1)] ^= 1, tag[(rt << 1 | 1)] ^= 1;
swap(mx[0][(rt << 1)], mx[1][(rt << 1)]);
swap(mx[0][(rt << 1 | 1)], mx[1][(rt << 1 | 1)]);
tag[rt] = 0;
}
}
void upd(int l, int r, int rt, int tl, int tr) {
if (tl <= l && r <= tr) {
tag[rt] ^= 1;
swap(mx[0][rt], mx[1][rt]);
return;
}
push_down(rt);
int mid = (l + r) >> 1;
if (tl <= mid) upd(l, mid, (rt << 1), tl, tr);
if (tr >= mid + 1) upd(mid + 1, r, (rt << 1 | 1), tl, tr);
push_up(rt);
}
} t;
int cg[maxn];
void dfs1(int u, int fa) {
dis[u] = dis[fa] + 1;
for (int i = 0; i < side[u].size(); i++) {
int v = side[u][i];
if (v == fa) continue;
dfs1(v, u);
}
}
void dfs2(int u, int fa, int last) {
dfn[u] = ++idx;
dep[dfn[u]] = dep[dfn[fa]] + 1;
sta[dfn[u]] = sta[dfn[fa]] ^ last;
size[u] = 1;
for (int i = 0; i < side[u].size(); i++) {
int v = side[u][i];
if (v == fa) continue;
dfs2(v, u, W[u][i]);
size[u] += size[v];
}
}
int ans[maxn];
int n, m;
void solve(int rt) {
memset(dfn, 0, sizeof(dfn));
idx = 0;
t.clear();
memset(dep, 0, sizeof(dep));
memset(sta, 0, sizeof(sta));
memset(size, 0, sizeof(size));
dep[0] = -1;
dfs2(rt, 0, 0);
t.build(1, n, 1);
for (int i = (1), iend = (m); i <= iend; i++) {
int u = ori[cg[i]].first, v = ori[cg[i]].second;
if (dep[dfn[u]] < dep[dfn[v]]) swap(u, v);
t.upd(1, n, 1, dfn[u], dfn[u] + size[u] - 1);
ans[i] = max(ans[i], t.mx[0][1]);
}
}
int main() {
scanf("%d", &n);
for (int i = (1), iend = (n - 1); i <= iend; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ori[i] = make_pair(u, v);
side[u].push_back(v);
side[v].push_back(u);
W[u].push_back(w);
W[v].push_back(w);
}
dfs1(1, 0);
int mx = 0, loc = 0, rt1, rt2;
for (int i = (1), iend = (n); i <= iend; i++)
if (dis[i] > mx) mx = dis[i], loc = i;
rt1 = loc;
dfs1(loc, 0);
mx = 0, loc = 0;
for (int i = (1), iend = (n); i <= iend; i++)
if (dis[i] > mx) mx = dis[i], loc = i;
rt2 = loc;
scanf("%d", &m);
for (int i = (1), iend = (m); i <= iend; i++) scanf("%d", &cg[i]);
solve(rt1);
solve(rt2);
for (int i = (1), iend = (m); i <= iend; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 5e5 + 5;
vector<long long> a[maxn];
vector<long long> b[maxn];
long long corn[maxn];
long long corn1[maxn];
bool used[maxn];
long long tin[maxn];
long long tout[maxn];
long long z[maxn];
long long timer = 0;
long long t[4 * maxn][2][2];
long long is[4 * maxn];
void dfs(long long x) {
used[x] = true;
for (auto v : a[x]) {
if (!used[v]) {
corn[v] = corn[x] + 1;
dfs(v);
}
}
used[x] = false;
}
void dfs1(long long x) {
used[x] = true;
for (auto v : a[x]) {
if (!used[v]) {
corn1[v] = corn1[x] + 1;
dfs1(v);
}
}
used[x] = false;
}
void dfs2(long long x) {
tin[x] = timer;
z[timer] = x;
++timer;
used[x] = true;
for (auto v : a[x]) {
if (!used[v]) {
dfs2(v);
}
}
tout[x] = timer;
used[x] = false;
}
void build(long long node, long long tl, long long tr) {
if ((tr - tl) == 1) {
long long x = z[tl];
t[node][0][0] = corn[x];
t[node][0][1] = corn1[x];
t[node][1][0] = (-1e18);
t[node][1][1] = (-1e18);
is[node] = 0;
return;
}
long long tm = (tl + tr) / 2;
build(2 * node + 1, tl, tm);
build(2 * node + 2, tm, tr);
is[node] = 0;
t[node][1][0] = (-1e18);
t[node][1][1] = (-1e18);
t[node][0][0] = max(t[2 * node + 1][0][0], t[2 * node + 2][0][0]);
t[node][0][1] = max(t[2 * node + 1][0][1], t[2 * node + 2][0][1]);
}
vector<vector<long long> > merg(vector<vector<long long> > u,
vector<vector<long long> > v) {
for (long long i = 0; i < 2; ++i) {
for (long long j = 0; j < 2; ++j) {
u[i][j] = max(u[i][j], v[i][j]);
}
}
return u;
}
void push(long long node) {
if (is[node]) {
is[2 * node + 1] ^= 1;
is[2 * node + 2] ^= 1;
is[node] = 0;
swap(t[2 * node + 1][0][0], t[2 * node + 1][1][0]);
swap(t[2 * node + 1][0][1], t[2 * node + 1][1][1]);
swap(t[2 * node + 2][0][0], t[2 * node + 2][1][0]);
swap(t[2 * node + 2][0][1], t[2 * node + 2][1][1]);
for (long long i = 0; i < 2; ++i) {
for (long long j = 0; j < 2; ++j) {
t[node][i][j] = max(t[2 * node + 1][i][j], t[2 * node + 2][i][j]);
}
}
}
}
void to(long long node, long long tl, long long tr, long long l, long long r) {
if (tl >= l && tr <= r) {
is[node] ^= 1;
swap(t[node][0][0], t[node][1][0]);
swap(t[node][0][1], t[node][1][1]);
return;
}
if (tl >= r || tr <= l) {
return;
}
push(node);
long long tm = (tl + tr) / 2;
to(2 * node + 1, tl, tm, l, r);
to(2 * node + 2, tm, tr, l, r);
for (long long i = 0; i < 2; ++i) {
for (long long j = 0; j < 2; ++j) {
t[node][i][j] = max(t[2 * node + 1][i][j], t[2 * node + 2][i][j]);
}
}
}
vector<vector<long long> > get(long long node, long long tl, long long tr,
long long l, long long r) {
if (tr <= l || tl >= r) {
return {{(long long)-1e18, (long long)-1e18},
{(long long)-1e18, (long long)-1e18}};
}
if (tl >= l && tr <= r) {
return {{t[node][0][0], t[node][0][1]}, {t[node][1][0], t[node][1][1]}};
}
push(node);
long long tm = (tl + tr) / 2;
return merg(get(2 * node + 1, tl, tm, l, r), get(2 * node + 2, tm, tr, l, r));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > v;
pair<long long, long long> u[n - 1];
for (long long i = 0; i < (n - 1); ++i) {
long long x, y;
cin >> x >> y;
x--;
y--;
long long w;
cin >> w;
u[i] = {x, y};
if (w == 1) v.push_back({x, y});
b[x].push_back(w);
b[y].push_back(w);
a[x].push_back(y);
a[y].push_back(x);
}
corn[0] = 0;
dfs(0);
long long d1;
long long ma = (-1);
for (long long i = 0; i < n; ++i) {
if (corn[i] >= ma) {
ma = corn[i];
d1 = i;
}
}
corn[d1] = 0;
dfs(d1);
long long d2;
ma = (-1);
for (long long i = 0; i < n; ++i) {
if (corn[i] >= ma) {
ma = corn[i];
d2 = i;
}
}
corn1[d2] = 0;
dfs1(d2);
dfs2(d1);
build(0, 0, n);
long long d2c = 0;
for (auto h : v) {
if (corn[h.first] <= corn[h.second]) {
swap(h.first, h.second);
}
to(0, 0, n, tin[h.first], tout[h.first]);
if (tin[h.first] <= tin[d2] && tout[h.first] >= tout[d2]) {
d2c ^= 1;
}
}
vector<vector<long long> > v1 = get(0, 0, n, 0, n);
long long m;
cin >> m;
while (m--) {
long long x;
cin >> x;
x--;
pair<long long, long long> h = u[x];
if (corn[h.first] <= corn[h.second]) {
swap(h.first, h.second);
}
to(0, 0, n, tin[h.first], tout[h.first]);
if (tin[h.first] <= tin[d2] && tout[h.first] >= tout[d2]) {
d2c ^= 1;
}
vector<vector<long long> > v = get(0, 0, n, 0, n);
cout << max(v[0][0], v[d2c][1]) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 5e5;
int n, m, q[N_MAX], sol[N_MAX], d[N_MAX];
pair<int, int> E[N_MAX];
bool state[N_MAX];
vector<int> G[N_MAX];
bool is_even[N_MAX], to_flip[8 * N_MAX];
int S[2 * N_MAX], s, first[N_MAX], last[N_MAX], even[8 * N_MAX], odd[8 * N_MAX];
void DFS(int u) {
for (int e : G[u]) {
int v = (E[e].first == u ? E[e].second : E[e].first);
if (d[v] == -1) {
d[v] = d[u] + 1;
DFS(v);
}
}
}
void DFS2(int u) {
S[s++] = u;
for (int e : G[u]) {
int v = (E[e].first == u ? E[e].second : E[e].first);
if (d[v] != -1) continue;
d[v] = d[u] + 1;
is_even[v] = is_even[u] ^ state[e];
first[e] = s;
DFS2(v);
last[e] = s - 1;
S[s++] = u;
}
}
void init(int v, int a, int b) {
if (a == b) {
int x = S[a];
if (is_even[x])
even[v] = d[x], odd[v] = 0;
else
even[v] = 0, odd[v] = d[x];
} else {
int k = (a + b) / 2;
init(2 * v, a, k);
init(2 * v + 1, k + 1, b);
even[v] = max(even[2 * v], even[2 * v + 1]);
odd[v] = max(odd[2 * v], odd[2 * v + 1]);
to_flip[v] = false;
}
}
void push(int v, int a, int b) {
if (!to_flip[v]) return;
to_flip[v] = false;
swap(even[2 * v], odd[2 * v]);
to_flip[2 * v] ^= 1;
swap(even[2 * v + 1], odd[2 * v + 1]);
to_flip[2 * v + 1] ^= 1;
}
void flip(int v, int a, int b, int i, int j) {
if (i > j) return;
if (a == i && b == j) {
swap(even[v], odd[v]);
to_flip[v] ^= 1;
return;
}
push(v, a, b);
int k = (a + b) / 2;
flip(2 * v, a, k, i, min(j, k));
flip(2 * v + 1, k + 1, b, max(k + 1, i), j);
even[v] = max(even[2 * v], even[2 * v + 1]);
odd[v] = max(odd[2 * v], odd[2 * v + 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--;
v--;
E[i] = {u, v};
state[i] = t;
G[u].push_back(i);
G[v].push_back(i);
}
cin >> m;
for (int i = 0; i < m; i++) {
int id;
cin >> id;
q[i] = id - 1;
}
for (int i = 0; i < n; i++) d[i] = -1;
d[0] = 0;
DFS(0);
int r1 = 0;
for (int i = 0; i < n; i++)
if (d[i] > d[r1]) r1 = i;
for (int i = 0; i < n; i++) d[i] = -1;
d[r1] = 0;
DFS(r1);
int r2 = 0;
for (int i = 0; i < n; i++)
if (d[i] > d[r2]) r2 = i;
for (int t = 0; t < 2; t++) {
int r = (t == 0 ? r1 : r2);
for (int i = 0; i < n; i++) d[i] = -1, is_even[i] = true;
d[r] = 0;
s = 0;
DFS2(r);
init(1, 0, s - 1);
for (int i = 0; i < m; i++) {
flip(1, 0, s - 1, first[q[i]], last[q[i]]);
sol[i] = max(sol[i], even[1]);
}
}
for (int i = 0; i < m; i++) cout << sol[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
struct IO_Tp {
const static int _I_Buffer_Size = 20 << 20;
char _I_Buffer[_I_Buffer_Size], *_I_pos = _I_Buffer;
const static int _O_Buffer_Size = 20 << 20;
char _O_Buffer[_O_Buffer_Size], *_O_pos = _O_Buffer;
IO_Tp() { fread(_I_Buffer, 1, _I_Buffer_Size, stdin); }
~IO_Tp() { fwrite(_O_Buffer, 1, _O_pos - _O_Buffer, stdout); }
IO_Tp &operator>>(int &res) {
res = 0;
while (!isdigit(*_I_pos)) ++_I_pos;
do res = res * 10 + (*_I_pos++ & 15);
while (isdigit(*_I_pos));
return *this;
}
char getop() {
while (!isdigit(*_I_pos)) ++_I_pos;
return *_I_pos++ & 15;
}
IO_Tp &operator<<(int n) {
static char _buf[10];
char *_pos = _buf;
do *_pos++ = '0' + n % 10;
while (n /= 10);
while (_pos != _buf) *_O_pos++ = *--_pos;
return *this;
}
IO_Tp &operator<<(char ch) {
*_O_pos++ = ch;
return *this;
}
} IO;
struct agg_Tp {
int length, dist[2][2], res[2];
int px;
agg_Tp() {
px = 0;
length = dist[0][0] = dist[1][0] = 0;
dist[0][1] = dist[1][1] = res[0] = res[1] = -(1 << 30);
}
void reverse() {
std::swap(dist[0][0], dist[1][0]), std::swap(dist[0][1], dist[1][1]);
}
agg_Tp &compress(const agg_Tp &a, const agg_Tp &b) {
length = a.length + b.length;
px = a.px ^ b.px;
dist[0][0] = std::max(a.dist[0][0], a.length + b.dist[0][a.px]);
dist[0][1] = std::max(a.dist[0][1], a.length + b.dist[0][!a.px]);
dist[1][0] = std::max(b.dist[1][0], b.length + a.dist[1][b.px]);
dist[1][1] = std::max(b.dist[1][1], b.length + a.dist[1][!b.px]);
res[0] = std::max(
std::max(a.res[0], b.res[0]),
std::max(a.dist[1][0] + b.dist[0][0], a.dist[1][1] + b.dist[0][1]));
res[1] = std::max(
std::max(a.res[1], b.res[1]),
std::max(a.dist[1][0] + b.dist[0][1], a.dist[1][1] + b.dist[0][0]));
return *this;
}
agg_Tp &rake_to_path(const agg_Tp &a, const agg_Tp &b) {
length = b.length;
px = b.px;
dist[0][0] = std::max(a.dist[0][0], b.dist[0][0]);
dist[0][1] = std::max(a.dist[0][1], b.dist[0][1]);
dist[1][0] = std::max(b.dist[1][0], b.length + a.dist[0][b.px]);
dist[1][1] = std::max(b.dist[1][1], b.length + a.dist[0][!b.px]);
res[0] = std::max(
std::max(a.res[0], b.res[0]),
std::max(a.dist[0][0] + b.dist[0][0], a.dist[0][1] + b.dist[0][1]));
res[1] = std::max(
std::max(a.res[1], b.res[1]),
std::max(a.dist[0][0] + b.dist[0][1], a.dist[0][1] + b.dist[0][0]));
return *this;
}
agg_Tp &rake(const agg_Tp &a, const agg_Tp &b) {
dist[0][0] = std::max(a.dist[0][0], b.dist[0][0]);
dist[0][1] = std::max(a.dist[0][1], b.dist[0][1]);
res[0] = std::max(
std::max(a.res[0], b.res[0]),
std::max(a.dist[0][0] + b.dist[0][0], a.dist[0][1] + b.dist[0][1]));
res[1] = std::max(
std::max(a.res[1], b.res[1]),
std::max(a.dist[0][0] + b.dist[0][1], a.dist[0][1] + b.dist[0][0]));
return *this;
}
};
const bool compress = false, rake = true;
struct Splay_Tree {
static Splay_Tree *Null;
void *operator new(size_t size);
void *operator new[](size_t size);
void operator delete(void *ptr);
Splay_Tree *ch[3], *parent;
bool rev;
agg_Tp agg;
Splay_Tree() : rev(false) {
static bool _init = false;
if (!_init) {
_init = true;
Null = new Splay_Tree;
Null->ch[0] = Null->ch[1] = Null->ch[2] = Null->parent = Null;
}
ch[0] = ch[1] = ch[2] = parent = Null;
}
bool is_root() const {
return parent->ch[0] != this && parent->ch[1] != this;
}
template <const bool type>
void pushup();
template <const bool type>
void pushdown();
void reverse() {
rev ^= 1, std::swap(ch[0], ch[1]);
agg.reverse();
}
bool dir() const { return parent->ch[1] == this; }
Splay_Tree *sch(const int d, Splay_Tree *c) {
return ch[d] = c, c->parent = this;
}
template <const bool type>
void rotate() {
Splay_Tree *p = parent;
p->pushdown<type>(), pushdown<type>();
bool d = dir();
if (parent = p->parent, p->parent != Splay_Tree::Null) {
if (p->parent->ch[2] == p)
p->parent->ch[2] = this;
else
p->parent->ch[p->dir()] = this;
}
p->sch(d, ch[!d])->pushup<type>(), sch(!d, p)->pushup<type>();
}
template <const bool type>
Splay_Tree *splay(Splay_Tree *p = Null) {
for (pushdown<type>(); parent != p && !is_root(); rotate<type>())
if (parent->parent != p && !parent->is_root())
parent->parent->pushdown<type>(),
(parent->dir() == dir() ? parent : this)->rotate<type>();
return this;
}
template <const bool type>
Splay_Tree *splay_m(const bool d) {
Splay_Tree *o = this;
while (o->pushdown<type>(), o->ch[d] != Splay_Tree::Null) o = o->ch[d];
return o->splay<type>(parent);
}
};
Splay_Tree *Splay_Tree::Null;
const int Max_N = 500005;
const int _M_size = Max_N * 3;
char _M[_M_size * sizeof(Splay_Tree)], *_M_cur = _M + sizeof(_M);
void *_M_rc[_M_size], **_M_rc_cur = _M_rc;
inline void *Splay_Tree::operator new(size_t size) {
return _M_rc_cur != _M_rc ? *--_M_rc_cur : _M_cur -= size;
}
inline void *Splay_Tree::operator new[](size_t size) { return _M_cur -= size; }
inline void Splay_Tree::operator delete(void *ptr) { *_M_rc_cur++ = ptr; }
template <>
inline void Splay_Tree::pushup<compress>() {
agg.compress(ch[0]->agg, agg_Tp().rake_to_path(ch[2]->agg, ch[1]->agg));
}
template <>
inline void Splay_Tree::pushup<rake>() {
agg.rake(ch[0]->agg, agg_Tp().rake(ch[2]->agg, ch[1]->agg));
}
template <>
inline void Splay_Tree::pushdown<compress>() {
if (rev) ch[0]->reverse(), ch[1]->reverse(), rev = false;
}
template <>
inline void Splay_Tree::pushdown<rake>() {}
void splay_splice(Splay_Tree *o) {
o->splay<rake>();
o = o->parent->splay<compress>();
Splay_Tree *c = o->ch[2];
c->pushdown<rake>();
if (o->ch[1] != Splay_Tree::Null)
std::swap(o->ch[1]->parent, c->ch[2]->parent),
std::swap(o->ch[1], c->ch[2]);
else {
o->sch(1, c->ch[2]);
if (c->ch[0] != Splay_Tree::Null)
c->ch[0]->splay_m<rake>(1), c->ch[0]->sch(1, c->ch[1]),
o->ch[2] = c->ch[0];
else
c->ch[1]->pushdown<rake>(), o->ch[2] = c->ch[1];
delete c, c = o->ch[2], c->parent = o;
}
c->pushup<rake>(), o->pushup<compress>(), o->ch[1]->rotate<compress>();
}
void access(Splay_Tree *o) {
o->splay<compress>();
if (o->ch[1] != Splay_Tree::Null) {
Splay_Tree *c = new Splay_Tree;
c->sch(0, o->ch[2]), c->sch(2, o->ch[1]), c->pushup<rake>();
o->ch[1] = Splay_Tree::Null, o->sch(2, c), o->pushup<compress>();
}
while (o->parent != Splay_Tree::Null) splay_splice(o->parent);
}
inline void evert(Splay_Tree *o) {
access(o), o->reverse(), o->pushdown<compress>();
}
inline void link(Splay_Tree *o1, Splay_Tree *o2, const int c) {
access(o1), evert(o2), o2->pushdown<compress>();
Splay_Tree *e = new Splay_Tree;
e->agg.length = 1, e->agg.px = c;
o2->sch(0, e)->pushup<compress>(), o1->sch(1, o2)->pushup<compress>();
}
int N, M;
int u[Max_N], v[Max_N];
Splay_Tree *node0;
int main(int argc, char **argv) {
IO >> N;
node0 = new Splay_Tree[N + 1];
for (int i = 1; i != N; ++i) {
int c;
IO >> u[i] >> v[i] >> c;
link((node0 + u[i]), (node0 + v[i]), c);
}
IO >> M;
while (M--) {
int e;
IO >> e;
evert((node0 + u[e])), access((node0 + v[e]));
(node0 + v[e])->pushdown<compress>(),
(node0 + v[e])->ch[0]->pushdown<compress>();
(node0 + v[e])->ch[0]->ch[1]->agg.px ^= 1;
(node0 + v[e])->ch[0]->pushup<compress>(),
(node0 + v[e])->pushup<compress>();
IO << (node0 + v[e])->agg.res[0] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, v;
node(int nx = 0, int nv = 0) {
x = nx;
v = nv;
}
};
int n, u, v, t, gl, gr, dp[500005], st[20][1000005], lg[1000005],
tr[2000005][2][2], rev[2000005], ans[2000005][2];
int dep[500005], cnt = 0, tot = 0, dfn[500005], seq[500005], ed[500005],
e[500005][2], m, dm[500005];
vector<node> s[500005];
void dfs(int p, int f) {
node v;
cnt++;
tot++;
dfn[p] = ed[p] = cnt;
dm[p] = tot;
st[0][tot] = dep[p];
seq[cnt] = p;
for (int i = 0; i < s[p].size(); i++) {
v = s[p][i];
if (v.x == f) continue;
dp[v.x] = dp[p] ^ v.v;
dep[v.x] = dep[p] + 1;
dfs(v.x, p);
tot++;
st[0][tot] = dep[p];
}
ed[p] = cnt;
}
int ask(int x, int y) {
int len = y - x + 1;
return min(st[lg[len]][x], st[lg[len]][y - (1 << lg[len]) + 1]);
}
int dist(int x, int y) {
return dep[x] + dep[y] - 2 * ask(min(dm[x], dm[y]), max(dm[x], dm[y]));
}
void upd(int p) {
int u, v, x, y, tmp;
u = p << 1;
v = u + 1;
for (int ty = 0; ty < 2; ty++) {
if (ans[u][ty] > ans[v][ty]) {
ans[p][ty] = ans[u][ty];
tr[p][ty][0] = tr[u][ty][0];
tr[p][ty][1] = tr[u][ty][1];
} else {
ans[p][ty] = ans[v][ty];
tr[p][ty][0] = tr[v][ty][0];
tr[p][ty][1] = tr[v][ty][1];
}
if (ans[u][ty] == -1 || ans[v][ty] == -1) continue;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
x = tr[u][ty][j];
y = tr[v][ty][k];
tmp = dist(x, y);
if (tmp > ans[p][ty]) {
ans[p][ty] = tmp;
tr[p][ty][0] = x;
tr[p][ty][1] = y;
}
}
}
}
}
void act(int p) {
rev[p] ^= 1;
swap(ans[p][0], ans[p][1]);
swap(tr[p][0][0], tr[p][1][0]);
swap(tr[p][0][1], tr[p][1][1]);
}
void push(int p) {
if (!rev[p]) return;
act(2 * p);
act(2 * p + 1);
rev[p] = 0;
}
void build(int p, int l, int r) {
ans[p][0] = ans[p][1] = -1;
if (l == r) {
ans[p][dp[seq[l]]] = 0;
tr[p][dp[seq[l]]][0] = tr[p][dp[seq[l]]][1] = seq[l];
return;
}
int mid = (l + r) / 2;
build(2 * p, l, mid);
build(2 * p + 1, mid + 1, r);
upd(p);
}
void modify(int p, int l, int r) {
if (l > gr || r < gl) return;
if (l >= gl && r <= gr) {
act(p);
return;
}
int mid = (l + r) / 2;
push(p);
modify(2 * p, l, mid);
modify(2 * p + 1, mid + 1, r);
upd(p);
}
int main() {
lg[1] = 0;
for (int i = 2; i <= 1000000; i++) lg[i] = lg[i / 2] + 1;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u, &v, &t);
s[u].push_back(node(v, t));
s[v].push_back(node(u, t));
e[i][0] = u;
e[i][1] = v;
}
dfs(1, 0);
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= tot; j++) {
if (j + (1 << (i - 1)) > tot)
st[i][j] = st[i - 1][j];
else
st[i][j] = min(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
}
}
build(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &u);
u = max(dfn[e[u][0]], dfn[e[u][1]]);
gl = u;
gr = ed[seq[u]];
modify(1, 1, n);
printf("%d\n", max(ans[1][0], ans[1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e5 + 5;
using namespace std;
int rd() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x * f;
}
int n, m, head[maxn], tot, rt, rt1, dep[maxn];
struct node {
int v, nxt, w, id;
} e[maxn << 1];
void add(int u, int v, int w, int id) {
e[++tot] = node{v, head[u], w, id};
head[u] = tot;
}
struct Segmemt_tree {
int mx_0[maxn << 2], mx_1[maxn << 2], in[maxn], out[maxn], cnt,
rev[maxn << 2], to[maxn];
void pushup(int p) {
mx_0[p] = max(mx_0[(p << 1)], mx_0[(p << 1 | 1)]);
mx_1[p] = max(mx_1[(p << 1)], mx_1[(p << 1 | 1)]);
}
void update(int p) {
swap(mx_0[p], mx_1[p]);
rev[p] ^= 1;
}
void pushdown(int p) {
if (!rev[p]) return;
update((p << 1));
update((p << 1 | 1));
rev[p] ^= 1;
}
void modify(int p, int l, int r, int x, int v, int v1) {
if (l == r) {
mx_0[p] = max(mx_0[p], v);
mx_1[p] = max(mx_1[p], v1);
return;
}
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
modify((p << 1), l, mid, x, v, v1);
else
modify((p << 1 | 1), mid + 1, r, x, v, v1);
pushup(p);
}
int query_0(int p, int l, int r, int x) {
if (l == r) return mx_0[p];
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
return query_0((p << 1), l, mid, x);
else
return query_0((p << 1 | 1), mid + 1, r, x);
pushup(p);
}
int query_1(int p, int l, int r, int x) {
if (l == r) return mx_1[p];
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
return query_1((p << 1), l, mid, x);
else
return query_1((p << 1 | 1), mid + 1, r, x);
pushup(p);
}
void cover(int p, int l, int r, int sl, int sr) {
if (sl <= l && r <= sr) {
swap(mx_0[p], mx_1[p]);
rev[p] ^= 1;
return;
}
int mid = (l + r) >> 1;
pushdown(p);
if (sl <= mid) cover((p << 1), l, mid, sl, sr);
if (mid < sr) cover((p << 1 | 1), mid + 1, r, sl, sr);
pushup(p);
}
void Dfs(int u, int y, int val, int dep) {
in[u] = ++cnt;
if (val)
modify(1, 1, n, in[u], 0, dep);
else
modify(1, 1, n, in[u], dep, 0);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == y) continue;
to[e[i].id] = v;
Dfs(v, u, val ^ e[i].w, dep + 1);
}
out[u] = cnt;
}
void Cover(int id) { cover(1, 1, n, in[to[id]], out[to[id]]); }
} T[2];
void dfs(int u, int y, int &root) {
dep[u] = dep[y] + 1;
if (dep[u] > dep[root]) root = u;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == y) continue;
dfs(v, u, root);
}
}
int main() {
n = rd();
for (int i = 1, u, v, w; i < n; i++) {
u = rd();
v = rd();
w = rd();
add(u, v, w, i);
add(v, u, w, i);
}
dfs(1, 0, rt);
dfs(rt, 0, rt1);
T[0].Dfs(rt, 0, 0, 0);
T[1].Dfs(rt1, 0, 0, 0);
m = rd();
for (int id; m; m--) {
id = rd();
T[0].Cover(id);
T[1].Cover(id);
printf("%d\n", max(T[0].mx_0[1], T[1].mx_0[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int h[500005], tot, n, m, d[500005], u[500005], v[500005];
vector<int> e[500005], w;
struct tree {
int rt, sz[500005], dfn[500005], idx, dis[500005], mat[500005], f[500005];
void dfs(int x, int fa) {
sz[x] = 1;
mat[dfn[x] = ++idx] = x;
dis[x] = dis[f[x] = fa] + 1;
for (auto y : e[x])
if (y != fa) dfs(y, x), sz[x] += sz[y];
}
struct node {
int l, r, mx[2], tag;
} a[500005 << 2];
void pushup(int x) { swap(a[x].mx[0], a[x].mx[1]), a[x].tag ^= 1; }
void down(int x) {
if (a[x].tag) pushup((x << 1)), pushup(((x << 1) | 1)), a[x].tag = 0;
}
void build(int x, int l, int r) {
a[x].l = l, a[x].r = r, a[x].tag = 0;
a[x].mx[1] = 0;
if (l == r)
a[x].mx[0] = dis[mat[l]] - 1;
else {
int mid = (l + r) >> 1;
build((x << 1), l, mid);
build(((x << 1) | 1), mid + 1, r);
a[x].mx[0] = max(a[(x << 1)].mx[0], a[((x << 1) | 1)].mx[0]);
}
}
void rev(int x, int l, int r) {
if (a[x].l >= l && a[x].r <= r)
pushup(x);
else {
down(x);
int mid = (a[x].l + a[x].r) >> 1;
if (mid >= l) rev((x << 1), l, r);
if (mid < r) rev(((x << 1) | 1), l, r);
for (int i = 0; i <= 1; i++)
a[x].mx[i] = max(a[(x << 1)].mx[i], a[((x << 1) | 1)].mx[i]);
}
}
void ins(int x, int y) {
if (f[x] != y) swap(x, y);
rev(1, dfn[x], dfn[x] + sz[x] - 1);
}
} s, t;
void calc(int x, int fa) {
d[x] = d[fa] + 1;
for (auto y : e[x])
if (y != fa) calc(y, x);
}
void diameter() {
calc(1, 0);
for (int i = 1; i <= n; i++)
if (d[i] > d[s.rt]) s.rt = i;
calc(s.rt, 0);
for (int i = 1; i <= n; i++)
if (d[i] > d[t.rt]) t.rt = i;
s.dfs(s.rt, 0);
s.build(1, 1, n);
t.dfs(t.rt, 0);
t.build(1, 1, n);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &u[i], &v[i]);
int z;
scanf("%d", &z);
e[u[i]].push_back(v[i]);
e[v[i]].push_back(u[i]);
if (z) w.push_back(i);
}
diameter();
for (auto x : w) s.ins(u[x], v[x]), t.ins(u[x], v[x]);
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
s.ins(u[x], v[x]);
t.ins(u[x], v[x]);
printf("%d\n", max(s.a[1].mx[0], t.a[1].mx[0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, type;
};
struct vertex {
int flag;
int maxh0;
int maxh1;
};
vector<vertex> tree1;
vector<vertex> tree2;
int n;
vector<vector<edge>> start;
vector<int> used;
vector<pair<int, int>> osnov_do1;
vector<pair<int, int>> par1;
vector<pair<int, int>> osnov_do2;
vector<pair<int, int>> par2;
int bfs(int x) {
vector<int> dist(n, 1e9);
dist[x] = 0;
queue<int> q;
q.push(x);
while (q.size()) {
auto f = q.front();
q.pop();
for (auto g : start[f]) {
if (dist[g.to] == 1e9) {
dist[g.to] = dist[f] + 1;
q.push(g.to);
}
}
}
int max_ans = 0;
for (int i = 1; i < n; i++) {
if (dist[i] > dist[max_ans]) {
max_ans = i;
}
}
return max_ans;
}
void propihni(int x, int l, int r, vector<vertex>& tree) {
if (tree[x].flag == 0) {
return;
}
swap(tree[x].maxh0, tree[x].maxh1);
if (r - l > 1) {
tree[2 * x + 1].flag ^= 1;
tree[2 * x + 2].flag ^= 1;
}
tree[x].flag = 0;
}
void builder(int x, int l, int r, vector<pair<int, int>>& osn,
vector<vertex>& tree) {
if (r - l == 1) {
tree[x].flag = 0;
tree[x].maxh0 = -1;
tree[x].maxh1 = -1;
if (osn[l].first == 0) {
tree[x].maxh0 = osn[l].second;
} else {
tree[x].maxh1 = osn[l].second;
}
return;
}
int mid = (r + l) / 2;
builder(2 * x + 1, l, mid, osn, tree);
builder(2 * x + 2, mid, r, osn, tree);
tree[x].maxh0 = max(tree[2 * x + 1].maxh0, tree[2 * x + 2].maxh0);
tree[x].maxh1 = max(tree[2 * x + 1].maxh1, tree[2 * x + 2].maxh1);
}
int get_ans(int x, int l, int r, int L, int R, vector<vertex>& tree) {
propihni(x, l, r, tree);
if (L <= l && r <= R) {
return tree[x].maxh0;
}
if (r <= L || l >= R) return -1;
int mid = (r + l) / 2;
return max(get_ans(2 * x + 1, l, mid, L, R, tree),
get_ans(2 * x + 2, mid, r, L, R, tree));
}
void updater(int x, int l, int r, int L, int R, vector<vertex>& tree) {
if (L <= l && r <= R) {
tree[x].flag ^= 1;
propihni(x, l, r, tree);
return;
}
propihni(x, l, r, tree);
if (r <= L || l >= R) return;
int mid = (r + l) / 2;
updater(2 * x + 1, l, mid, L, R, tree);
updater(2 * x + 2, mid, r, L, R, tree);
tree[x].maxh0 = max(tree[2 * x + 1].maxh0, tree[2 * x + 2].maxh0);
tree[x].maxh1 = max(tree[2 * x + 1].maxh1, tree[2 * x + 2].maxh1);
}
void dfs1(int x, int h, int bln, vector<pair<int, int>>& par,
vector<pair<int, int>>& v) {
used[x] = true;
v.push_back({bln % 2, h});
par[x].first = v.size();
for (auto f : start[x]) {
if (!used[f.to]) {
dfs1(f.to, h + 1, bln + f.type, par, v);
}
}
par[x].second = v.size();
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
start.resize(n);
used.resize(n);
tree1.resize(4 * n);
tree2.resize(4 * n);
vector<pair<int, int>> smena(n);
for (int i = 0; i < n - 1; i++) {
int x, y, z;
cin >> x >> y >> z;
x--;
y--;
start[x].push_back({y, z});
start[y].push_back({x, z});
smena[i] = {x, y};
}
int d1 = bfs(0);
int d2 = bfs(d1);
par1.resize(n);
par2.resize(n);
dfs1(d1, 0, 0, par1, osnov_do1);
for (int i = 0; i < n; i++) used[i] = false;
dfs1(d2, 0, 0, par2, osnov_do2);
builder(0, 0, n, osnov_do1, tree1);
builder(0, 0, n, osnov_do2, tree2);
int kkk = 0;
cin >> kkk;
while (kkk--) {
int x;
cin >> x;
x--;
auto f = smena[x];
if (par1[f.first] < par1[f.second]) {
updater(0, 0, n, par1[f.second].first - 1, par1[f.second].second, tree1);
} else
updater(0, 0, n, par1[f.first].first - 1, par1[f.first].second, tree1);
if (par2[f.first] < par2[f.second]) {
updater(0, 0, n, par2[f.second].first - 1, par2[f.second].second, tree2);
} else
updater(0, 0, n, par2[f.first].first - 1, par2[f.first].second, tree2);
cout << max(get_ans(0, 0, n, 0, n, tree1), get_ans(0, 0, n, 0, n, tree2))
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
struct MI {
private:
char bb[1 << 14];
FILE *f;
char *bs, *be;
char e;
bool o, l;
public:
MI() : f(stdin), bs(0), be(0) {}
inline char get() {
if (o) {
o = 0;
return e;
}
if (bs == be) be = (bs = bb) + fread(bb, 1, sizeof(bb), f);
if (bs == be) {
l = 1;
return -1;
};
return *bs++;
}
inline void unget(char c) {
o = 1;
e = c;
}
template <class T>
inline T read() {
T r;
*this > r;
return r;
}
template <class T>
inline MI &operator>(T &);
};
template <class T>
struct Q {
const static bool U = T(-1) >= T(0);
inline void operator()(MI &t, T &r) const {
r = 0;
char c;
bool y = 0;
if (U)
for (;;) {
c = t.get();
if (c == -1) goto E;
if (isdigit(c)) break;
}
else
for (;;) {
c = t.get();
if (c == -1) goto E;
if (c == '-') {
c = t.get();
if (isdigit(c)) {
y = 1;
break;
};
} else if (isdigit(c))
break;
;
};
for (;;) {
if (c == -1) goto E;
if (isdigit(c))
r = r * 10 + (c ^ 48);
else
break;
c = t.get();
}
t.unget(c);
E:;
if (y) r = -r;
}
};
template <>
struct Q<char> {};
template <class T>
inline MI &MI::operator>(T &t) {
Q<T>()(*this, t);
return *this;
}
template <class T>
std::ostream &operator<(std::ostream &out, const T &t) {
return out << t;
}
using std::cout;
MI cin;
const int $n = 500005;
const int $t = 1048600;
template <typename T>
inline bool gmax(T &a, const T &b) {
return a < b && (a = b, true);
}
int n, fa[$n], mx[$n], se[$n], dep[$n], es[$n][2], t1, t2, dia;
std::vector<std::pair<int, bool>> outs[$n];
bool val[$n];
void dfs(int x) {
mx[x] = x;
dep[x] = dep[fa[x]] + 1;
for (auto [v, w] : outs[x]) {
if (v == fa[x]) continue;
fa[v] = x;
val[v] = val[x] ^ w;
dfs(v);
if (dep[mx[v]] >= dep[mx[x]]) {
se[x] = mx[x];
mx[x] = mx[v];
} else if (dep[mx[v]] > dep[se[x]])
se[x] = mx[v];
}
if (se[x] && gmax(dia, dep[mx[x]] + dep[se[x]] - dep[x] * 2)) {
t1 = mx[x];
t2 = se[x];
}
}
struct {
int rt, fa[$n], dfn[$n], dt, siz[$n], dep[$n], seq[$n];
int mx[$t][2], ll, rr;
bool rv[$t];
inline void upd(int x) {
std::swap(mx[x][0], mx[x][1]);
rv[x] ^= 1;
}
inline void pd(int x) {
if (!rv[x]) return;
upd((x << 1));
upd(((x << 1) | 1));
rv[x] = 0;
}
inline void pu(int x) {
mx[x][0] = std::max(mx[(x << 1)][0], mx[((x << 1) | 1)][0]);
mx[x][1] = std::max(mx[(x << 1)][1], mx[((x << 1) | 1)][1]);
}
void build(int x = 1, int l = 1, int r = n) {
if (l == r) return (void)(mx[x][val[seq[l]]] = dep[seq[l]] - 1);
const int mid = (l + r) >> 1;
build((x << 1), l, mid);
build(((x << 1) | 1), mid + 1, r);
pu(x);
}
void $update(int x, int l, int r) {
if (ll <= l && r <= rr) return upd(x);
const int mid = (l + r) >> 1;
pd(x);
if (ll <= mid) $update((x << 1), l, mid);
if (mid < rr) $update(((x << 1) | 1), mid + 1, r);
pu(x);
}
inline void update(int l, int r) {
ll = l;
rr = r;
$update(1, 1, n);
}
void dfs(int x) {
seq[dfn[x] = ++dt] = x;
siz[x] = 1;
dep[x] = dep[fa[x]] + 1;
for (auto [v, w] : outs[x]) {
if (v == fa[x]) continue;
fa[v] = x;
dfs(v);
siz[x] += siz[v];
}
}
inline void init(int rt) {
this->rt = rt;
dfs(rt);
build();
}
inline int flip(int x, int y) {
if (fa[y] == x) std::swap(x, y);
assert(fa[x] == y);
update(dfn[x], dfn[x] + siz[x] - 1);
return mx[1][val[rt]];
}
} A, B;
int main() {
cin > n;
for (int i = 1; i < n; ++i) {
const int x = es[i][0] = (cin.read<int>()),
y = es[i][1] = (cin.read<int>()), w = (cin.read<int>());
outs[x].emplace_back(y, w);
outs[y].emplace_back(x, w);
}
dfs(1);
A.init(t1);
B.init(t2);
for (int T = (cin.read<int>()); T; --T) {
const int id = (cin.read<int>()), x = es[id][0], y = es[id][1];
cout < std::max(A.flip(x, y), B.flip(x, y)) < ('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
struct Tree {
vector<int> cnt0, cnt1;
struct Node {
int l, r, val0, val1, swap_tag;
} tree[N << 2];
void pushup(int pos) {
tree[pos].val0 = max(tree[pos << 1].val0, tree[pos << 1 | 1].val0);
tree[pos].val1 = max(tree[pos << 1].val1, tree[pos << 1 | 1].val1);
}
void pushdown(int pos) {
if (!tree[pos].swap_tag) return;
tree[pos].swap_tag = 0;
tree[pos << 1].swap_tag ^= 1;
swap(tree[pos << 1].val0, tree[pos << 1].val1);
tree[pos << 1 | 1].swap_tag ^= 1;
swap(tree[pos << 1 | 1].val0, tree[pos << 1 | 1].val1);
}
void build(int pos, int l, int r) {
tree[pos] = {l, r, cnt0[l], cnt1[l], 0};
if (l == r) return;
int mid = l + r >> 1;
build(pos << 1, l, mid);
build(pos << 1 | 1, mid + 1, r);
pushup(pos);
}
void modify(int pos, int l, int r) {
if (l <= tree[pos].l && tree[pos].r <= r) {
tree[pos].swap_tag ^= 1;
swap(tree[pos].val0, tree[pos].val1);
return;
}
pushdown(pos);
int mid = tree[pos].l + tree[pos].r >> 1;
if (l <= mid) modify(pos << 1, l, r);
if (mid < r) modify(pos << 1 | 1, l, r);
pushup(pos);
}
void print(int pos) {
if (tree[pos].l == tree[pos].r) {
cout << tree[pos].l << " " << tree[pos].val0 << " " << tree[pos].val1
<< "\n";
return;
}
print(pos << 1);
print(pos << 1 | 1);
}
} tree[2];
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> op(n);
vector<vector<pair<int, int>>> v(n + 1);
for (int i = 1; i < n; i++) {
int x, y, w;
scanf("%d %d %d", &x, &y, &w);
v[x].emplace_back(y, w);
v[y].emplace_back(x, w);
op[i] = {x, y};
}
function<void(int, int, int, int &, int &)> find_farthest =
[&](int u, int f, int depth, int &ma, int &p) {
if (depth > ma) ma = depth, p = u;
for (auto it : v[u]) {
if (it.first == f) continue;
find_farthest(it.first, u, depth + 1, ma, p);
}
};
int ma = 0, p0 = 0, p1 = 0;
find_farthest(1, 0, 1, ma, p0);
ma = 0;
find_farthest(p0, 0, 1, ma, p1);
int idx = 0;
vector<vector<int>> L(n + 1, vector<int>(2, 0)), R(n + 1, vector<int>(2, 0));
vector<vector<int>> fa(n + 1, vector<int>(2, 0)),
cnt0(n + 1, vector<int>(2, 0)), cnt1(n + 1, vector<int>(2, 0));
function<void(int, int, int, int, int)> dfs = [&](int u, int f, int op,
int val, int depth) {
fa[u][op] = f;
L[u][op] = ++idx;
if (val & 1)
cnt1[u][op] = depth;
else
cnt0[u][op] = depth;
for (auto it : v[u]) {
int x = it.first, w = it.second;
if (x == f) continue;
dfs(x, u, op, val + w, depth + 1);
}
R[u][op] = idx;
};
dfs(p0, 0, 0, 0, 0);
idx = 0;
dfs(p1, 0, 1, 0, 0);
for (int i = 0; i <= 1; i++) {
tree[i].cnt0.assign(n + 1, 0);
tree[i].cnt1.assign(n + 1, 0);
for (int j = 1; j <= n; j++) {
tree[i].cnt0[L[j][i]] = cnt0[j][i];
tree[i].cnt1[L[j][i]] = cnt1[j][i];
}
tree[i].build(1, 1, n);
}
int q;
scanf("%d", &q);
while (q--) {
int id;
scanf("%d", &id);
int x = op[id].first, y = op[id].second;
for (int i = 0; i <= 1; i++) {
if (fa[x][i] != y) swap(x, y);
tree[i].modify(1, L[x][i], R[x][i]);
}
printf("%d\n", max(tree[0].tree[1].val0, tree[1].tree[1].val0));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, m;
vector<pair<int, int> > g[N];
pair<int, int> b[N][2];
int len[N], deep[N], l[N], r[N], cnt, sig[N], l2id[N];
int ans[N];
int edge[N][2], q[N];
struct node {
int v[2];
bool tag;
void clear() {
v[0] = v[1] = 0;
tag = 0;
}
} f[N * 4];
void dfs(int x, int fa) {
for (auto u : g[x])
if (u.first != fa) {
dfs(u.first, x);
if (b[u.first][0].second + 1 >= b[x][0].second) {
b[x][1] = b[x][0];
b[x][0] = {u.first, b[u.first][0].second + 1};
} else {
if (b[u.first][0].second + 1 > b[x][1].second) {
b[x][1] = {u.first, b[u.first][0].second + 1};
}
}
}
}
void dfs(int x, int up, int fa) {
len[x] = max(b[x][0].second, up);
for (auto u : g[x])
if (u.first != fa) {
int up1 = up;
if (u.first != b[x][0].first)
up1 = max(up1, b[x][0].second);
else
up1 = max(up1, b[x][1].second);
dfs(u.first, up1 + 1, x);
}
}
void dfs1(int x, int fa) {
l2id[l[x] = ++cnt] = x;
deep[x]++;
for (auto u : g[x])
if (u.first != fa) {
sig[u.first] = (sig[x] ^ u.second);
deep[u.first] = deep[x];
dfs1(u.first, x);
}
r[x] = cnt;
}
void down(int l, int r, int s) {
if (f[s].tag) {
swap(f[s].v[0], f[s].v[1]);
if (l != r) f[s + s].tag ^= f[s].tag, f[s + s + 1].tag ^= f[s].tag;
f[s].tag = 0;
}
}
void merge(int s) {
f[s].v[0] = max(f[s + s + 1].v[0], f[s + s].v[0]);
f[s].v[1] = max(f[s + s + 1].v[1], f[s + s].v[1]);
}
void build(int l, int r, int s) {
f[s].clear();
if (l == r) {
f[s].v[sig[l2id[l]]] = deep[l2id[l]];
return;
}
build(l, (l + r) / 2, s + s);
build((l + r) / 2 + 1, r, s + s + 1);
merge(s);
}
void change(int l, int r, int s, int ll, int rr) {
down(l, r, s);
if (r < ll || rr < l) return;
if (ll <= l && r <= rr) {
f[s].tag = 1;
down(l, r, s);
return;
}
change(l, (l + r) / 2, s + s, ll, rr);
change((l + r) / 2 + 1, r, s + s + 1, ll, rr);
merge(s);
}
void work(int root) {
cnt = 0;
deep[root] = -1;
sig[root] = 0;
dfs1(root, 0);
build(1, n, 1);
for (int i = 1; i <= m; i++) {
int x;
if (deep[edge[q[i]][0]] > deep[edge[q[i]][1]])
x = edge[q[i]][0];
else
x = edge[q[i]][1];
change(1, n, 1, l[x], r[x]);
ans[i] = max(ans[i], f[1].v[0]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].push_back({y, z});
g[y].push_back({x, z});
edge[i][0] = x, edge[i][1] = y;
}
dfs(1, 0);
dfs(1, 0, 0);
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(len[i], mx);
}
int cnt = 3;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &q[i]);
}
for (int i = 1; i <= n; i++)
if (len[i] == mx) {
if (cnt) {
cnt--;
work(i);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m, id, rt, u[N], v[N], d[N], dis[N];
vector<int> vec[N];
struct tree {
int rt, cnt, head[N], to[N * 2], nxt[N * 2], dd[N * 2];
int idx, fa[N], dep[N], val[N], in[N], out[N], pos[N], tag[N * 4],
maxn[N * 4][2];
void adde(int u, int v, int d) {
to[++cnt] = v;
nxt[cnt] = head[u];
dd[cnt] = d;
head[u] = cnt;
}
void dfs(int u) {
in[u] = ++idx;
pos[idx] = u;
dep[u] = dep[fa[u]] + 1;
int v;
for (int i = head[u]; i; i = nxt[i]) {
v = to[i];
if (v != fa[u]) {
fa[v] = u;
val[v] = val[u] ^ dd[i];
dfs(v);
}
}
out[u] = idx;
}
int merge(int u, int v) { return dep[u] > dep[v] ? u : v; }
void build(int o, int l, int r) {
if (l == r) {
maxn[o][val[pos[l]]] = pos[l];
return;
}
int mid = (l + r) / 2;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
maxn[o][0] = merge(maxn[o * 2][0], maxn[o * 2 + 1][0]);
maxn[o][1] = merge(maxn[o * 2][1], maxn[o * 2 + 1][1]);
}
void reverse(int o) {
tag[o] ^= 1;
swap(maxn[o][0], maxn[o][1]);
}
void pushdown(int o) {
if (tag[o]) {
reverse(o * 2);
reverse(o * 2 + 1);
tag[o] = 0;
}
}
void update(int o, int l, int r, int L, int R) {
if (L <= l && R >= r) {
reverse(o);
return;
}
pushdown(o);
int mid = (l + r) / 2;
if (L <= mid) {
update(o * 2, l, mid, L, R);
}
if (R > mid) {
update(o * 2 + 1, mid + 1, r, L, R);
}
maxn[o][0] = merge(maxn[o * 2][0], maxn[o * 2 + 1][0]);
maxn[o][1] = merge(maxn[o * 2][1], maxn[o * 2 + 1][1]);
}
void build() {
dfs(rt);
build(1, 1, n);
}
void update(int u, int v) {
if (fa[u] == v) {
update(1, 1, n, in[u], out[u]);
} else {
update(1, 1, n, in[v], out[v]);
}
}
int query() { return dep[maxn[1][0]] - 1; }
} t1, t2;
void dfs(int pre, int u) {
dis[u] = dis[pre] + 1;
if (dis[u] > dis[rt]) {
rt = u;
}
for (int v : vec[u]) {
if (v != pre) {
dfs(u, v);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u[i], &v[i], &d[i]);
vec[u[i]].push_back(v[i]);
vec[v[i]].push_back(u[i]);
t1.adde(u[i], v[i], d[i]);
t1.adde(v[i], u[i], d[i]);
t2.adde(u[i], v[i], d[i]);
t2.adde(v[i], u[i], d[i]);
}
dfs(0, rt = 1);
t1.rt = rt;
dfs(0, rt);
t2.rt = rt;
t1.build();
t2.build();
scanf("%d", &m);
while (m--) {
scanf("%d", &id);
t1.update(u[id], v[id]);
t2.update(u[id], v[id]);
printf("%d\n", max(t1.query(), t2.query()));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m;
vector<pair<int, int>> g[N];
int eu[N], ev[N], et[N];
int in[N], out[N], rin[N], dfst;
int val[N], lvl[N];
void dfs(int u, int p) {
in[u] = ++dfst;
rin[in[u]] = u;
for (auto [v, w] : g[u])
if (v != p) {
val[v] = val[u] ^ w;
lvl[v] = lvl[u] + 1;
dfs(v, u);
}
out[u] = dfst;
}
int dist[N];
int bfs(int st) {
for (int i = 1; i <= n; i++) dist[i] = -1;
queue<int> q;
q.push(st);
dist[st] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
if (dist[u] > dist[st]) st = u;
for (auto [v, w] : g[u])
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
return st;
}
int st[4 * N][2];
int lz[4 * N];
void prop(int p, int L, int R) {
if (lz[p]) {
swap(st[p][0], st[p][1]);
if (L < R) {
lz[2 * p] ^= 1;
lz[2 * p + 1] ^= 1;
}
lz[p] = 0;
}
}
void upd(int p, int L, int R, int i, int j) {
prop(p, L, R);
if (i > R or j < L) return;
if (L >= i and R <= j) {
lz[p] = 1;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, j);
upd(2 * p + 1, mid + 1, R, i, j);
st[p][0] = max(st[2 * p][0], st[2 * p + 1][0]);
st[p][1] = max(st[2 * p][1], st[2 * p + 1][1]);
}
void build(int p, int L, int R) {
lz[p] = 0;
if (L == R) {
int u = rin[L];
st[p][1 - val[u]] = 0;
st[p][val[u]] = lvl[u];
return;
}
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
st[p][0] = max(st[2 * p][0], st[2 * p + 1][0]);
st[p][1] = max(st[2 * p][1], st[2 * p + 1][1]);
}
void print(int p, int L, int R) {
prop(p, L, R);
printf("[%d %d] = {%d %d}\n", L, R, st[p][0], st[p][1]);
if (L == R) return;
int mid = (L + R) / 2;
print(2 * p, L, mid);
print(2 * p + 1, mid + 1, R);
}
int mid[N];
int ans[N];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", eu + i, ev + i, et + i);
g[eu[i]].emplace_back(ev[i], et[i]);
g[ev[i]].emplace_back(eu[i], et[i]);
}
int sa = bfs(1);
int sb = bfs(sa);
lvl[sa] = val[sa] = 0;
dfst = 0;
dfs(sa, sa);
build(1, 1, n);
scanf("%d", &m);
for (int j = 0; j < m; j++) {
scanf("%d", mid + j);
int i = mid[j];
int u = lvl[eu[i]] < lvl[ev[i]] ? ev[i] : eu[i];
upd(1, 1, n, in[u], out[u]);
ans[j] = st[1][0];
}
lvl[sb] = val[sb] = 0;
dfst = 0;
dfs(sb, sb);
build(1, 1, n);
for (int j = 0; j < m; j++) {
int i = mid[j];
int u = lvl[eu[i]] < lvl[ev[i]] ? ev[i] : eu[i];
upd(1, 1, n, in[u], out[u]);
printf("%d\n", max(ans[j], st[1][0]));
}
}
|
#include <bits/stdc++.h>
template <typename Tp>
void read(Tp &res) {
static char ch;
ch = getchar(), res = 0;
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) res = res * 10 + ch - 48, ch = getchar();
}
const int MAXN = 5e5 + 19;
int n, q;
struct Edge {
int to, next, id;
} edge[MAXN << 1];
int head[MAXN], cnt;
inline void add(int from, int to, int id) {
edge[++cnt].to = to;
edge[cnt].next = head[from];
edge[cnt].id = id;
head[from] = cnt;
}
int su, rt, dep[MAXN], type[MAXN];
void dfs1(int node, int f) {
dep[node] = dep[f] + 1;
if (dep[node] > dep[rt]) rt = node;
for (int i = head[node]; i; i = edge[i].next)
if (edge[i].to != f) dfs1(edge[i].to, node);
}
int to[MAXN], dfn[MAXN], size[MAXN], id[MAXN], ind;
bool c[MAXN];
void dfs2(int node, int f) {
dep[node] = dep[f] + 1, size[node] = 1, id[dfn[node] = ++ind] = node;
for (int i = head[node]; i; i = edge[i].next)
if (edge[i].to != f)
to[edge[i].id] = edge[i].to, c[edge[i].to] = c[node] ^ type[edge[i].id],
dfs2(edge[i].to, node), size[node] += size[edge[i].to];
}
struct Node {
int max[2];
bool tag;
} tr[MAXN << 2];
inline void push_up(int node) {
for (int i = 0; i < 2; ++i)
tr[node].max[i] = std::max(tr[(node << 1)].max[i ^ tr[node].tag],
tr[(node << 1 | 1)].max[i ^ tr[node].tag]);
}
void build(int node, int L, int R) {
if (L == R) {
tr[node].max[c[id[L]]] = dep[id[L]];
tr[node].max[c[id[L]] ^ 1] = 0;
return;
}
int mid = (L + R) >> 1;
build((node << 1), L, mid), build((node << 1 | 1), mid + 1, R);
tr[node].tag = 0, push_up(node);
}
void modify(int node, int L, int R, int l, int r) {
if (l <= L && R <= r) {
std::swap(tr[node].max[0], tr[node].max[1]);
tr[node].tag ^= 1;
return;
}
int mid = (L + R) >> 1;
if (l <= mid) modify((node << 1), L, mid, l, r);
if (r > mid) modify((node << 1 | 1), mid + 1, R, l, r);
push_up(node);
}
int ans[MAXN], Q[MAXN];
void solve(int root) {
ind = 0, dfs2(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; ++i)
modify(1, 1, n, dfn[to[Q[i]]], dfn[to[Q[i]]] + size[to[Q[i]]] - 1),
ans[i] = std::max(ans[i], tr[1].max[c[root]]);
}
int main() {
read(n);
for (int i = 1; i < n; ++i) {
int u, v;
read(u), read(v), read(type[i]);
add(u, v, i), add(v, u, i);
}
dfs1(1, 0), dfs1(su = rt, 0);
read(q);
for (int i = 1; i <= q; ++i) read(Q[i]);
solve(su), solve(rt);
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i] - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct aaa {
int x, y, op;
} a[500010];
int ans, cnt, n, tx, ty, tot, mx, e[1000010], nt[1000010], hd[1000010],
dep[500010], ru[500010], chu[500010], id[500010], f[2000010][2][2],
val[1000010], d[500010], jl[500010][2], lz[2000010];
void build(int x, int y, int w) {
tot++;
e[tot] = y;
val[tot] = w;
nt[tot] = hd[x];
hd[x] = tot;
}
void get(int x, int fa) {
int i;
dep[x] = dep[fa] + 1;
if (dep[x] > dep[mx]) mx = x;
for (i = hd[x]; i; i = nt[i]) {
if (e[i] == fa) continue;
get(e[i], x);
}
}
void dfs(int x, int fa) {
int i;
ru[x] = ++cnt;
id[cnt] = x;
dep[x] = dep[fa] + 1;
for (i = hd[x]; i; i = nt[i]) {
if (e[i] == fa) continue;
d[e[i]] = d[x] ^ val[i];
dfs(e[i], x);
}
chu[x] = cnt;
}
void pushup(int x) {
int i, j;
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
f[x][i][j] = max(f[x * 2][i][j], f[x * 2 + 1][i][j]);
}
void build1(int x, int l, int r) {
if (l == r) {
if (d[id[l]] == 0) {
f[x][0][0] = jl[id[l]][0];
f[x][1][0] = jl[id[l]][1];
} else {
f[x][0][1] = jl[id[l]][0];
f[x][1][1] = jl[id[l]][1];
}
return;
}
int mid = (l + r) / 2;
build1(x * 2, l, mid);
build1(x * 2 + 1, mid + 1, r);
pushup(x);
}
void pushdown(int x) {
if (lz[x]) {
lz[x * 2] ^= 1;
lz[x * 2 + 1] ^= 1;
lz[x] = 0;
swap(f[x * 2][0][0], f[x * 2][0][1]);
swap(f[x * 2][1][0], f[x * 2][1][1]);
swap(f[x * 2 + 1][0][0], f[x * 2 + 1][0][1]);
swap(f[x * 2 + 1][1][0], f[x * 2 + 1][1][1]);
}
}
void xiu(int x, int l, int r, int t, int k) {
if (l == t && r == k) {
lz[x] ^= 1;
swap(f[x][0][0], f[x][0][1]);
swap(f[x][1][0], f[x][1][1]);
return;
}
pushdown(x);
int mid = (l + r) / 2;
if (mid >= k)
xiu(x * 2, l, mid, t, k);
else if (t > mid)
xiu(x * 2 + 1, mid + 1, r, t, k);
else
xiu(x * 2, l, mid, t, mid), xiu(x * 2 + 1, mid + 1, r, mid + 1, k);
pushup(x);
}
int get(int x, int l, int r, int t) {
if (l == r) {
return d[id[l]] ^ lz[x];
}
pushdown(x);
int mid = (l + r) / 2;
if (mid >= t)
return get(x * 2, l, mid, t);
else
return get(x * 2 + 1, mid + 1, r, t);
}
int main() {
int t1, i, op0, op1;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].op);
build(a[i].x, a[i].y, a[i].op);
build(a[i].y, a[i].x, a[i].op);
}
get(1, 0);
tx = mx;
mx = 0;
get(tx, 0);
for (i = 1; i <= n; i++) jl[i][0] = dep[i] - 1;
ty = mx;
get(ty, 0);
for (i = 1; i <= n; i++) jl[i][1] = dep[i] - 1;
dfs(1, 0);
build1(1, 1, n);
scanf("%d", &t1);
while (t1--) {
scanf("%d", &i);
if (dep[a[i].x] < dep[a[i].y]) swap(a[i].x, a[i].y);
xiu(1, 1, n, ru[a[i].x], chu[a[i].x]);
op0 = get(1, 1, n, ru[tx]);
op1 = get(1, 1, n, ru[ty]);
ans = 0;
if (op0 == 0)
ans = max(ans, f[1][0][0]);
else
ans = max(ans, f[1][0][1]);
if (op1 == 0)
ans = max(ans, f[1][1][0]);
else
ans = max(ans, f[1][1][1]);
printf("%d\n", ans);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.