text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long mod = 998244353;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long binpow(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
struct dsu {
struct op {
int u, l, t;
op() {}
op(int u, int l, int t) : u(u), l(l), t(t) {}
};
vector<int> pai, tam;
stack<op> old_pai;
stack<op> old_tam;
vector<int> g[200200];
dsu() {}
dsu(int n) {
pai.resize(n);
tam = pai;
for (int i = 0; i < n; i++) {
pai[i] = i;
tam[i] = 1;
}
}
vector<int> at, deleted;
void init(vector<int> &v) {
at.resize(v.size() + 1);
deleted.resize(v.size() + 1);
for (int i = 0; i < v.size(); i++) {
g[i].emplace_back(v[i]);
at[v[i]] = i;
}
}
int find(int u) {
if (pai[u] == u) return u;
return find(pai[u]);
}
void merge(int u, int v, int t) {
int a = find(u);
int b = find(v);
if (a == b) return;
if (tam[a] > tam[b]) swap(a, b);
old_pai.emplace(a, pai[a], t);
old_tam.emplace(b, tam[b], t);
pai[a] = b;
tam[b] += tam[a];
for (int &x : g[a]) {
g[b].push_back(x);
at[x] = b;
}
}
void query(int v) {
v = find(v);
int go = 0;
while (!g[v].empty()) {
int u = g[v].back();
g[v].pop_back();
if (u == 0 or at[u] != v or deleted[u])
continue;
else {
go = u;
deleted[u] = 1;
break;
}
}
cout << go << "\n";
}
void rollback(int t) {
while (!old_pai.empty() && old_pai.top().t >= t) {
pai[old_pai.top().u] = old_pai.top().l;
tam[old_tam.top().u] = old_tam.top().l;
for (int &x : g[old_pai.top().l]) {
at[x] = old_pai.top().l;
}
old_pai.pop();
old_tam.pop();
}
}
};
void solve() {
int n, m, q;
cin >> n >> m >> q;
vector<int> p(n), er(m);
{
for (auto &_re : p) cin >> _re;
};
vector<pair<int, int> > e(m);
for (int i = 0; i < m; i++) {
cin >> e[i].first >> e[i].second;
e[i].first--;
e[i].second--;
}
vector<pair<int, int> > qs(q);
for (int i = 0; i < q; i++) {
cin >> qs[i].first >> qs[i].second;
qs[i].second--;
if (qs[i].first == 2) er[qs[i].second] = 1;
}
dsu D(n);
D.init(p);
for (int i = 0; i < m; i++) {
if (er[i]) continue;
D.merge(e[i].first, e[i].second, 0);
}
int t = 1;
for (int i = q - 1; i >= 0; i--) {
if (qs[i].first == 2) {
D.merge(e[qs[i].second].first, e[qs[i].second].second, t++);
}
}
for (int i = 0; i < n; i++) sort(D.g[i].begin(), D.g[i].end());
for (int i = 0; i < q; i++) {
if (qs[i].first == 1) {
D.query(qs[i].second);
} else {
D.rollback(--t);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
void solve();
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int tc = 1;
while (tc--) solve();
return 0;
}
using ll = long long;
using pii = std::pair<int, int>;
using vi = std::vector<int>;
using vii = std::vector<pii>;
using std::cin;
using std::cout;
using std::string;
using std::vector;
const int inf = 0x3f3f3f3f;
const int MOD = 998244853;
const int N = 500000 + 5;
int n, m, q;
pii e[N], que[N], t[N * 2];
vi adj[N];
int tin[N], tout[N], timer;
int par[N], arr[N];
bool del[N];
int get_father(int x) {
if (x != par[x]) par[x] = get_father(par[x]);
return par[x];
}
void dsu_union(int x, int y) {
x = get_father(x);
y = get_father(y);
if (x == y) return;
++n;
par[n] = n;
par[x] = n;
par[y] = n;
adj[n].push_back(x);
adj[n].push_back(y);
}
void dfs(int x) {
tin[x] = ++timer;
for (int y : adj[x]) dfs(y);
tout[x] = timer;
}
pii segMax(int l, int r) {
pii ans(0, 0);
++r;
for (l += timer, r += timer; l < r; l /= 2, r /= 2) {
if (l & 1) ans = std::max(ans, t[l++]);
if (r & 1) ans = std::max(ans, t[--r]);
}
return ans;
}
void updatePos(int x, pii value) {
x += timer;
t[x] = value;
while (x > 1) {
x /= 2;
t[x] = std::max(t[x * 2], t[x * 2 + 1]);
}
}
void solve() {
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
e[i] = pii(u, v);
}
for (int i = 1; i <= q; ++i) {
int a, b;
cin >> a >> b;
que[i] = pii(a, b);
if (a == 2) del[b] = true;
}
for (int i = 1; i <= n; ++i) par[i] = i;
for (int i = 1; i <= m; ++i) {
if (!del[i]) dsu_union(e[i].first, e[i].second);
}
for (int i = q; i >= 1; --i) {
int type = que[i].first;
if (type == 2) {
int id = que[i].second;
dsu_union(e[id].first, e[id].second);
} else {
que[i].second = get_father(que[i].second);
}
}
for (int i = 1; i <= n; ++i) {
if (get_father(i) == i) dfs(i);
}
for (int i = 1; i <= n; ++i) {
updatePos(tin[i], pii(arr[i], tin[i]));
}
for (int i = 1; i <= q; ++i) {
int type = que[i].first;
if (type == 2) continue;
int v = que[i].second;
pii mx = segMax(tin[v], tout[v]);
if (mx.first == 0)
cout << 0 << '\n';
else {
cout << mx.first << '\n';
updatePos(mx.second, pii(0, 0));
}
}
}
|
#include <bits/stdc++.h>
long long int mod = 2000000000 + 7;
long long int inf = (long long int)(1e18);
using namespace std;
mt19937 unlucko(chrono::steady_clock::now().time_since_epoch().count());
set<int, greater<int> > s[int(2e5)];
vector<int> a(int(2e5)), sz(int(2e5)), p(int(2e5));
vector<bool> used(int(3e5), false);
vector<pair<int, int> > e, q;
void fills() {
for (int i = 0; i < int(2e5); i++) sz[i] = 1, p[i] = i;
}
int Link(int a) {
if (a == p[a]) return a;
return p[a] = Link(p[a]);
}
void Unite(int a, int b) {
a = Link(a);
b = Link(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
sz[a] += sz[b];
p[b] = a;
}
int rLink(int a, vector<pair<int, int> > &rp) {
if (a == p[a]) return a;
int ret = rLink(p[a], rp);
rp.push_back({a, p[a]});
return p[a] = ret;
}
void rUnite(int a, int b, vector<pair<int, int> > &rval,
vector<pair<int, int> > &rsz, vector<pair<int, int> > &rp) {
a = rLink(a, rp);
b = rLink(b, rp);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
rsz.push_back({a, sz[a]});
sz[a] += sz[b];
while (!s[b].empty()) {
int x = *s[b].begin();
s[b].erase(s[b].begin());
rval.push_back({b, x});
s[a].insert(x);
}
rp.push_back({b, b});
p[b] = a;
}
void rec(int cur) {
vector<pair<int, int> > rsz, rp, rval;
if (q[cur].first)
rUnite(e[q[cur].second].first, e[q[cur].second].second, rval, rsz, rp);
if (cur) rec(cur - 1);
if (!q[cur].first) {
int x = 0, pr = rLink(q[cur].second, rp);
if (!s[pr].empty()) x = *s[pr].begin();
cout << x << "\n";
if (s[pr].find(x) != s[pr].end()) s[pr].erase(s[pr].find(x));
}
while (!rval.empty()) {
int v = rval.back().first, vl = rval.back().second;
rval.pop_back();
int pr = rLink(v, rp);
if (s[pr].find(vl) != s[pr].end())
s[v].insert(vl), s[pr].erase(s[pr].find(vl));
}
while (!rp.empty()) {
int v = rp.back().first, pr = rp.back().second;
rp.pop_back();
p[v] = pr;
}
while (!rsz.empty()) {
int v = rsz.back().first, zs = rsz.back().second;
rsz.pop_back();
sz[v] = zs;
}
}
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
fills();
int n, m, t;
cin >> n >> m >> t;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
--x;
y--;
e.push_back({x, y});
}
for (int i = 0; i < t; i++) {
int x, y;
cin >> x >> y;
--x;
y--;
q.push_back({x, y});
if (x) used[y] = true;
}
for (int i = 0; i < m; i++) {
if (used[i]) continue;
Unite(e[i].first, e[i].second);
}
for (int i = 0; i < n; i++) {
s[Link(i)].insert(a[i]);
}
rec(t - 1);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
return int(c.size());
}
using ll = long long;
constexpr const char nl = '\n', sp = ' ';
struct StaticGraph {
vector<int> ST, TO, A, B;
StaticGraph(int V) : ST(V + 1, 0) {}
void reserveDiEdges(int maxEdges) {
TO.reserve(maxEdges);
A.reserve(maxEdges);
B.reserve(maxEdges);
}
void addDiEdge(int from, int to) {
ST[from]++;
A.push_back(from);
B.push_back(to);
}
void addBiEdge(int v, int w) {
addDiEdge(v, w);
addDiEdge(w, v);
}
void build() {
partial_sum(ST.begin(), ST.end(), ST.begin());
TO = B;
for (int e = 0; e < int(A.size()); e++) TO[--ST[A[e]]] = B[e];
}
struct Iterator {
const StaticGraph &G;
int i;
Iterator(const StaticGraph &G, int i) : G(G), i(i) {}
Iterator &operator++() {
i++;
return *this;
}
int operator*() const { return G.TO[i]; }
bool operator!=(const Iterator &it) const { return i != it.i; }
};
struct Adj {
const StaticGraph &G;
int v;
Adj(const StaticGraph &G, int v) : G(G), v(v) {}
const Iterator begin() const { return Iterator(G, G.ST[v]); }
const Iterator end() const { return Iterator(G, G.ST[v + 1]); }
};
const Adj operator[](int v) const { return Adj(*this, v); }
int size() const { return int(ST.size()) - 1; }
};
template <class R, const bool VALUES_ON_EDGES>
struct SubtreeQueries {
using Data = typename R::Data;
using Lazy = typename R::Lazy;
int V, ind;
vector<int> pre, post, vert;
R ops;
void updateVertex(int v, const Lazy &val) { ops.update(pre[v], pre[v], val); }
void updateSubtree(int v, const Lazy &val) {
int l = pre[v] + VALUES_ON_EDGES, r = post[v];
if (l <= r) ops.update(l, r, val);
}
Data queryVertex(int v) { return ops.query(pre[v], pre[v]); }
Data querySubtree(int v) {
int l = pre[v] + VALUES_ON_EDGES, r = post[v];
return l <= r ? ops.query(l, r) : R::qdef();
}
template <class Forest>
void dfs(const Forest &G, int v, int prev) {
vert[pre[v] = ++ind] = v;
for (int w : G[v])
if (w != prev) dfs(G, w, v);
post[v] = ind;
}
template <class Forest>
vector<Data> reorder(const Forest &G, const vector<Data> &A,
const vector<int> &roots) {
if (roots.empty()) {
for (int v = 0; v < V; v++)
if (pre[v] == -1) dfs(G, v, -1);
} else
for (int v : roots)
if (pre[v] == -1) dfs(G, v, -1);
vector<Data> ret;
ret.reserve(V);
for (int i = 0; i < V; i++) ret.push_back(A[vert[i]]);
return ret;
}
template <class Forest>
SubtreeQueries(const Forest &G, const vector<Data> &A,
const vector<int> &roots = vector<int>())
: V(G.size()),
ind(-1),
pre(V, -1),
post(V),
vert(V),
ops(reorder(G, A, roots)) {}
template <class Forest>
SubtreeQueries(const Forest &G, const vector<Data> &A, int rt)
: SubtreeQueries(G, A, vector<int>{rt}) {}
};
template <class C>
struct SegmentTreeBottomUp {
using Data = typename C::Data;
using Lazy = typename C::Lazy;
int N;
vector<Data> TR;
template <class F>
SegmentTreeBottomUp(int N, F f) : N(N), TR(N * 2, C::qdef()) {
generate(TR.begin() + N, TR.end(), f);
for (int i = N - 1; i > 0; i--) TR[i] = C::merge(TR[i * 2], TR[i * 2 + 1]);
}
template <class It>
SegmentTreeBottomUp(It st, It en)
: SegmentTreeBottomUp(en - st, [&] { return *st++; }) {}
SegmentTreeBottomUp(int N, const Data &vdef)
: SegmentTreeBottomUp(N, [&] { return vdef; }) {}
void update(int i, const Lazy &v) {
for (i += N, TR[i] = C::applyLazy(TR[i], v); i /= 2;)
TR[i] = C::merge(TR[i * 2], TR[i * 2 + 1]);
}
Data query(int l, int r) {
Data ql = C::qdef(), qr = C::qdef();
for (l += N, r += N; l <= r; l /= 2, r /= 2) {
if (l % 2) ql = C::merge(ql, TR[l++]);
if (!(r % 2)) qr = C::merge(TR[r--], qr);
}
return C::merge(ql, qr);
}
};
struct C {
using Data = pair<int, int>;
using Lazy = int;
static Data qdef() { return make_pair(0, -1); }
static Data merge(const Data &l, const Data &r) { return max(l, r); }
static Data applyLazy(const Data &l, const Lazy &r) {
return make_pair(r, l.second);
}
};
struct R {
using Data = pair<int, int>;
using Lazy = int;
static Data qdef() { return C::qdef(); }
SegmentTreeBottomUp<C> ST;
R(const vector<Data> &A) : ST(A.begin(), A.end()) {}
void update(int l, int r, const Lazy &val) { ST.update(l, val); }
Data query(int l, int r) { return ST.query(l, r); }
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M, Q;
cin >> N >> M >> Q;
vector<pair<int, int>> A(N + N - 1, C::qdef());
for (int i = 0; i < N; i++) {
cin >> A[i].first;
A[i].second = i;
}
vector<pair<int, int>> edges(M);
vector<int> UF(N + N - 1, -1);
function<int(int)> find = [&](int v) {
return UF[v] < 0 ? v : UF[v] = find(UF[v]);
};
for (auto &&e : edges) {
cin >> e.first >> e.second;
--e.first;
--e.second;
}
vector<int> removed(M, false);
vector<pair<int, int>> queries(Q);
for (int i = 0; i < Q; i++) {
cin >> queries[i].first >> queries[i].second;
--queries[i].second;
if (queries[i].first == 2) removed[queries[i].second] = true;
}
StaticGraph G(N + N - 1);
int cur = N;
for (int i = 0; i < M; i++)
if (!removed[i]) {
int v, w;
tie(v, w) = edges[i];
if ((v = find(v)) != (w = find(w))) {
G.addDiEdge(cur, v);
G.addDiEdge(cur, w);
UF[v] = UF[w] = cur;
cur++;
}
}
for (int i = Q - 1; i >= 0; i--) {
if (queries[i].first == 1) {
queries[i].second = find(queries[i].second);
} else {
int v, w;
tie(v, w) = edges[queries[i].second];
if ((v = find(v)) != (w = find(w))) {
G.addDiEdge(cur, v);
G.addDiEdge(cur, w);
UF[v] = UF[w] = cur;
cur++;
}
}
}
G.build();
vector<int> roots;
for (int i = 0; i < N + N - 1; i++)
if (find(i) == i) roots.push_back(i);
SubtreeQueries<R, false> sbtr(G, A, roots);
for (int i = 0; i < Q; i++)
if (queries[i].first == 1) {
pair<int, int> q = sbtr.querySubtree(queries[i].second);
cout << q.first << nl;
sbtr.updateVertex(q.second, 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
pair<int, int> query[500005];
pair<int, int> edge[300005];
pair<int, pair<int, int> > se[300005];
vector<int> vec[200005];
int par[200005];
int vi[200005];
int le[200005];
int ri[200005];
int p[200005];
int sz[200005];
pair<int, int> dq[500005];
int ble[500005], bri[500005];
int find(int x) {
if (par[x] == x) return x;
return find(par[x]);
}
pair<int, int> tree[800005];
int ssz;
void update(int idx, int val) {
idx += ssz;
tree[idx] = {val, idx - ssz};
idx /= 2;
while (idx) {
tree[idx] = max(tree[idx * 2], tree[idx * 2 + 1]);
idx /= 2;
}
}
pair<int, int> qu(int le, int ri) {
pair<int, int> ret = {0, 0};
le += ssz;
ri += ssz;
while (le <= ri) {
if ((le & 1)) ret = max(ret, tree[le++]);
if (!(ri & 1)) ret = max(ret, tree[ri--]);
le /= 2;
ri /= 2;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
ssz = 1;
while (ssz < n) ssz *= 2;
for (int i = 1; i <= n; i++) {
par[i] = i;
vec[i].push_back(i);
scanf("%d", &p[i]);
}
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
edge[i] = {a, b};
se[i] = {0x3f3f3f3f, {a, b}};
}
for (int i = 0; i < q; i++) {
int a, b;
scanf("%d%d", &a, &b);
query[i] = {a, b};
if (a == 2) {
se[b].first = i;
}
}
sort(se + 1, se + 1 + m);
for (int i = m; i >= 1; i--) {
int a, b;
tie(a, b) = se[i].second;
a = find(a);
b = find(b);
if (a == b) continue;
if (vec[a].size() > vec[b].size()) swap(a, b);
par[a] = b;
for (auto x : vec[a]) vec[b].push_back(x);
}
int idx = 0;
for (int i = 1; i <= n; i++) {
if (find(i) == i) {
for (auto x : vec[i]) {
vi[x] = idx++;
}
}
}
for (int i = 1; i <= n; i++) {
par[i] = i;
le[i] = vi[i];
ri[i] = vi[i];
sz[i] = 1;
update(vi[i], p[i]);
}
for (int i = m; i >= 1; i--) {
int a, b;
tie(a, b) = se[i].second;
if (se[i].first != 0x3f3f3f3f) {
dq[se[i].first] = {-1, -1};
}
a = find(a);
b = find(b);
if (a == b) continue;
if (sz[a] > sz[b]) swap(a, b);
if (se[i].first != 0x3f3f3f3f) {
dq[se[i].first] = {a, b};
ble[se[i].first] = le[b];
bri[se[i].first] = ri[b];
}
par[a] = b;
sz[b] += sz[a];
le[b] = min(le[b], le[a]);
ri[b] = max(ri[b], ri[a]);
}
for (int i = 0; i < q; i++) {
int a, b;
tie(a, b) = query[i];
if (a == 1) {
b = find(b);
pair<int, int> ret;
ret = qu(le[b], ri[b]);
printf("%d\n", ret.first);
update(ret.second, 0);
} else {
int x, y;
tie(x, y) = dq[i];
if (x == -1 && y == -1) {
continue;
}
par[x] = x;
sz[y] -= sz[x];
le[y] = ble[i];
ri[y] = bri[i];
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mxn = 3e5 + 1, mxnq = 5e5 + 1;
int arr[mxn], q1[mxnq], q2[mxnq], edgesu[mxn], edgesv[mxn], L1[mxn], L2[mxn],
mark[mxn];
set<pair<int, int>> LOL[mxn];
struct DSU {
int connected;
vector<int> par, sz;
vector<set<pair<int, int>>> s;
void init(int n) {
par = sz = vector<int>(n + 1, 0);
s = vector<set<pair<int, int>>>(n + 1);
for (int i = 1; i <= n; ++i) s[i].insert({arr[i], i});
for (int i = 1; i <= n; i++) {
par[i] = i, sz[i] = 1;
}
connected = n;
}
int getPar(int u) {
if (u != par[u]) return getPar(par[u]);
return u;
}
int getSize(int u) { return sz[getPar(u)]; }
int getAns(int u) {
int par2 = getPar(u);
auto it = *s[par2].rbegin();
s[par2].erase(it);
arr[it.second] = 0;
s[par2].insert({0, it.second});
return it.first;
}
void unite(int u, int v, int val) {
int par1 = getPar(u), par2 = getPar(v);
if (par1 == par2) return;
connected--;
if (sz[par1] > sz[par2]) swap(par1, par2);
for (auto &x : s[par1]) {
s[par2].insert(x);
}
sz[par2] += sz[par1];
par[par1] = par[par2];
if (val) {
mark[val] = 1;
LOL[val] = s[par1];
L1[val] = par1;
L2[val] = par2;
}
}
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) cin >> arr[i];
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= m; ++i) {
cin >> edgesu[i] >> edgesv[i];
}
for (int i = 1; i <= q; ++i) {
cin >> q1[i] >> q2[i];
if (q1[i] == 2) mark[q2[i]] = 1;
}
DSU dsu;
dsu.init(n);
for (int i = 1; i <= m; ++i) {
if (mark[i]) continue;
dsu.unite(edgesu[i], edgesv[i], 0);
}
memset(mark, 0, sizeof(mark));
for (int i = q; i > 0; --i) {
if (q1[i] == 2) dsu.unite(edgesu[q2[i]], edgesv[q2[i]], q2[i]);
}
for (int i = 1; i <= q; ++i) {
if (q1[i] == 1) {
cout << dsu.getAns(q2[i]) << '\n';
;
} else {
if (mark[q2[i]]) {
int I = q2[i];
int val = L2[I];
dsu.s[L1[I]].clear();
for (auto &x : LOL[I]) {
dsu.s[val].erase({arr[x.second], x.second});
dsu.s[L1[I]].insert({arr[x.second], x.second});
}
dsu.par[L1[I]] = L1[I];
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
stack<pair<int, int>> ops;
vector<int> uf, score;
vector<set<pair<int, int>>> comps;
int find(int u) { return uf[u] < 0 ? u : find(uf[u]); }
void merge(int u, int v) {
int pu = find(u), pv = find(v);
if (pu == pv) return;
if (uf[pu] > uf[pv]) swap(pu, pv);
ops.push({pv, uf[pv]});
for (auto &x : comps[pv]) {
comps[pu].insert(x);
}
uf[pu] += uf[pv];
uf[pv] = pu;
}
void rollback() {
pair<int, int> op = ops.top();
ops.pop();
if (op.first == -1) return;
int p = uf[op.first];
uf[p] -= op.second;
uf[op.first] = op.second;
vector<pair<int, int>> items;
for (auto &x : comps[op.first]) {
pair<int, int> v = {score[x.second], x.second};
items.push_back(v);
comps[p].erase(v);
}
comps[op.first].clear();
for (auto &x : items) {
comps[op.first].insert(x);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
score.assign(n, 0);
for (auto &x : score) {
cin >> x;
}
vector<pair<int, int>> edges(m);
for (auto &x : edges) {
cin >> x.first >> x.second;
--x.first, --x.second;
}
vector<bool> erased(m);
vector<pair<int, int>> queries(q);
for (auto &x : queries) {
cin >> x.first >> x.second;
--x.second;
if (x.first == 2) {
erased[x.second] = true;
}
}
cerr << "READING WAS GOOD" << endl;
uf.assign(n, -1);
comps.assign(n, set<pair<int, int>>());
for (int i = 0; i < n; ++i) {
comps[i].insert({score[i], i});
}
for (int i = 0; i < m; ++i) {
pair<int, int> e = edges[i];
if (!erased[i] && find(e.first) != find(e.second)) {
merge(e.first, e.second);
}
}
for (int i = q - 1; i >= 0; --i) {
pair<int, int> x = queries[i];
if (x.first == 2) {
pair<int, int> e = edges[x.second];
if (find(e.first) != find(e.second)) {
merge(e.first, e.second);
} else {
ops.push({-1, -1});
}
}
}
cerr << "MERGING EVERYTHING WAS GOOD TOO" << endl;
for (auto &x : queries) {
if (x.first == 1) {
int p = find(x.second);
pair<int, int> v = *comps[p].rbegin();
cout << v.first << "\n";
score[v.second] = 0;
comps[p].erase(v);
comps[p].insert({0, v.second});
} else {
rollback();
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
vector<int> edges[maxn];
int a[maxn], par[maxn], del[maxn];
int n, m, q;
pair<int, int> E[maxn], Q[maxn];
int get(int x) {
if (par[x] == x)
return x;
else {
return par[x] = get(par[x]);
}
}
void unite(int x, int y) {
x = get(x);
y = get(y);
if (x == y) return;
++n;
par[n] = n;
par[x] = n;
par[y] = n;
edges[n].push_back(x);
edges[n].push_back(y);
}
int st[maxn], ed[maxn], timer = 0, vis[maxn], vert[maxn];
void dfs(int x) {
vis[x] = 1;
st[x] = ++timer;
vert[timer] = x;
for (auto i : edges[x]) {
if (!vis[i]) {
dfs(i);
}
}
ed[x] = timer;
}
pair<int, int> t[maxn << 2];
void build(int node, int b, int e) {
if (b == e) {
t[node] = {a[vert[b]], b};
return;
}
int mid = (b + e) >> 1;
build(2 * node, b, mid);
build(2 * node + 1, mid + 1, e);
t[node] = max(t[2 * node], t[2 * node + 1]);
}
void upd(int node, int b, int e, int idx, int val) {
if (idx > e or idx < b) return;
if (b == idx && e == idx) {
t[node] = {val, -1};
return;
}
int mid = (b + e) >> 1;
upd(2 * node, b, mid, idx, val);
upd(2 * node + 1, mid + 1, e, idx, val);
t[node] = max(t[2 * node], t[2 * node + 1]);
}
pair<int, int> query(int node, int b, int e, int i, int j) {
if (i > e || j < b) return make_pair(0, -1);
if (b >= i && j >= e) return t[node];
int mid = (b + e) >> 1;
return max(query(2 * node, b, mid, i, j),
query(2 * node + 1, mid + 1, e, i, j));
}
int main(int argc, char const *argv[]) {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &E[i].first, &E[i].second);
}
for (int i = 1; i <= n; ++i) {
par[i] = i;
}
for (int i = 1; i <= q; ++i) {
scanf("%d %d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) {
del[Q[i].second] = 1;
}
}
for (int i = 1; i <= m; ++i) {
if (!del[i]) {
unite(E[i].first, E[i].second);
}
}
for (int i = q; i >= 1; --i) {
if (Q[i].first == 1) {
Q[i].second = get(Q[i].second);
} else {
unite(E[Q[i].second].first, E[Q[i].second].second);
}
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
dfs(get(i));
}
}
build(1, 1, n);
for (int i = 1; i <= q; ++i) {
if (Q[i].first == 1) {
pair<int, int> ans = query(1, 1, n, st[Q[i].second], ed[Q[i].second]);
if (ans.first == 0) {
printf("0\n");
} else {
printf("%d\n", ans.first);
upd(1, 1, n, ans.second, 0);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> snm, nodes_rank;
vector<pair<int, int>> tree;
pair<int, int> get_max(int v, int vl, int vr, int l, int r) {
if (l <= vl && r >= vr) return tree[v];
if (l >= vr || r <= vl) return make_pair(-1, -1);
auto mid = (vl + vr) / 2;
auto x1 = get_max(2 * v + 1, vl, mid, l, r);
auto x2 = get_max(2 * v + 2, mid, vr, l, r);
if (x1.first > x2.first) return x1;
return x2;
}
void update(int v, int vl, int vr, int pos, int val) {
if (vl + 1 == vr) {
tree[v].first = val;
tree[v].second = pos;
return;
}
auto mid = (vl + vr) / 2;
if (pos < mid) {
update(2 * v + 1, vl, mid, pos, val);
} else {
update(2 * v + 2, mid, vr, pos, val);
}
auto x1 = tree[2 * v + 1], x2 = tree[2 * v + 2];
if (x1.first > x2.first)
tree[v] = x1;
else
tree[v] = x2;
}
int get_parent(int v) {
if (snm[v] == -1) return v;
snm[v] = get_parent(snm[v]);
return snm[v];
}
int uni(int p1, int p2) {
if (nodes_rank[p1] < nodes_rank[p2]) swap(p1, p2);
snm[p2] = p1;
if (nodes_rank[p1] == nodes_rank[p2]) nodes_rank[p1]++;
return p1;
}
int n;
vector<int> euler_tour;
vector<pair<int, int>> first_last;
vector<bool> dfs_used;
vector<vector<int>> graph;
void dfs(int v) {
if (dfs_used[v]) return;
dfs_used[v] = true;
euler_tour.push_back(v);
first_last[v].first = euler_tour.size() - 1;
first_last[v].second = euler_tour.size() - 1;
for (auto&& to : graph[v]) {
dfs(to);
}
if (v >= n) {
euler_tour.push_back(v);
first_last[v].second = euler_tour.size() - 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int m, q;
cin >> n >> m >> q;
vector<long long> p(n), parent;
graph.resize(n);
nodes_rank.resize(n, 0);
snm.resize(n, -1);
for (int i = 0; i < n; i++) cin >> p[i];
vector<bool> used(m, false);
vector<pair<long long, long long>> edges(m);
for (int i = 0; i < m; i++) {
cin >> edges[i].first >> edges[i].second;
edges[i].first--;
edges[i].second--;
}
vector<pair<int, int>> queries(q);
for (int i = 0; i < q; i++) {
cin >> queries[i].first >> queries[i].second;
queries[i].second--;
if (queries[i].first == 2) used[queries[i].second] = true;
}
for (int i = 0; i < m; i++)
if (!used[i]) queries.push_back(make_pair(2, i));
parent.resize(queries.size(), -1);
for (int i = queries.size() - 1; i >= 0; i--) {
if (queries[i].first == 2) {
auto [from, to] = edges[queries[i].second];
auto pfrom = get_parent(from);
auto pto = get_parent(to);
if (pfrom != pto) {
snm.emplace_back(-1);
nodes_rank.emplace_back(0);
graph.emplace_back();
auto vertex = snm.size() - 1;
snm[uni(pfrom, pto)] = vertex;
graph[pto].push_back(vertex);
graph[vertex].push_back(pto);
graph[pfrom].push_back(vertex);
graph[vertex].push_back(pfrom);
}
} else {
parent[i] = get_parent(queries[i].second);
}
}
dfs_used.resize(snm.size(), false);
first_last.resize(snm.size());
for (int i = 0; i < snm.size(); i++) {
if (!dfs_used[i] && snm[i] == -1) dfs(i);
}
tree.resize(4 * euler_tour.size(), make_pair(-1, -1));
vector<int> cost(euler_tour.size());
for (int i = 0; i < euler_tour.size(); i++) {
if (euler_tour[i] < n) {
cost[i] = p[euler_tour[i]];
} else {
cost[i] = 0;
}
update(0, 0, euler_tour.size(), i, cost[i]);
}
for (int i = 0; i < queries.size(); i++) {
if (queries[i].first == 1) {
auto [second, e] = first_last[parent[i]];
auto x = get_max(0, 0, euler_tour.size(), second, e + 1);
cout << x.first << endl;
update(0, 0, euler_tour.size(), x.second, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v, queries;
vector<int> adj[1000009];
int val[200009];
int neww, tree[4000009], qvalue[1000009], visited[1000009], endd[1000009], k,
p[2000009], n, m, q, present[300009], parent[1000009];
void update(int node, int start, int endd, int ind, int val) {
if (start == endd) {
tree[node] = val;
return;
}
int mid = (start + endd) / 2;
if (ind <= mid)
update(2 * node, start, mid, ind, val);
else {
update(2 * node + 1, mid + 1, endd, ind, val);
}
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int query(int node, int start, int endd, int l, int r) {
if (start > endd || l > r || start > r || endd < l) return 0;
if (start >= l && endd <= r) return tree[node];
int mid = (start + endd) / 2;
return max(query(2 * node, start, mid, l, r),
query(2 * node + 1, mid + 1, endd, l, r));
}
void dfs(int i) {
if (visited[i]) return;
visited[i] = endd[i] = ++neww;
update(1, 1, k, visited[i], p[i]);
for (int j = 0; j < adj[i].size(); j++) {
dfs(adj[i][j]);
endd[i] = max(endd[i], endd[adj[i][j]]);
}
}
int root(int i) {
while (parent[i] != i) {
parent[i] = parent[parent[i]];
i = parent[i];
}
return i;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> p[i];
val[p[i]] = i;
parent[i] = i;
}
for (int i = n + 1; i <= 1000000; i++) parent[i] = i;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v.push_back({x, y});
}
k = n + 1;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
queries.push_back({x, y});
if (x == 2) present[y] = 1;
}
for (int i = 1; i <= m; i++) {
if (present[i] == 0) {
int p1 = root(v[i - 1].first), p2 = root(v[i - 1].second);
if (p1 != p2) {
adj[k].push_back(p1);
adj[k].push_back(p2);
parent[p1] = parent[p2] = k;
k++;
}
}
}
for (int i = q - 1; i >= 0; i--) {
if (queries[i].first == 2) {
int p1 = root(v[queries[i].second - 1].first),
p2 = root(v[queries[i].second - 1].second);
if (p1 != p2) {
adj[k].push_back(p1);
adj[k].push_back(p2);
parent[p1] = parent[p2] = k;
qvalue[i] = k;
k++;
}
} else {
int tt = queries[i].second;
int pita = root(tt);
qvalue[i] = pita;
}
}
for (int i = k - 1; i >= 1; i--) {
if (!visited[i]) dfs(i);
}
for (int i = 0; i < q; i++) {
if (queries[i].first == 1) {
int l = visited[qvalue[i]];
int r = endd[qvalue[i]];
int ans = query(1, 1, k, l, r);
if (ans) {
update(1, 1, k, visited[val[ans]], 0);
}
cout << ans << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T& a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T& a, Args&... args) {
cin >> a;
__read(args...);
}
constexpr long long M7 = 1000000007ll;
constexpr long long M9 = 1000000009ll;
constexpr long long MFFT = 998244353ll;
template <class T>
void outv(T& a) {
for (auto& x : a) cout << x << ' ';
}
static mt19937 rnd(static_cast<unsigned>(
chrono::steady_clock::now().time_since_epoch().count()));
auto __fast_io__ = (ios_base::sync_with_stdio(false), cin.tie(nullptr));
int32_t main() {
long long n, m, q;
__read(n, m, q);
vector<long long> p(n);
for (signed i = 0; i < (n); i++) cin >> p[i];
vector<pair<long long, long long>> e(m);
vector<set<long long>> g(n);
for (auto& [v, u] : e) {
cin >> v >> u;
v--, u--;
g[v].insert(u);
g[u].insert(v);
}
vector<pair<long long, long long>> qr(q);
for (auto& [t, i] : qr) {
cin >> t >> i;
i--;
t--;
if (t) {
auto& [v, u] = e[i];
g[v].erase(u);
g[u].erase(v);
}
}
vector<vector<long long>> comp;
vector<long long> color(n, -1);
function<void(long long)> dfs = [&](long long v) {
color[v] = comp.size() - 1;
comp.back().push_back(v);
for (auto& u : g[v]) {
if (color[u] == -1) {
dfs(u);
}
}
};
for (long long i = 0; i < n; ++i) {
if (color[i] == -1) {
comp.emplace_back();
dfs(i);
}
}
vector<vector<long long>> z(q);
for (long long i = q - 1; i >= 0; --i) {
if (qr[i].first) {
auto [v, u] = e[qr[i].second];
if (color[v] != color[u]) {
if (comp[color[v]].size() > comp[color[u]].size()) {
swap(v, u);
}
z[i] = comp[color[v]];
long long cc = color[v];
for (long long w : comp[cc]) {
color[w] = color[u];
comp[color[u]].push_back(w);
}
comp[cc].clear();
}
g[v].insert(u);
g[u].insert(v);
}
}
vector<priority_queue<pair<long long, long long>>> d;
color.assign(n, -1);
function<void(long long)> dfs2 = [&](long long v) {
color[v] = d.size() - 1;
d.back().emplace(p[v], v);
for (long long u : g[v]) {
if (color[u] == -1) {
dfs2(u);
}
}
};
for (long long v = 0; v < n; ++v) {
if (color[v] == -1) {
d.emplace_back();
dfs2(v);
}
}
for (long long j = 0; j < q; ++j) {
auto& [t, i] = qr[j];
if (t == 0) {
long long ind = color[i];
while (color[d[ind].top().second] != ind) {
d[ind].pop();
}
auto [w, v] = d[ind].top();
cout << w << '\n';
p[v] = 0;
d[ind].pop();
d[ind].emplace(0, v);
} else {
if (!z[j].empty()) {
d.emplace_back();
for (auto v : z[j]) {
color[v] = d.size() - 1;
d.back().emplace(p[v], v);
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5 + 5;
const int MAXM = (int)3e5 + 5;
const int MAXQ = (int)5e5 + 5;
pair<int, int> e[MAXM], que[MAXQ], t[MAXN << 2];
vector<int> adj[MAXN];
int tin[MAXN], tout[MAXN], timer;
int par[MAXN], arr[MAXN];
bool del[MAXM];
int n, m, q;
int getPar(int x) {
if (x == par[x]) {
return x;
}
return par[x] = getPar(par[x]);
}
void uni(int a, int b) {
a = getPar(a);
b = getPar(b);
if (a == b) {
return;
}
++n;
par[n] = n;
par[a] = n;
par[b] = n;
adj[n].push_back(a);
adj[n].push_back(b);
}
void dfs(int v) {
tin[v] = ++timer;
for (int to : adj[v]) {
dfs(to);
}
tout[v] = timer;
}
pair<int, int> segMax(int v, int tl, int tr, int l, int r) {
if (l > r || tl > r || tr < l) {
return make_pair(0, 0);
}
if (l <= tl && tr <= r) {
return t[v];
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
return max(segMax(c1, tl, mid, l, r), segMax(c2, mid + 1, tr, l, r));
}
void updPos(int v, int tl, int tr, int p, pair<int, int> x) {
if (tl == tr) {
t[v] = x;
return;
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
if (p <= mid) {
updPos(c1, tl, mid, p, x);
} else {
updPos(c2, mid + 1, tr, p, x);
}
t[v] = max(t[c1], t[c2]);
}
void solve() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
e[i] = make_pair(u, v);
}
for (int i = 1; i <= q; ++i) {
int a, b;
scanf("%d %d", &a, &b);
que[i] = make_pair(a, b);
if (a == 2) {
del[b] = 1;
}
}
for (int i = 1; i <= n; ++i) {
par[i] = i;
}
for (int i = 1; i <= m; ++i) {
if (!del[i]) {
uni(e[i].first, e[i].second);
}
}
for (int i = q; i > 0; --i) {
int tp = que[i].first;
if (tp == 2) {
int id = que[i].second;
uni(e[id].first, e[id].second);
} else {
que[i].second = getPar(que[i].second);
}
}
for (int i = 1; i <= n; ++i) {
if (getPar(i) == i) {
dfs(i);
}
}
for (int i = 1; i <= n; ++i) {
updPos(1, 1, n, tin[i], make_pair(arr[i], tin[i]));
}
for (int i = 1; i <= q; ++i) {
int tp = que[i].first;
if (tp == 1) {
int v = que[i].second;
pair<int, int> tmp = segMax(1, 1, n, tin[v], tout[v]);
if (tmp.first == 0) {
printf("0\n");
} else {
printf("%d\n", tmp.first);
updPos(1, 1, n, tmp.second, make_pair(0, 0));
}
}
}
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,-ffloat-store")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
const int maxn = 1e5 + 5;
int n, m, q, U[maxn * 3], V[maxn * 3], p[maxn << 1];
int tr[maxn * 5], X[maxn * 5];
int sz[maxn << 1], par[maxn << 1], id[maxn << 1];
bool vis[maxn * 5], oke[maxn * 3];
set<int, greater<int> > mys[maxn << 1];
stack<pair<int, int> > st;
vector<int> del;
void readf() {
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
id[p[i]] = i;
}
for (int i = 1; i <= m; ++i) cin >> U[i] >> V[i];
for (int i = 1; i <= q; ++i) {
cin >> tr[i] >> X[i];
if (tr[i] == 2) {
oke[X[i]] = 1;
del.emplace_back(X[i]);
}
}
}
inline int root(int u) {
while (u != par[u]) u = par[u];
return u;
}
void join(int i, int u, int v) {
u = root(u);
v = root(v);
if (u == v) return;
vis[i] = 1;
if (sz[u] < sz[v]) swap(u, v);
for (auto it : mys[v]) mys[u].insert(it);
if (oke[i] == 1) {
st.push(pair<int, int>(u, sz[u]));
st.push(pair<int, int>(v, par[v]));
}
sz[u] += sz[v];
par[v] = u;
}
void roll(int i) {
if (vis[i] == 0) return;
pair<int, int> it = st.top();
st.pop();
int v = it.first;
par[v] = it.second;
it = st.top();
st.pop();
int u = it.first;
sz[u] = it.second;
for (auto it : mys[v]) mys[u].erase(it);
}
void solve() {
for (int i = 1; i <= n; ++i) par[i] = i, sz[i] = 1, mys[i].insert(p[i]);
for (int i = 1; i <= m; ++i)
if (oke[i] == 0) {
join(i, U[i], V[i]);
}
reverse(del.begin(), del.end());
for (int i : del) {
join(i, U[i], V[i]);
}
for (int i = 1; i <= q; ++i)
if (tr[i] == 1) {
int u = root(X[i]);
if (mys[u].size() == 0) {
cout << "0\n";
continue;
} else {
int tmp = (*mys[u].begin());
cout << tmp << '\n';
u = id[tmp];
mys[u].erase(tmp);
while (u != par[u]) {
u = par[u];
mys[u].erase(tmp);
}
}
} else
roll(X[i]);
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
struct NodeP {
int val;
NodeP *left, *right;
NodeP() {}
NodeP(int v) { val = v; }
};
struct Range {
int L, R;
Range() {}
Range(int a, int b) {
L = a;
R = b;
}
bool operator<(const Range& r) const { return R < r.R; }
};
struct Event {
bool isValid = false;
Range original, split1, split2;
Event() {}
Event(Range a, Range b, Range c) {
isValid = true;
original = a;
split1 = b, split2 = c;
}
};
struct ST {
struct Node {
int L, R;
pair<int, int> maxVal;
Node() {}
Node(int a, int b) {
L = a;
R = b;
maxVal = {0, L};
}
};
vector<Node> st;
ST(int n) {
st.resize(4 * n + 10, Node());
init(1, 0, n - 1);
}
void init(int p, int a, int b) {
st[p] = Node(a, b);
if (a == b) return;
int mid = (a + b) / 2;
init(2 * p, a, mid);
init(2 * p + 1, mid + 1, b);
}
void pointUpdate(int p, int pos, long long int val) {
Node& now = st[p];
if (pos < now.L || now.R < pos) return;
if (pos <= now.L && now.R <= pos) {
st[p].maxVal.first = val;
return;
}
pointUpdate(2 * p, pos, val);
pointUpdate(2 * p + 1, pos, val);
update(p);
}
pair<int, int> rangeMax(int p, int a, int b) {
Node& now = st[p];
if (b < now.L || now.R < a) return {-oo, -1};
if (a <= now.L && now.R <= b) {
return st[p].maxVal;
}
auto ret1 = rangeMax(2 * p, a, b);
auto ret2 = rangeMax(2 * p + 1, a, b);
update(p);
return max(ret1, ret2);
}
void update(int p) {
Node& now = st[p];
now.maxVal = max(st[2 * p].maxVal, st[2 * p + 1].maxVal);
}
};
vector<int> lefts, rights, leftHead, rightHead;
vector<int> par;
int find(int i) {
if (par[i] == i) return i;
return par[i] = find(par[i]);
}
bool merge(int u, int v) {
u = find(u), v = find(v);
if (u == v) return false;
par[v] = u;
int rHead = rightHead[u], lHead = leftHead[v];
rights[rHead] = lHead;
lefts[lHead] = rHead;
rightHead[u] = rightHead[v];
return true;
}
void sol() {
int n, m, q;
cin >> n >> m >> q;
vector<int> vals(n);
for (int& x : vals) cin >> x;
vector<pair<int, int>> queries(q), edges(m);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
edges[i] = {x, y};
}
vector<bool> edgesRem(m);
for (int i = 0; i < q; i++) {
int type, node;
cin >> type >> node;
node--;
queries[i] = {type, node};
if (type == 2) edgesRem[node] = true;
}
for (int i = 0; i < m; i++)
if (!edgesRem[i]) {
queries.push_back({2, i});
}
par = vector<int>(n);
lefts = rights = leftHead = rightHead = vector<int>(n);
auto clearDSU = [&] {
for (int i = 0; i < n; i++) {
par[i] = i;
leftHead[i] = rightHead[i] = i;
lefts[i] = rights[i] = i;
}
};
clearDSU();
for (int i = (int)queries.size() - 1; i >= 0; i--) {
auto now = queries[i];
if (now.first != 2) continue;
auto edge = edges[now.second];
merge(edge.first, edge.second);
}
vector<int> arr(n);
int ptr = 0;
set<Range> curRanges;
for (int i = 0; i < n; i++)
if (find(i) == i) {
int now = lefts[i];
int oPtr = ptr;
while (true) {
arr[ptr++] = now;
if (rights[now] == now) break;
now = rights[now];
}
curRanges.insert(Range(oPtr, ptr - 1));
}
vector<int> pos(n);
for (int i = 0; i < n; i++) pos[arr[i]] = i;
auto makeRange = [&](int u) {
int L = leftHead[u], R = rightHead[u];
if (pos[L] > pos[R]) swap(L, R);
return Range(pos[L], pos[R]);
};
clearDSU();
vector<Event> events((int)queries.size());
for (int i = (int)queries.size() - 1; i >= 0; i--) {
auto now = queries[i];
if (now.first != 2) continue;
auto edge = edges[now.second];
int u = find(edge.first), v = find(edge.second);
if (u != v) {
par[v] = u;
int rHead = rightHead[u], lHead = leftHead[v];
Range old1 = makeRange(u), old2 = makeRange(v);
rights[rHead] = lHead;
lefts[lHead] = rHead;
rightHead[u] = rightHead[v];
Range new1 = makeRange(u);
events[i] = Event(new1, old1, old2);
}
}
ST st = ST(n);
for (int i = 0; i < n; i++) {
st.pointUpdate(1, pos[i], vals[i]);
}
for (int i = 0; i < q; i++) {
auto now = queries[i];
if (now.first == 1) {
int spot = pos[now.second];
auto who = curRanges.lower_bound(Range(spot, spot));
auto range = *who;
auto ans = st.rangeMax(1, range.L, range.R);
cout << ans.first << '\n';
st.pointUpdate(1, ans.second, 0);
} else {
if (events[i].isValid) {
curRanges.erase(events[i].original);
curRanges.insert(events[i].split1);
curRanges.insert(events[i].split2);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10, MAXM = 3e5 + 10, MAXQ = 5e5 + 10;
int n, m, q, c[MAXN], st[MAXN], fn[MAXN], S[MAXQ], E[MAXQ], ind[MAXN], p[MAXN];
pair<int, int> edg[MAXM], Q[MAXQ];
vector<int> comp[MAXN], res;
bool en[MAXM];
struct node {
int mx, l, r;
};
node vs[MAXN * 4];
void upd(int v) {
if (vs[2 * v + 1].r == 0 || p[vs[2 * v].mx] > p[vs[2 * v + 1].mx])
vs[v].mx = vs[2 * v].mx;
else
vs[v].mx = vs[2 * v + 1].mx;
}
void make(int v, int l, int r) {
vs[v].l = l, vs[v].r = r;
if (r - l == 1) {
vs[v].mx = res[l];
return;
}
int mid = (l + r) / 2;
make(2 * v, l, mid);
make(2 * v + 1, mid, r);
upd(v);
}
int getmx(int v, int ql, int qr) {
if (vs[v].r <= ql || qr <= vs[v].l) return res[ql];
if (ql <= vs[v].l && vs[v].r <= qr) return vs[v].mx;
int a = getmx(2 * v, ql, qr);
int b = getmx(2 * v + 1, ql, qr);
if (p[a] > p[b])
return a;
else
return b;
}
void chg(int v, int qi) {
if (qi < vs[v].l || vs[v].r <= qi) return;
if (qi == vs[v].l && vs[v].r - vs[v].l == 1) return;
chg(2 * v, qi);
chg(2 * v + 1, qi);
upd(v);
}
void merge(int a, int b) {
if (comp[a].size() < comp[b].size()) swap(a, b);
if (a == b) return;
fn[a] = fn[b];
for (int i = 0; i < comp[b].size(); i++)
comp[a].push_back(comp[b][i]), c[comp[b][i]] = a;
comp[b].clear();
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
cin >> p[i], c[i] = i, comp[i].push_back(i), st[i] = i, fn[i] = i;
for (int i = 0; i < m; i++) cin >> edg[i].first >> edg[i].second;
for (int i = 0; i < q; i++) {
cin >> Q[i].first >> Q[i].second;
if (Q[i].first == 2) {
Q[i].second--;
en[Q[i].second] = true;
}
}
for (int i = 0; i < m; i++)
if (!en[i]) merge(c[edg[i].first], c[edg[i].second]);
for (int i = q - 1; i >= 0; i--)
if (Q[i].first == 2)
merge(c[edg[Q[i].second].first], c[edg[Q[i].second].second]);
else
S[i] = st[c[Q[i].second]], E[i] = fn[c[Q[i].second]];
for (int i = 1; i <= n; i++)
for (int j = 0; j < comp[i].size(); j++) res.push_back(comp[i][j]);
for (int i = 0; i < n; i++) ind[res[i]] = i;
make(1, 0, n);
for (int i = 0; i < q; i++)
if (Q[i].first == 1) {
int t = getmx(1, ind[S[i]], ind[E[i]] + 1);
cout << p[t] << '\n';
p[t] = 0;
chg(1, ind[t]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct dsu {
vector<int> id;
vector<int> last;
dsu(int n) {
id = vector<int>(n);
iota(id.begin(), id.end(), 0);
last = vector<int>(n);
iota(last.begin(), last.end(), 0);
}
int find(int a) {
while (id[a] != a) {
id[a] = id[id[a]];
a = id[a];
}
return a;
}
bool unite(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return false;
last[a] = last[b];
id[b] = a;
return true;
}
};
class segtree {
private:
struct node {
int mx = 0;
int mx_ind = -1;
void assign(int ind, int v) {
mx = v;
mx_ind = ind;
}
void merge(node &a, node &b) {
if (a.mx >= b.mx) {
mx_ind = a.mx_ind;
} else {
mx_ind = b.mx_ind;
}
mx = max(a.mx, b.mx);
}
};
int b;
node *tree;
public:
const int n;
segtree(int _n) : n(_n) {
assert(_n > 0);
for (b = 1; b < n; b <<= 1)
;
tree = new node[b << 1];
}
template <typename... M>
void update(int ind, const M &...v) {
tree[b + ind].assign(ind, v...);
for (int i = (b + ind) / 2; i > 0; i >>= 1) {
tree[i].merge(tree[i * 2], tree[i * 2 + 1]);
}
}
node get(int l, int r) const {
assert(0 <= l && l <= r && r < n);
l += b;
r += b;
if (l == r) {
return tree[l];
}
node left = tree[l];
node right = tree[r];
while (l + 1 < r) {
if (l % 2 == 0) {
left.merge(left, tree[l + 1]);
}
if (r % 2) {
right.merge(tree[r - 1], right);
}
l /= 2;
r /= 2;
}
node answer;
answer.merge(left, right);
return answer;
}
};
void foo() {
int n, m, q;
cin >> n >> m >> q;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
vector<pair<int, int>> edges;
set<int> es;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
edges.push_back({x, y});
es.insert(i);
}
struct query {
int type;
int x;
};
vector<query> queries;
for (int i = 0; i < q; i++) {
int type, x;
cin >> type >> x;
x--;
queries.push_back({type, x});
if (type == 2) {
auto it = es.find(x);
assert(it != es.end());
es.erase(it);
}
}
for (int ed : es) {
queries.push_back({2, ed});
}
q = queries.size();
reverse(queries.begin(), queries.end());
dsu g(n);
vector<pair<int, int>> info;
vector<int> par(n, -1);
for (int i = 0; i < q; i++) {
const query &qr = queries[i];
if (qr.type == 1) {
int rt = g.find(qr.x);
info.push_back({rt, g.last[rt]});
} else {
assert(qr.type == 2);
const pair<int, int> &e = edges[qr.x];
int v = e.first, u = e.second;
v = g.find(v);
u = g.find(u);
assert(par[v] == -1);
assert(par[u] == -1);
if (v == u) continue;
par[u] = g.last[v];
g.unite(v, u);
}
}
reverse(info.begin(), info.end());
vector<int> nxt(n, -1);
for (int i = 0; i < n; i++) {
if (par[i] != -1) {
nxt[par[i]] = i;
}
}
vector<int> roots;
for (int i = 0; i < n; i++) {
if (par[i] == -1) {
roots.push_back(i);
}
}
vector<int> order(n);
int next = -1;
vector<int> pos(n, -1);
for (int i = 0; i < n; i++) {
if (next == -1) {
order[i] = roots.back();
roots.pop_back();
} else {
order[i] = next;
}
next = nxt[order[i]];
pos[order[i]] = i;
}
segtree st(n);
for (int i = 0; i < n; i++) {
st.update(i, p[order[i]]);
}
for (auto &pr : info) {
int index = st.get(pos[pr.first], pos[pr.second]).mx_ind;
cout << p[order[index]] << endl;
st.update(index, 0);
p[order[index]] = 0;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
foo();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e5 + 9;
const int MAX2 = 2e5 + 9;
int n, p[MAX2], idx[MAX2], node[(int)5e5 + 9];
vector<int> adj[MAX];
pair<int, int> qu[(int)5e5 + 9], edges[(int)3e5 + 9];
bool vis[(int)3e5 + 9];
int par[MAX];
int dfsCnt, euler[MAX], rangeStart[MAX], rangeEnd[MAX];
int tree[(MAX << 2)];
int N;
int FindSet(int node) {
if (par[node] == node) {
return node;
}
return par[node] = FindSet(par[node]);
}
void MergeNodes(int u, int v) {
int parU = FindSet(u), parV = FindSet(v);
if (parU == parV) {
return;
}
++n;
adj[n].push_back(parU);
adj[n].push_back(parV);
par[parU] = par[parV] = n;
}
void Initialize() {
for (int i = 1; i < MAX; ++i) {
par[i] = i;
}
}
void DFS(int cur, int parent = -1) {
++dfsCnt;
(cur <= N ? euler[dfsCnt] = p[cur] : euler[dfsCnt] = 0);
rangeStart[cur] = dfsCnt;
for (int i = 0; i < adj[cur].size(); ++i) {
int child = adj[cur][i];
if (child != parent) {
DFS(child, cur);
}
}
rangeEnd[cur] = dfsCnt;
}
void Build(int low, int high, int pos) {
if (low == high) {
tree[pos] = euler[low];
return;
}
int mid = ((low + high) >> 1);
Build(low, mid, (pos << 1));
Build(mid + 1, high, (pos << 1 | 1));
tree[pos] = max(tree[(pos << 1)], tree[(pos << 1 | 1)]);
}
int Query(int low, int high, int pos, int L, int R) {
if (L > high || R < low) {
return 0;
}
if (L <= low && R >= high) {
return tree[pos];
}
int mid = ((low + high) >> 1);
return max(Query(low, mid, (pos << 1), L, R),
Query(mid + 1, high, (pos << 1 | 1), L, R));
}
void Update(int low, int high, int pos, int index) {
if (low == high) {
tree[pos] = 0;
return;
}
int mid = ((low + high) >> 1);
if (index <= mid)
Update(low, mid, (pos << 1), index);
else
Update(mid + 1, high, (pos << 1 | 1), index);
tree[pos] = max(tree[(pos << 1)], tree[(pos << 1 | 1)]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m, q;
cin >> n >> m >> q;
N = n;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
idx[p[i]] = i;
}
for (int i = 1; i <= m; ++i) {
cin >> edges[i].first >> edges[i].second;
}
for (int i = 1; i <= q; ++i) {
cin >> qu[i].first >> qu[i].second;
if (qu[i].first == 2) {
vis[qu[i].second] = 1;
}
}
Initialize();
for (int i = 1; i <= m; ++i) {
if (!vis[i]) {
MergeNodes(edges[i].first, edges[i].second);
}
}
for (int i = q; i >= 1; --i) {
if (qu[i].first == 1) {
node[i] = FindSet(qu[i].second);
} else {
MergeNodes(edges[qu[i].second].first, edges[qu[i].second].second);
}
}
vector<int> roots;
for (int i = 1; i <= n; ++i) {
roots.push_back(FindSet(i));
}
sort(roots.begin(), roots.end());
roots.erase(unique(roots.begin(), roots.end()), roots.end());
for (int i = 0; i < roots.size(); ++i) {
DFS(roots[i]);
}
Build(1, dfsCnt, 1);
for (int i = 1; i <= q; ++i) {
if (qu[i].first == 1) {
int ans = Query(1, dfsCnt, 1, rangeStart[node[i]], rangeEnd[node[i]]);
cout << ans << "\n";
if (ans) {
Update(1, dfsCnt, 1, rangeStart[idx[ans]]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
template <class T>
inline void rd(T &x) {
char c = getchar(), f = 0;
x = 0;
while (!isdigit(c)) f = (c == '-'), c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
x = f ? -x : x;
}
const int MAXN = 1e6 + 7;
int fa[MAXN], dfn[MAXN], sz[MAXN], f[MAXN][22], ans[MAXN], pos[MAXN];
std::vector<int> son[MAXN];
int p[MAXN], n, m, tim[MAXN], q, seq[MAXN], wei[MAXN], tot;
std::pair<int, int> E[MAXN], Q[MAXN];
int cmax(int x, int y) {
return p[x] == p[y] ? (x < y ? x : y) : (p[x] > p[y] ? x : y);
}
struct Node {
int l, r;
Node *lc, *rc;
int max;
Node() {}
Node(int l, int r, Node *lc, Node *rc) : l(l), r(r), lc(lc), rc(rc) {}
static Node *build(int l, int r) {
Node *ret;
if (l == r) {
ret = new Node(l, r, 0, 0);
ret->max = pos[l];
} else {
ret = new Node(l, r, build(l, (l + (r - l) / 2)),
build((l + (r - l) / 2) + 1, r));
ret->up();
}
return ret;
}
void up() { max = cmax(lc->max, rc->max); }
void change(int p, int x) {
if (l == r) {
::p[pos[l]] = x;
max = pos[l];
return;
}
if (p <= (l + (r - l) / 2))
lc->change(p, x);
else
rc->change(p, x);
up();
}
int query(int L, int R) {
if (l == L && r == R) return max;
if (R <= (l + (r - l) / 2))
return lc->query(L, R);
else if (L > (l + (r - l) / 2))
return rc->query(L, R);
else
return cmax(lc->query(L, (l + (r - l) / 2)),
rc->query((l + (r - l) / 2) + 1, R));
}
} * root;
bool cmp(int a, int b) { return tim[a] > tim[b]; }
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void dfs(int u) {
static int ts = 0;
dfn[u] = ++ts;
pos[ts] = u;
sz[u] = 1;
for (auto v : son[u]) dfs(v), sz[u] += sz[v], f[v][0] = u;
}
int get(int u, int val) {
for (int i = (21); i >= (0); --i) {
if (f[u][i] && wei[f[u][i]] >= val) u = f[u][i];
}
return u;
}
int main() {
memset(ans, -1, sizeof ans);
rd(n), rd(m), rd(q);
for (int i = (1); i <= (n); ++i) rd(p[i]), wei[i] = q + 1;
for (int i = (1); i <= (2 * n + 5); ++i) fa[i] = i;
for (int i = (1); i <= (m); ++i) {
rd(E[i].first);
rd(E[i].second);
tim[i] = q + 1;
seq[i] = i;
}
for (int i = (1); i <= (q); ++i) rd(Q[i].first), rd(Q[i].second);
for (int i = (1); i <= (q); ++i) {
if (Q[i].first == 2) tim[Q[i].second] = i;
}
std::sort(seq + 1, seq + m + 1, cmp);
tot = n;
for (int i = (1); i <= (m); ++i) {
int u = E[seq[i]].first, v = E[seq[i]].second, tt = tim[seq[i]];
if (find(u) == find(v)) continue;
wei[++tot] = tt;
u = find(u), v = find(v);
son[tot].push_back(u), son[tot].push_back(v);
fa[u] = fa[v] = tot;
}
for (int i = (tot); i >= (1); --i)
if (!dfn[i]) dfs(i);
root = Node::build(1, tot);
for (int j = (1); j <= (21); ++j)
for (int i = (1); i <= (tot); ++i) f[i][j] = f[f[i][j - 1]][j - 1];
for (int i = (1); i <= (q); ++i) {
if (Q[i].first == 1) {
int v = get(Q[i].second, i);
int tmp = root->query(dfn[v], dfn[v] + sz[v] - 1);
ans[i] = p[tmp];
if (ans[i]) root->change(dfn[tmp], 0);
printf("%d\n", ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, timer, real_n;
vector<int> a, g, ts, te;
vector<vector<int>> adj;
vector<pair<int, int>> segtree;
int get(int u) { return u == g[u] ? u : g[u] = get(g[u]); }
void uni(int u, int v) {
u = get(u);
v = get(v);
if (u == v) return;
adj.push_back({u, v});
g.push_back(n);
g[u] = n;
g[v] = n;
n++;
}
void dfs(int u) {
segtree.emplace_back(u < real_n ? a[u] : 0, timer);
ts[u] = timer++;
for (int v : adj[u]) {
dfs(v);
}
te[u] = timer;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> n >> m >> q;
real_n = n;
a.resize(n);
for (auto& it : a) cin >> it;
vector<array<int, 2>> edges(m);
for (auto& it : edges) {
cin >> it[0] >> it[1];
--it[0], --it[1];
}
vector<array<int, 2>> queries(q);
vector<int> erased(m);
for (auto& it : queries) {
cin >> it[0] >> it[1];
--it[1];
if (it[0] == 2) {
erased[it[1]] = true;
}
}
g.resize(n);
g.reserve(n * 2);
adj.resize(n);
adj.reserve(n * 2);
iota(g.begin(), g.end(), 0);
for (int i = 0; i < m; i++) {
if (!erased[i]) {
uni(edges[i][0], edges[i][1]);
}
}
vector<int> real_queries;
for (int i = q - 1; i >= 0; i--) {
if (queries[i][0] == 1) {
real_queries.push_back(get(queries[i][1]));
} else {
auto& e = edges[queries[i][1]];
uni(e[0], e[1]);
}
}
ts.resize(n, -1);
te.resize(n, -1);
segtree.resize(n, {0, -1});
segtree.reserve(n * 2);
for (int i = 0; i < real_n; i++) {
int leader = get(i);
if (ts[leader] == -1) {
dfs(leader);
}
}
for (int i = n - 1; i > 0; i--) {
segtree[i] = max(segtree[i << 1], segtree[i << 1 | 1]);
}
reverse(real_queries.begin(), real_queries.end());
for (int qi : real_queries) {
int l = ts[qi] + n, r = te[qi] + n;
pair<int, int> res = {0, -1};
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, segtree[l++]);
if (r & 1) res = max(res, segtree[--r]);
}
cout << res.first << '\n';
if (res.first != 0) {
int i = res.second + n;
segtree[i].first = 0;
for (; i >>= 1;) {
segtree[i] = max(segtree[i << 1], segtree[i << 1 | 1]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
void _dbg(char const *s, const T &t) {
cerr << s << "=" << t << endl;
}
template <typename T, typename... TA>
void _dbg(char const *s, const T &t, const TA &...ta) {
while (*s != ',') cerr << *s++;
cerr << "=" << t << ",";
_dbg(s + 1, ta...);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &print_iterable(ostream &os, T beg, T end) {
os << '[';
for (auto it = beg; it != end; ++it) {
if (it != beg) os << ", ";
os << *it;
}
return os << ']';
}
template <typename T, size_t N>
ostream &operator<<(ostream &os, const array<T, N> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const map<T1, T2> &x) {
return print_iterable(os, begin(x), end(x));
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const unordered_map<T1, T2> &x) {
return print_iterable(os, begin(x), end(x));
}
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<ld, ld>;
constexpr int maxn = 2e5 + 1;
constexpr int maxq = 5e5 + 1;
struct DSU {
int par[maxn];
int sz[maxn];
DSU() {
iota(par, par + maxn, 0);
fill(sz, sz + maxn, 1);
}
int p(int x) {
if (par[x] == x) return x;
return par[x] = p(par[x]);
}
bool merge(int a, int b) {
a = p(a);
b = p(b);
if (a == b) return false;
if (sz[a] < sz[b]) {
swap(a, b);
}
sz[a] += sz[b];
par[b] = a;
return true;
}
} dsu;
vector<pii> edges;
vector<bool> edge_will_be_deleted;
vector<int> g[maxn];
vector<pii> qs;
array<set<int>, maxn> setik;
array<pii, maxq> rollbacks;
void solve() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
vector<int> used(n + 1);
vector<int> p(n);
for (auto &x : p) {
scanf("%d", &x);
}
edges.resize(m);
edge_will_be_deleted.resize(m, false);
for (auto &e : edges) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
e = {a, b};
g[a].push_back(b);
g[b].push_back(a);
}
qs.resize(q);
for (auto &e : qs) {
int t, v;
scanf("%d%d", &t, &v);
--v;
e = {t, v};
if (t == 2) {
edge_will_be_deleted[v] = true;
}
}
for (int i = 0; i < m; ++i) {
if (edge_will_be_deleted[i]) continue;
int a, b;
tie(a, b) = edges[i];
dsu.merge(a, b);
}
for (int i = 0; i < n; ++i) {
int a = dsu.p(i);
setik[a].insert(p[i]);
}
for (int i = q - 1; i >= 0; --i) {
int t, eid;
tie(t, eid) = qs[i];
if (t == 2) {
int a, b;
tie(a, b) = edges[eid];
a = dsu.p(a);
b = dsu.p(b);
if (a == b) {
continue;
}
if (dsu.sz[a] < dsu.sz[b]) {
swap(a, b);
}
setik[a].insert(setik[b].begin(), setik[b].end());
rollbacks[i] = {a, b};
dsu.merge(a, b);
}
if (t == 1) {
int v = eid;
v = dsu.p(v);
rollbacks[i] = {v, 0};
}
}
for (int i = 0; i < q; ++i) {
int t, v;
tie(t, v) = qs[i];
if (t == 2) {
int a, b;
tie(a, b) = rollbacks[i];
if (a == b) continue;
for (const auto &e : setik[b]) {
setik[a].erase(e);
}
continue;
}
int p = rollbacks[i].first;
int res = 0;
while (!setik[p].empty()) {
int r = *setik[p].rbegin();
if (!used[r]) {
res = r;
break;
}
setik[p].erase(r);
}
used[res] = true;
;
printf("%d\n", res);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
vector<pair<int, int>> edges;
vector<pair<int, int>> queries;
int nodes[MAX], ds[MAX], currentNode, tourID;
bool dels[MAX];
vector<int> ady[MAX];
pair<int, int> stree[4 * MAX];
int idIni[MAX], idFin[MAX];
int dsFind(int v) {
if (ds[v] == v) {
return v;
}
return ds[v] = dsFind(ds[v]);
}
void dsJoin(int u, int v) {
u = dsFind(u);
v = dsFind(v);
if (u == v) return;
currentNode++;
ds[currentNode] = currentNode;
ds[u] = currentNode;
ds[v] = currentNode;
ady[currentNode].push_back(u);
ady[currentNode].push_back(v);
}
pair<int, int> query(int n, int ini, int fin, int a, int b) {
if (ini > b || fin < a) {
return make_pair(INT_MIN, INT_MIN);
} else if (ini >= a && fin <= b) {
return stree[n];
} else {
int mid = (ini + fin) / 2;
return max(query(n * 2, ini, mid, a, b),
query(n * 2 + 1, mid + 1, fin, a, b));
}
}
void update(int n, int ini, int fin, int p, int v) {
if (ini > p || fin < p) {
return;
} else if (ini >= p && fin <= p) {
stree[n] = make_pair(v, p);
} else {
int mid = (ini + fin) / 2;
update(n * 2, ini, mid, p, v);
update(n * 2 + 1, mid + 1, fin, p, v);
stree[n] = max(stree[n * 2], stree[n * 2 + 1]);
}
}
void dfs(int u) {
tourID++;
idIni[u] = tourID;
for (auto v : ady[u]) {
dfs(v);
}
idFin[u] = tourID;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
memset(stree, -63, sizeof stree);
int N, M, Q;
cin >> N >> M >> Q;
currentNode = N;
for (int i = 1; i <= N; i++) {
cin >> nodes[i];
}
edges.emplace_back(0, 0);
queries.emplace_back(0, 0);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
edges.emplace_back(u, v);
}
for (int i = 0; i < Q; i++) {
int t, v;
cin >> t >> v;
if (t == 2) {
dels[v] = true;
}
queries.emplace_back(t, v);
}
for (int i = 1; i <= N; i++) {
ds[i] = i;
}
for (int i = 1; i <= M; i++) {
if (!dels[i]) {
dsJoin(edges[i].first, edges[i].second);
}
}
for (int i = Q; i > 0; i--) {
int t = queries[i].first;
int n = queries[i].second;
if (t == 1) {
queries[i].second = dsFind(n);
} else {
dsJoin(edges[n].first, edges[n].second);
}
}
for (int i = 1; i < MAX; i++) {
if (ds[i] == i) {
dfs(i);
}
}
tourID++;
for (int i = 1; i <= N; i++) {
int p = idIni[i];
update(1, 1, tourID, p, nodes[i]);
}
for (int i = 1; i <= Q; i++) {
int t = queries[i].first;
int n = queries[i].second;
if (t == 1) {
auto res = query(1, 1, tourID, idIni[n], idFin[n]);
cout << res.first << "\n";
update(1, 1, tourID, res.second, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500100;
int v[MAXN];
pair<int, int> grafo[MAXN], q[MAXN];
bool are[MAXN];
int p[MAXN];
int pai[MAXN];
vector<int> vec[MAXN];
struct seg {
seg *fe, *fd;
int meio, l, r;
pair<int, int> mex;
seg(int x, int y) {
meio = (x + y) / 2;
l = x, r = y;
mex = {-1, 0};
if (l == r) return;
fe = new seg(x, meio);
fd = new seg(meio + 1, y);
}
void up(int pos, int novo) {
if (l == r) {
mex = {novo, l};
return;
}
if (pos <= meio)
fe->up(pos, novo);
else
fd->up(pos, novo);
if (fe->mex.first >= fd->mex.first)
mex = fe->mex;
else
mex = fd->mex;
}
pair<int, int> get(int a, int b) {
if (l >= a && r <= b) return mex;
if (l > b || r < a) return {-1, 0};
pair<int, int> re = fe->get(a, b), rd = fd->get(a, b);
if (re.first >= rd.first) return re;
return rd;
}
};
int find(int x) {
if (pai[x] == x) return x;
return pai[x] = find(pai[x]);
}
void join(int a, int b) {
a = find(a), b = find(b);
if (vec[a].size() >= vec[b].size()) {
for (int i = 0; i < vec[b].size(); i++) vec[a].push_back(vec[b][i]);
pai[b] = a;
} else {
for (int i = 0; i < vec[a].size(); i++) vec[b].push_back(vec[a][i]);
pai[a] = b;
}
}
seg st(0, MAXN);
int main() {
int n, m, Q;
scanf("%d %d %d", &n, &m, &Q);
for (int i = 1; i <= n; i++)
scanf("%d", &v[i]), pai[i] = i, vec[i].push_back(i);
for (int i = 1; i <= m; i++)
scanf("%d %d", &grafo[i].first, &grafo[i].second);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &q[i].first, &q[i].second);
if (q[i].first == 2) are[q[i].second] = true;
}
for (int i = 1; i <= m; i++) {
if (are[i] == true) continue;
int a = grafo[i].first, b = grafo[i].second;
if (find(a) == find(b)) continue;
join(a, b);
}
vector<pair<int, int>> res;
for (int i = Q; i >= 1; i--) {
if (q[i].first == 1) {
int a = find(q[i].second);
res.push_back({a, vec[a].size()});
} else {
int a = find(grafo[q[i].second].first),
b = find(grafo[q[i].second].second);
if (a == b) continue;
join(a, b);
}
}
for (int i = 1; i < n; i++) {
if (find(i) == find(i + 1)) continue;
join(i, i + 1);
}
int h = find(1);
for (int i = 0; i < n; i++) p[vec[h][i]] = i + 1, st.up(i + 1, v[vec[h][i]]);
for (int i = (int)res.size() - 1; i >= 0; i--) {
pair<int, int> h =
st.get(p[res[i].first], p[res[i].first] + res[i].second - 1);
printf("%d\n", h.first);
st.up(h.second, 0);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read() {
int x = 0;
int f = 0;
char ch = 0;
while (!isdigit(ch)) {
f |= (ch == '-') ? 1 : 0;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
const int maxn = 6e5 + 10;
int aa[maxn];
int st1[maxn], st2[maxn];
int del[maxn], f[maxn];
int typ[maxn], key[maxn];
int n, m, q;
int cnt, tim = 0;
int in[maxn], out[maxn];
struct node {
int to, nxt;
} edge[maxn << 1];
int head[maxn], tot = 0;
pair<int, int> sum[maxn << 2];
inline void add(int u, int v) {
edge[tot].to = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
inline int fnd(int x) {
if (x == f[x]) return x;
return f[x] = fnd(f[x]);
}
inline void link(int u, int v) {
u = fnd(u);
v = fnd(v);
if (u != v) {
++cnt;
f[cnt] = cnt;
f[u] = f[v] = cnt;
add(cnt, u);
add(cnt, v);
}
}
inline void dfs(int u) {
in[u] = ++tim;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].to;
dfs(v);
}
out[u] = tim;
}
inline void update(int rt, int x, int l, int r, pair<int, int> k) {
if (l > x || r < x) return;
if (l == r) {
sum[rt] = k;
return;
}
int mid = (l + r) >> 1;
update(rt << 1, x, l, mid, k);
update(rt << 1 | 1, x, mid + 1, r, k);
sum[rt] = max(sum[rt << 1], sum[rt << 1 | 1]);
}
inline pair<int, int> query(int rt, int l, int r, int al, int ar) {
if (l > ar || r < al) return make_pair(0, 0);
if (l <= al && r >= ar) return sum[rt];
int mid = (al + ar) >> 1;
return max(query(rt << 1, l, r, al, mid),
query(rt << 1 | 1, l, r, mid + 1, ar));
}
int main() {
n = read();
m = read();
q = read();
cnt = n;
memset(head, -1, sizeof(head));
for (register int i = 1; i <= n; ++i) aa[i] = read(), f[i] = i;
for (register int i = 1; i <= m; ++i) {
int u = read();
int v = read();
st1[i] = u;
st2[i] = v;
}
for (register int i = 1; i <= q; ++i) {
typ[i] = read();
key[i] = read();
if (typ[i] == 2) {
del[key[i]] = 1;
}
}
for (register int i = 1; i <= m; ++i)
if (!del[i]) {
link(st1[i], st2[i]);
}
for (register int i = q; i >= 1; --i) {
if (typ[i] == 2) {
link(st1[key[i]], st2[key[i]]);
} else
key[i] = fnd(key[i]);
}
for (register int i = 1; i <= cnt; ++i)
if (fnd(i) == i) dfs(i);
for (register int i = 1; i <= n; ++i)
update(1, in[i], 1, cnt, make_pair(aa[i], in[i]));
for (register int i = 1; i <= q; ++i) {
if (typ[i] == 1) {
pair<int, int> tmp = query(1, in[key[i]], out[key[i]], 1, cnt);
printf("%d\n", tmp.first);
if (tmp.first) update(1, tmp.second, 1, cnt, make_pair(0, 0));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const long double pi = std::acos(-1);
long long gcd(long long a, long long b) {
if (!b) {
return a;
}
return gcd(b, a % b);
}
long long gcdE(long long a, long long b, long long* x, long long* y) {
if (!a) {
*x = 0;
*y = 1;
return b;
}
long long x1, y1;
long long _gcd = gcdE(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return _gcd;
}
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) {
res = (res * x) % mod;
}
y >>= 1;
x = (x * x) % mod;
}
return res;
}
long long inverse(long long x) { return power(x, mod - 2); }
int n, m, q;
vector<int> p(1000001, 0);
vector<int> b(1000001, 0);
vector<pair<int, int>> edges(300001);
vector<bool> exists(300001, 1);
vector<pair<int, int>> query(500001);
vector<int> dsuparent(500001);
vector<int> adj[500001];
vector<pair<int, int>> node;
vector<pair<int, int>> segtree;
int timer = 0;
vector<int> in(1000001), out(1000001);
vector<int> conv(1000001);
void dfs(int c) {
in[c] = ++timer;
for (int x : adj[c]) {
dfs(x);
}
out[c] = ++timer;
}
int find(int i) {
if (dsuparent[i] != i) {
dsuparent[i] = find(dsuparent[i]);
}
return dsuparent[i];
}
void add(int x, int y) {
int xroot = find(x);
int yroot = find(y);
if (xroot == yroot) {
return;
}
adj[++n].push_back(xroot);
adj[n].push_back(yroot);
dsuparent[xroot] = dsuparent[yroot] = dsuparent[n] = n;
}
void dsuinit() {
for (int i = 1; i <= n; i++) {
dsuparent[i] = i;
}
}
pair<int, int> getsum(int ns, int ne, int qs, int qe, int ci) {
if (qs <= ns && qe >= ne) {
return segtree[ci];
}
if (qe < ns || ne < qs) {
return {-1, -1};
}
int mid = ns + ((ne - ns) >> 1);
return max(getsum(ns, mid, qs, qe, (ci << 1) + 1),
getsum(mid + 1, ne, qs, qe, (ci << 1) + 2));
}
pair<int, int> segquery(int qs, int qe) {
return getsum(0, timer - 1, qs, qe, 0);
}
void updatef(int ns, int ne, int i, int ci) {
if (i < ns || i > ne) {
return;
}
if (ns == ne) {
segtree[ci] = {0, 0};
return;
}
int mid = ns + ((ne - ns) >> 1);
updatef(ns, mid, i, (ci << 1) + 1);
updatef(mid + 1, ne, i, (ci << 1) + 2);
segtree[ci] = max(segtree[(ci << 1) + 1], segtree[(ci << 1) + 2]);
}
void update(int index) { updatef(0, timer - 1, index, 0); }
pair<int, int> construct(int si, int ei, int ci) {
if (si == ei) {
segtree[ci] = {b[si + 1], si + 1};
return segtree[ci];
}
int mid = si + ((ei - si) >> 1);
segtree[ci] = max(construct(si, mid, (ci << 1) + 1),
construct(mid + 1, ei, (ci << 1) + 2));
return segtree[ci];
}
void init() {
for (int i = 1; i <= n; i++) {
b[in[i]] = b[out[i]] = p[i];
conv[in[i]] = conv[out[i]] = i;
}
segtree.resize((timer << 2) + 1);
construct(0, timer - 1, 0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> p[i];
}
dsuinit();
for (int i = 1; i <= m; i++) {
cin >> edges[i].first >> edges[i].second;
}
for (int i = 1; i <= q; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 2) {
exists[query[i].second] = 0;
}
}
for (int i = 1; i <= m; i++) {
if (exists[i]) {
add(edges[i].first, edges[i].second);
}
}
for (int i = q; i >= 1; i--) {
if (query[i].first == 2) {
add(edges[query[i].second].first, edges[query[i].second].second);
continue;
}
query[i].second = find(query[i].second);
}
for (int i = 1; i <= n; i++) {
if (find(i) == i) {
dfs(i);
}
}
init();
for (int i = 1; i <= q; i++) {
if (query[i].first == 1) {
pair<int, int> get =
segquery(in[query[i].second] - 1, out[query[i].second] - 1);
cout << get.first << "\n";
get.second = conv[get.second];
if (get.second >= 1) {
update(in[get.second] - 1);
update(out[get.second] - 1);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 400003;
int n = 0, m = 0, q = 0, cPoint = 0;
int p[maxn];
struct Edge {
int u, e;
int id;
};
Edge E[maxn];
int deleteTime[maxn];
inline bool operator<(Edge const &lhs, Edge const &rhs) {
return deleteTime[lhs.id] > deleteTime[rhs.id];
}
int opt[500003], Sec[500003];
int head[maxn], nxt[maxn], to[maxn], cnt = 0;
inline void insert(int u, int e) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = e;
}
int fath[maxn];
inline int find(int x) { return fath[x] == x ? x : fath[x] = find(fath[x]); }
int ti[maxn];
void CreateTheTree() {
std::sort(E + 1, E + m + 1);
for (int i = 1; i <= 2 * n; ++i) fath[i] = i;
cPoint = n;
for (int i = 1; i <= m; ++i) {
if (find(E[i].u) == find(E[i].e)) continue;
++cPoint;
ti[cPoint] = deleteTime[E[i].id];
insert(cPoint, find(E[i].u));
insert(cPoint, find(E[i].e));
fath[find(E[i].u)] = cPoint;
fath[find(E[i].e)] = cPoint;
}
}
int fa[20][maxn], Ldfn[maxn], Rdfn[maxn];
int dfn[maxn], idfn[maxn];
void dfs(int x, int f) {
fa[0][x] = f;
for (int j = 1; j <= 18; ++j) fa[j][x] = fa[j - 1][fa[j - 1][x]];
if (x <= n) {
Ldfn[x] = Rdfn[x] = dfn[x] = ++dfn[0];
idfn[dfn[x]] = x;
return;
}
Ldfn[x] = cPoint + 1, Rdfn[x] = 0;
for (int i = head[x]; i; i = nxt[i]) {
dfs(to[i], x);
Ldfn[x] = std::min(Ldfn[x], Ldfn[to[i]]);
Rdfn[x] = std::max(Rdfn[x], Rdfn[to[i]]);
}
}
struct MX {
int v, pos;
};
MX operator|(MX const &lhs, MX const &rhs) { return lhs.v > rhs.v ? lhs : rhs; }
MX mx[maxn << 2];
void CreateSeg(int po, int L, int R) {
if (L == R) {
mx[po].v = p[idfn[L]];
mx[po].pos = idfn[L];
return;
}
int mid = (L + R) >> 1;
CreateSeg(po << 1, L, mid);
CreateSeg(po << 1 | 1, mid + 1, R);
mx[po] = mx[po << 1] | mx[po << 1 | 1];
}
void Modify(int po, int L, int R, int x) {
if (L == R) {
mx[po].v = p[idfn[L]];
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
Modify(po << 1, L, mid, x);
else
Modify(po << 1 | 1, mid + 1, R, x);
mx[po] = mx[po << 1] | mx[po << 1 | 1];
}
MX query(int po, int L, int R, int l, int r) {
if (l <= L && R <= r) return mx[po];
int mid = (L + R) >> 1;
if (r <= mid)
return query(po << 1, L, mid, l, r);
else if (l > mid)
return query(po << 1 | 1, mid + 1, R, l, r);
else
return query(po << 1, L, mid, l, r) | query(po << 1 | 1, mid + 1, R, l, r);
}
int jump(int x, int time) {
for (int j = 18; ~j; --j)
if (ti[fa[j][x]] > time) x = fa[j][x];
return x;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) scanf("%d", p + i);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &E[i].u, &E[i].e);
E[i].id = i;
deleteTime[i] = q + 1;
}
for (int i = 1; i <= q; ++i) {
scanf("%d %d", opt + i, Sec + i);
if (opt[i] == 2) deleteTime[Sec[i]] = i;
}
CreateTheTree();
for (int i = 1; i <= cPoint; ++i)
if (fath[i] == i) dfs(i, 0);
CreateSeg(1, 1, n);
for (int i = 1; i <= q; ++i)
if (opt[i] == 1) {
int x = jump(Sec[i], i);
MX res = query(1, 1, n, Ldfn[x], Rdfn[x]);
printf("%d\n", res.v);
p[res.pos] = 0;
Modify(1, 1, n, dfn[res.pos]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long sz = 2e5 + 10, esz = 3e5 + 10, qsz = 5e5 + 10;
int p[sz], erased[esz], par[sz], siz[sz];
struct info {
long long a, b;
} edge[esz], qry[qsz];
struct rollback {
int par, node, siz;
} chng[qsz];
long long findp(long long u) {
if (par[u] == u) return u;
return findp(par[u]);
}
vector<int> lst[sz];
const bool cmp(int &a, int &b) { return p[a] < p[b]; }
void dsu_uni(int u, int v, int id = 0) {
int pu = findp(u), pv = findp(v);
if (pu == pv) return;
if (siz[pu] < siz[pv]) swap(pu, pv);
if (id != 0) chng[id] = {pu, pv, siz[pu]};
par[pv] = pu;
lst[pu].insert(lst[pu].end(), lst[pv].begin(), lst[pv].end());
siz[pu] += siz[pv];
}
int main() {
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (long long i = 1; i <= m; ++i)
scanf("%lld", &edge[i].a), scanf("%lld", &edge[i].b);
for (long long i = 1; i <= q; ++i) {
scanf("%lld", &qry[i].a), scanf("%lld", &qry[i].b);
if (qry[i].a == 2) erased[qry[i].b] = 1;
}
for (long long i = 1; i <= n; ++i)
par[i] = i, siz[i] = 1, lst[i].push_back(i);
for (long long i = 1; i <= m; ++i) {
if (erased[i]) continue;
dsu_uni(edge[i].a, edge[i].b);
}
for (long long i = q; i >= 1; --i) {
if (qry[i].a == 1) continue;
long long id = qry[i].b;
dsu_uni(edge[id].a, edge[id].b, i);
}
for (long long i = 1; i <= n; ++i) sort(lst[i].begin(), lst[i].end(), cmp);
for (long long i = 1; i <= q; ++i) {
if (qry[i].a == 1) {
long long pu = findp(qry[i].b);
while (!lst[pu].empty()) {
long long now = lst[pu].back(), pnow = findp(now);
if (pnow != pu || p[now] == 0) {
lst[pu].pop_back();
continue;
}
break;
}
long long ans = 0;
if (!lst[pu].empty()) ans = p[lst[pu].back()], p[lst[pu].back()] = 0;
printf("%lld\n", ans);
} else {
par[chng[i].node] = chng[i].node;
siz[chng[i].par] = chng[i].siz;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, r = 1, tmp, op[500005], x[500005], a[500005], w[500005],
tim[300005], be[500005], ed[500005], fp[500005];
int tot, head[500005];
int fo[500005], nxt[500005];
int t[500005 * 4];
int finds(int x) { return w[x] == x ? x : w[x] = finds(w[x]); }
void link(int u, int to) {
u = finds(u), to = finds(to);
if (u == to) return;
++n;
w[n] = n;
w[to] = n;
w[u] = n;
fo[++tot] = to;
nxt[tot] = head[n];
head[n] = tot;
fo[++tot] = u;
nxt[tot] = head[n];
head[n] = tot;
}
void dfs(int u) {
fp[be[u] = ++tmp] = u;
for (int i = head[u]; i; i = nxt[i]) dfs(fo[i]);
ed[u] = tmp;
}
int cma(int x, int y) { return a[x] > a[y] ? x : y; }
void build(int l, int r, int i) {
t[i] = fp[l];
if (l == r) return;
build(l, (l + r) / 2, i * 2 + 1);
build((l + r) / 2 + 1, r, i * 2 + 2);
t[i] = cma(t[i * 2 + 1], t[i * 2 + 2]);
}
void upd(int pos, int l, int r, int i) {
if (l > r) return;
t[i] = fp[l];
if (l == r) return;
if (pos <= (l + r) / 2)
upd(pos, l, (l + r) / 2, i * 2 + 1);
else
upd(pos, (l + r) / 2 + 1, r, i * 2 + 2);
t[i] = cma(t[i * 2 + 1], t[i * 2 + 2]);
}
int quy(int L, int R, int l, int r, int i) {
if (L > R) return 0;
if (L <= l && R >= r) return t[i];
int res = 0;
if (L <= (l + r) / 2) res = cma(res, quy(L, R, l, (l + r) / 2, i * 2 + 1));
if (R > (l + r) / 2) res = cma(res, quy(L, R, (l + r) / 2 + 1, r, i * 2 + 2));
return res;
}
int main() {
cin >> n >> m >> q;
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]), w[i] = i;
w[n + 1] = n + 1;
for (int i = (1); i <= (m); i++) scanf("%d%d", &be[i], &ed[i]);
for (int i = (1); i <= (q); i++) {
scanf("%d%d", &op[i], &x[i]);
if (op[i] == 2) tim[x[i]] = 1;
}
for (int i = (1); i <= (m); i++)
if (!tim[i]) link(be[i], ed[i]);
for (int i = (q); i >= (1); i--) {
if (op[i] == 2) link(be[x[i]], ed[x[i]]);
if (op[i] == 1) x[i] = finds(x[i]);
}
for (int i = (1); i <= (n); i++)
if (w[i] == i) dfs(i);
build(1, n, 0);
for (int i = (1); i <= (q); i++) {
if (op[i] == 2) continue;
x[i] = quy(be[x[i]], ed[x[i]], 1, n, 0);
printf("%d\n", a[x[i]]);
a[x[i]] = 0;
upd(be[x[i]], 1, n, 0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using pr = pair<int, int>;
int N, M, Q, A[200005], par[200005];
pr E[300005], QS[500005];
bool chk[300005];
set<int> s[200005];
stack<pr> st;
int f(int x) { return par[x] = (par[x] == x ? x : f(par[x])); }
void uni(int x, int y) {
x = f(x), y = f(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
st.push(pr(x, y));
for (auto it : s[x]) s[y].insert(it);
par[x] = y;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> M >> Q;
iota(par, par + N + 1, 0);
for (int i = 1; i <= N; i++) cin >> A[i], s[i].insert(A[i]);
for (int i = 1, x, y; i <= M; i++) {
cin >> x >> y;
E[i] = pr(x, y);
}
for (int i = 1, x, y; i <= Q; i++) {
cin >> x >> y;
QS[i] = pr(x, y);
if (x == 2) chk[y] = 1;
}
for (int i = 1; i <= M; i++)
if (!chk[i]) uni(E[i].first, E[i].second);
for (int i = Q; i; i--) {
if (QS[i].first == 1)
QS[i].second = f(QS[i].second);
else {
int x = E[QS[i].second].first, y = E[QS[i].second].second;
if (f(x) == f(y))
QS[i].first = 0;
else
uni(x, y);
}
}
for (int i = 1; i <= Q; i++) {
if (QS[i].first == 1) {
int p = QS[i].second;
int ans = 0;
if (s[p].size() > 0) {
ans = *s[p].rbegin();
s[p].erase(ans);
}
cout << ans << "\n";
} else if (QS[i].first == 2) {
int x = st.top().first, y = st.top().second;
st.pop();
set<int> tmp;
for (auto it : s[x])
if (s[y].find(it) != s[y].end()) {
tmp.insert(it);
s[y].erase(it);
}
s[x] = tmp;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m, q;
int p[N];
int wei[N], w[N];
int tim[N], seq[N];
struct edge {
int l, r;
} e[N];
struct query {
int l, r, id;
} qq[N];
int tot;
int find(int x) {
if (x == p[x]) return x;
return p[x] = find(p[x]);
}
int cmp(int a, int b) { return tim[a] > tim[b]; }
int ans[N];
vector<int> g[N];
int in[N], out[N], num, pre[N], f[N][21];
int tr[N << 2];
void dfs(int u) {
in[u] = ++num;
pre[num] = u;
for (int j = 1; j <= 20; j++) f[u][j] = f[f[u][j - 1]][j - 1];
for (auto &j : g[u]) {
f[j][0] = u;
dfs(j);
}
out[u] = num;
}
void pushup(int rt) {
if (w[tr[rt << 1]] >= w[tr[rt << 1 | 1]]) {
tr[rt] = tr[rt << 1];
} else
tr[rt] = tr[rt << 1 | 1];
}
int get(int x, int t) {
for (int i = 20; i >= 0; i--)
if (f[x][i] && wei[f[x][i]] >= t) x = f[x][i];
return x;
}
void build(int rt, int l, int r) {
if (l == r) {
tr[rt] = pre[l];
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
int query(int rt, int L, int R, int l, int r) {
if (L <= l && R >= r) {
return tr[rt];
}
int mid = l + r >> 1;
int res = 0, res1 = 0, res2 = 0;
if (L <= mid) res1 = query(rt << 1, L, R, l, mid);
if (R > mid) res2 = query(rt << 1 | 1, L, R, mid + 1, r);
if (w[res1] >= w[res2])
res = res1;
else
res = res2;
return res;
}
void update(int rt, int L, int C, int l, int r) {
if (l == r) {
w[pre[l]] = C;
tr[rt] = pre[l];
return;
}
int mid = l + r >> 1;
if (L <= mid)
update(rt << 1, L, C, l, mid);
else
update(rt << 1 | 1, L, C, mid + 1, r);
pushup(rt);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &w[i]), wei[i] = q + 1;
for (int i = 1; i <= n + n + 10; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i].l, &e[i].r);
tim[i] = q + 1;
seq[i] = i;
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &qq[i].l, &qq[i].r);
qq[i].id = i;
if (qq[i].l == 2) tim[qq[i].r] = i;
}
sort(seq + 1, seq + m + 1, cmp);
tot = n;
for (int i = 1; i <= m; i++) {
int u = e[seq[i]].l, v = e[seq[i]].r, t = tim[seq[i]];
int fx = find(u), fy = find(v);
if (fx == fy) continue;
wei[++tot] = t;
g[tot].push_back(fx);
g[tot].push_back(fy);
p[fx] = tot, p[fy] = tot;
}
for (int i = tot; i >= 1; i--)
if (!in[i]) dfs(i);
build(1, 1, num);
for (int i = 1; i <= q; i++) {
if (qq[i].l == 1) {
int v = get(qq[i].r, i);
int tmp = query(1, in[v], out[v], 1, num);
ans[i] = w[tmp];
if (ans[i]) update(1, in[tmp], 0, 1, num);
printf("%d\n", ans[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
using ii = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
const int N = 5e5 + 5;
int n, m, q, a[2 * N], id[2 * N], o[N];
ii it[N << 3], ed[N], qu[N];
vector<int> ad[N];
int tin[N], tout[N], idx;
int root(int x) { return id[x] == x ? x : id[x] = root(id[x]); }
void join(int u, int v) {
u = root(u), v = root(v);
if (u == v) return;
n++;
id[n] = n;
id[u] = n;
id[v] = n;
ad[n].push_back(u);
ad[n].push_back(v);
}
void upd(int i, int l, int r, int pos, ii val) {
if (pos < l || pos > r) return;
if (l == r) {
it[i] = val;
return;
}
int mid = l + (r - l) / 2;
upd(2 * i, l, mid, pos, val);
upd(2 * i + 1, mid + 1, r, pos, val);
it[i] = max(it[2 * i], it[2 * i + 1]);
}
ii que(int i, int l, int r, int u, int v) {
if (v < l || u > r) return make_pair(0, 0);
if (u <= l && r <= v) return it[i];
int mid = l + (r - l) / 2;
return max(que(2 * i, l, mid, u, v), que(2 * i + 1, mid + 1, r, u, v));
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
if (fopen("graph"
".inp",
"r")) {
freopen(
"graph"
".inp",
"r", stdin);
freopen(
"graph"
".out",
"w", stdout);
}
cin >> n >> m >> q;
for (int i = 1, _c = n; i <= _c; ++i) cin >> a[i];
for (int i = 1, _c = n + m; i <= _c; ++i) id[i] = i;
for (int i = 1, _c = m; i <= _c; ++i) cin >> ed[i].first >> ed[i].second;
for (int i = 1, _c = q; i <= _c; ++i) {
cin >> qu[i].first >> qu[i].second;
if (qu[i].first == 2) o[qu[i].second] = 1;
}
for (int i = 1, _c = m; i <= _c; ++i)
if (!o[i]) {
join(ed[i].first, ed[i].second);
}
for (int i = q, _c = 1; i >= _c; --i)
if (qu[i].first == 2) {
int x = qu[i].second;
join(ed[x].first, ed[x].second);
} else {
qu[i].second = root(qu[i].second);
}
function<void(int)> dfs = [&](int u) {
tin[u] = ++idx;
for (auto &v : ad[u]) {
dfs(v);
}
tout[u] = idx;
};
for (int i = 1, _c = n; i <= _c; ++i)
if (root(i) == i) dfs(i);
for (int i = 1, _c = n; i <= _c; ++i)
upd(1, 1, n, tin[i], make_pair(a[i], tin[i]));
for (int i = 1, _c = q; i <= _c; ++i)
if (qu[i].first == 1) {
int u = qu[i].second;
ii ans = que(1, 1, n, tin[u], tout[u]);
cout << ans.first << '\n';
upd(1, 1, n, ans.second, make_pair(0, ans.second));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long q = 239017;
const long long mod = 1e9 + 7;
const long long mod2 = 1e9 + 13;
const long long N = 2e5 + 100;
const long long M = 3e5 + 100;
const long long L = 26;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long p[N];
pair<long long, long long> seg[N];
vector<long long> comp[N];
long long c[N];
pair<long long, long long> qrSeg[N + M];
bitset<M> del;
long long get(long long a) {
if (p[a] == a) return a;
return p[a] = get(p[a]);
}
void merge(long long a, long long b) {
a = get(a);
b = get(b);
if (a == b) return;
if ((long long)comp[a].size() < (long long)comp[b].size()) swap(a, b);
p[b] = a;
seg[a].second = seg[b].second;
for (long long el : comp[b]) comp[a].push_back(el);
comp[b].clear();
}
struct SegTree {
vector<long long> t, id;
long long n;
void update(long long v) {
t[v] = max(t[v * 2], t[v * 2 + 1]);
if (t[v * 2] > t[v * 2 + 1])
id[v] = id[v * 2];
else
id[v] = id[v * 2 + 1];
}
void build(long long tl, long long tr, long long v, vector<long long>& a) {
if (tl + 1 == tr) {
t[v] = a[tl];
id[v] = tl;
return;
}
long long mid = (tl + tr) >> 1;
build(tl, mid, v * 2, a);
build(mid, tr, v * 2 + 1, a);
update(v);
}
SegTree(vector<long long>& a) {
if (a.empty()) return;
n = (long long)a.size();
t.resize(4 * n);
id.resize(4 * n);
build(0, n, 1, a);
}
void del(long long tl, long long tr, long long v, long long k) {
if (tl > k || tr <= k) return;
if (tl + 1 == tr && tl == k) {
t[v] = 0;
return;
}
long long mid = (tl + tr) >> 1;
del(tl, mid, v * 2, k);
del(mid, tr, v * 2 + 1, k);
update(v);
}
pair<long long, long long> get_mx(long long tl, long long tr, long long v,
long long l, long long r) {
if (tr <= l || tl >= r) return {-(long long)1e18, 1337};
if (l <= tl && tr <= r) return {t[v], id[v]};
long long mid = (tl + tr) >> 1;
auto a = get_mx(tl, mid, v * 2, l, r);
auto b = get_mx(mid, tr, v * 2 + 1, l, r);
return (a.first > b.first ? a : b);
}
pair<long long, long long> get_mx(long long l, long long r) {
return get_mx(0, n, 1, l, r + 1);
}
};
void $main() {
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 0; i < n; ++i) cin >> c[i];
for (long long i = 0; i < n; ++i) {
p[i] = i;
seg[i] = {i, i};
comp[i].push_back(i);
}
vector<pair<long long, long long> > r;
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
r.emplace_back(a, b);
}
vector<pair<long long, long long> > qr;
for (long long i = 0; i < q; ++i) {
long long a, b;
cin >> a >> b;
--b;
qr.emplace_back(a, b);
if (a != 1) del[b] = 1;
}
for (long long i = 0; i < m; ++i)
if (!del[i]) qr.emplace_back(2, i);
reverse(qr.begin(), qr.end());
long long it = 0;
for (auto el : qr) {
if (el.first == 2) {
merge(r[el.second].first, r[el.second].second);
} else {
qrSeg[it++] = seg[get(el.second)];
}
}
for (long long i = 0; i < n; ++i) merge(0, i);
long long root = get(0);
for (long long i = 0; i < (long long)comp[root].size(); ++i)
p[comp[root][i]] = i;
for (long long i = 0; i < it; ++i)
qrSeg[i] = {p[qrSeg[i].first], p[qrSeg[i].second]};
for (long long& el : comp[root]) el = c[el];
SegTree tree = SegTree(comp[root]);
for (long long i = it - 1; i >= 0; --i) {
auto get = tree.get_mx(qrSeg[i].first, qrSeg[i].second);
cout << get.first << '\n';
tree.del(0, n, 1, get.second);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
$main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) {
uniform_int_distribution<int> uni(l, r);
return uni(rng);
}
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m, q;
int dsu[700066], tot;
pair<int, int> E[300066], query[500066];
bool vis[300066];
vector<int> e[700066], vec[700066], V;
int p[200066];
int ans[500066];
int dfn[700066], tot_dfn, siz[700066];
set<int> Set;
pair<int, int> node[200066 * 20];
void update(int x, int l, int r, int aim, int w) {
if (l == r) {
node[x].first = w;
node[x].second = l;
return;
}
int mid = (l + r) >> 1;
if (aim <= mid)
update(x << 1, l, mid, aim, w);
else
update(x << 1 | 1, mid + 1, r, aim, w);
if (node[x << 1].first >= node[x << 1 | 1].first)
node[x] = node[x << 1];
else
node[x] = node[x << 1 | 1];
}
pair<int, int> que(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return node[x];
pair<int, int> ret = make_pair(0, 0);
int mid = (l + r) >> 1;
if (ql <= mid) ret = que(x << 1, l, mid, ql, qr);
if (mid < qr) ret = max(ret, que(x << 1 | 1, mid + 1, r, ql, qr));
return ret;
}
void dfs(int x) {
if (x <= n) {
dfn[x] = ++tot_dfn;
update(1, 1, n, dfn[x], p[x]);
siz[x] = 1;
V.push_back(x);
}
int mn = 1e9;
for (auto y : e[x]) {
dfs(y);
siz[x] += siz[y];
mn = min(mn, dfn[y]);
}
if (x > n) dfn[x] = mn;
}
void solve(int x) {
for (int i = ((int)(vec[x]).size()) - 1; i >= 0; i--) {
auto pii = que(1, 1, n, dfn[x], dfn[x] + siz[x] - 1);
ans[vec[x][i]] = pii.first;
update(1, 1, n, pii.second, 0);
}
for (auto y : e[x]) {
solve(y);
}
}
int leader(int x) { return x == dsu[x] ? x : dsu[x] = leader(dsu[x]); }
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= m; i++) scanf("%d%d", &E[i].first, &E[i].second);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &query[i].first, &query[i].second);
if (query[i].first == 2) vis[query[i].second] = true;
}
for (int i = 1; i <= n + q; i++) dsu[i] = i;
tot = n;
for (int i = 1; i <= m; i++) {
if (vis[i]) continue;
int s = leader(E[i].first), t = leader(E[i].second);
if (s == t) continue;
++tot;
dsu[s] = tot;
dsu[t] = tot;
dsu[tot] = tot;
e[tot].push_back(s);
e[tot].push_back(t);
}
for (int i = q; i > 0; i--) {
if (query[i].first == 1) {
int s = leader(query[i].second);
vec[s].push_back(i);
} else {
int id = query[i].second;
int s = leader(E[id].first), t = leader(E[id].second);
if (s == t)
continue;
else {
++tot;
dsu[s] = dsu[t] = tot;
e[tot].push_back(s);
e[tot].push_back(t);
}
}
}
for (int i = 1; i <= n; i++) Set.insert(leader(i));
for (auto x : Set) {
dfs(x);
solve(x);
for (auto y : V) update(1, 1, n, y, 0);
V.clear();
tot_dfn = 0;
}
for (int i = 1; i <= q; i++)
if (query[i].first == 1) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long N = 200005;
long long p[N];
long long x[N << 1], y[N << 1];
bool removed[N << 1];
vector<pair<long long, long long>> query;
struct DSU {
vector<long long> a, s;
vector<pair<long long, long long>> changes;
vector<set<long long>> elements;
DSU(long long n) {
a.resize(n + 1);
s.resize(n + 1);
elements.resize(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = i;
s[i] = 1;
elements[i].insert(p[i]);
}
}
long long root(long long i) {
while (i != a[i]) {
i = a[i];
}
return i;
}
bool merge(long long x, long long y) {
long long xr = root(x), yr = root(y);
if (xr == yr) {
changes.push_back({xr, xr});
return false;
}
if (s[xr] < s[yr]) swap(xr, yr);
s[xr] += s[yr];
elements[xr].insert(elements[yr].begin(), elements[yr].end());
a[yr] = xr;
changes.push_back({xr, yr});
return true;
}
void rollBack() {
if (changes.empty()) return;
pair<long long, long long> p = changes.back();
long long xr = p.first, yr = p.second;
changes.pop_back();
if (xr == yr) return;
for (auto it = elements[yr].begin(); it != elements[yr].end();) {
if (elements[xr].find(*it) != elements[xr].end())
elements[xr].erase(*it), it++;
else
it = elements[yr].erase(it);
}
a[yr] = yr;
s[xr] = elements[xr].size();
s[yr] = elements[yr].size();
}
long long query(long long x) {
long long xr = root(x);
if (elements[xr].empty()) return 0;
long long ret = *(--elements[xr].end());
elements[xr].erase(--elements[xr].end());
s[xr]--;
return ret;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
set<long long> s;
s.erase(5);
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 1; i < n + 1; i++) cin >> p[i];
for (long long i = 1; i < m + 1; i++) cin >> x[i] >> y[i];
query.resize(q);
vector<long long> r;
for (long long i = 0; i < q; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 2)
removed[query[i].second] = true, r.push_back(query[i].second);
}
DSU d(n);
for (long long i = 1; i < m + 1; i++) {
if (!removed[i]) d.merge(x[i], y[i]);
}
reverse(r.begin(), r.end());
for (long long i = 0; i < r.size(); i++) d.merge(x[r[i]], y[r[i]]);
for (long long i = 0; i < q; i++) {
if (query[i].first == 1)
cout << d.query(query[i].second) << '\n';
else
d.rollBack();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const int maxm = 3e5 + 10;
pair<int, int> Edge[maxm];
pair<int, int> Q[maxn];
vector<int> vec[maxn];
int arr[maxn], vis[maxm];
int n, m, q;
int rnk[maxn], f[maxn];
int in[maxn], out[maxn], tot;
int ufind(int x) { return x == f[x] ? x : f[x] = ufind(f[x]); }
void uni(int u, int v) {
int fu = ufind(u), fv = ufind(v);
if (fu == fv) return;
++n;
f[n] = n;
f[fu] = f[fv] = n;
vec[n].push_back(fu);
vec[n].push_back(fv);
}
void dfs(int u) {
in[u] = ++tot;
for (auto& v : vec[u]) dfs(v);
out[u] = tot;
return;
}
int tree[maxn * 4];
void update(int o, int L, int R, int pos, int v) {
int lch = o * 2, rch = o * 2 + 1;
if (L == R) {
tree[o] = v;
return;
}
int mid = (L + R) / 2;
if (pos <= mid)
update(lch, L, mid, pos, v);
else
update(rch, mid + 1, R, pos, v);
tree[o] = max(tree[lch], tree[rch]);
return;
}
int query(int o, int L, int R, int l, int r) {
int lch = o * 2, rch = o * 2 + 1;
if (l <= L && R <= r) {
return tree[o];
}
int mid = (L + R) / 2;
int ret = 0;
if (l <= mid) ret = max(ret, query(lch, L, mid, l, r));
if (r > mid) ret = max(ret, query(rch, mid + 1, R, l, r));
return ret;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
rnk[arr[i]] = i;
}
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &Edge[i].first, &Edge[i].second);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) vis[Q[i].second] = 1;
}
for (int i = 1; i <= m; i++)
if (!vis[i]) uni(Edge[i].first, Edge[i].second);
for (int i = q; i >= 1; i--) {
if (Q[i].first == 1)
Q[i].second = ufind(Q[i].second);
else
uni(Edge[Q[i].second].first, Edge[Q[i].second].second);
}
for (int i = 1; i <= n; i++)
if (ufind(i) == i) dfs(i);
for (int i = 1; i <= n; i++) update(1, 1, n, in[i], arr[i]);
for (int i = 1; i <= q; i++) {
if (Q[i].first == 1) {
int x = query(1, 1, n, in[Q[i].second], out[Q[i].second]);
printf("%d\n", x);
if (x) update(1, 1, n, in[rnk[x]], 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int A[1000006];
int fa[1000006], tot = 0;
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
struct ed {
int u, v, w;
} E[1000006];
vector<pair<int, int> > qs;
vector<int> G[1000006];
int que[1000006];
int L[1000006], R[1000006], bac[1000006], clo;
void dfs(int u) {
L[u] = ++clo, bac[clo] = u;
for (int v : G[u]) dfs(v);
R[u] = clo;
}
pair<int, int> T[1000006 << 2];
void pu(int rt) { T[rt] = max(T[rt << 1], T[rt << 1 | 1]); }
void build(int rt, int l, int r) {
if (l == r) {
T[rt] = make_pair(A[bac[l]], l);
return;
}
int m = l + r >> 1;
build(rt << 1, l, m), build(rt << 1 | 1, m + 1, r);
pu(rt);
}
pair<int, int> query(int rt, int l, int r, int L, int R) {
if (L <= l && R >= r) return T[rt];
int m = l + r >> 1;
pair<int, int> res;
if (L <= m) res = max(res, query(rt << 1, l, m, L, R));
if (R > m) res = max(res, query(rt << 1 | 1, m + 1, r, L, R));
return res;
}
void mdfy(int rt, int l, int r, int p) {
if (l == r) {
T[rt] = {0, l};
return;
}
int m = l + r >> 1;
if (p <= m)
mdfy(rt << 1, l, m, p);
else
mdfy(rt << 1 | 1, m + 1, r, p);
pu(rt);
}
void solve() {
cin >> n >> m >> q;
for (int i = (1), iend = (n); i <= iend; ++i) scanf("%d", A + i);
for (int i = (1), iend = (n << 1); i <= iend; ++i) fa[i] = i;
for (int i = (1), iend = (m); i <= iend; ++i) {
static int u, v;
scanf("%d%d", &u, &v);
E[i] = (ed){u, v, 0x3f3f3f3f};
}
for (int i = (1), iend = (q); i <= iend; ++i) {
static int op, x;
scanf("%d%d", &op, &x);
if (op == 1) {
qs.emplace_back(make_pair(x, i));
} else {
E[x].w = i;
}
}
sort(E + 1, E + 1 + m, [](ed a, ed b) { return a.w > b.w; });
sort((qs).begin(), (qs).end(),
[](pair<int, int> a, pair<int, int> b) { return a.second > b.second; });
int u, v, cur = 0;
tot = n;
for (int i = (1), iend = (m); i <= iend; ++i) {
u = find(E[i].u), v = find(E[i].v);
while (qs[cur].second > E[i].w && cur < qs.size()) {
que[qs[cur].second] = find(qs[cur].first);
++cur;
}
if (u != v) {
fa[u] = fa[v] = ++tot;
G[tot].push_back(u), G[tot].push_back(v);
}
}
while (cur < qs.size()) que[qs[cur].second] = find(qs[cur].first), ++cur;
for (int i = (1), iend = (tot); i <= iend; ++i)
if (fa[i] == i) dfs(i);
build(1, 1, tot);
for (int i = (1), iend = (q); i <= iend; ++i)
if (que[i]) {
pair<int, int> as = query(1, 1, tot, L[que[i]], R[que[i]]);
printf("%d\n", as.first);
mdfy(1, 1, tot, as.second);
}
}
signed main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
string print_iterable(T1 begin_iter, T2 end_iter, int counter) {
bool done_something = false;
stringstream res;
res << "[";
for (; begin_iter != end_iter and counter; ++begin_iter) {
done_something = true;
counter--;
res << *begin_iter << ", ";
}
string str = res.str();
if (done_something) {
str.pop_back();
str.pop_back();
}
str += "]";
return str;
}
vector<int> SortIndex(int size, std::function<bool(int, int)> compare) {
vector<int> ord(size);
for (int i = 0; i < size; i++) ord[i] = i;
sort(ord.begin(), ord.end(), compare);
return ord;
}
template <typename T>
bool MinPlace(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T>& p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
template <class TH>
void _dbg(const char* name, TH val) {
clog << name << ": " << val << endl;
}
template <class TH, class... TA>
void _dbg(const char* names, TH curr_val, TA... vals) {
while (*names != ',') clog << *names++;
clog << ": " << curr_val << ", ";
_dbg(names + 1, vals...);
}
struct Edge {
int u, v, id;
int t;
};
int N, Q;
const int MAXN = 1 << 19;
int dep[MAXN];
vector<int> aa[MAXN];
vector<int> ids[MAXN];
Edge edges[MAXN];
int queries[MAXN];
vector<int> prequery;
void dfs(int v, int p) {
for (int a : aa[v]) {
if (a == p) continue;
dep[a] = dep[v] + 1;
dfs(a, v);
}
}
int from[MAXN];
int to[MAXN];
int cnt;
int dist[MAXN];
int ff0[2 * MAXN], ff1[2 * MAXN];
void preproc(int v, int p) {
cnt++;
int id = cnt;
ff0[MAXN + id] = dist[v];
for (int i = 0; i < ((int)((aa[v]).size())); i++) {
int a = aa[v][i];
if (a == p) continue;
dist[a] = dist[v] + 1;
from[ids[v][i]] = cnt + 1;
preproc(a, v);
to[ids[v][i]] = cnt;
}
}
bool flag[2 * MAXN];
void f(int v, int l, int r, int a, int b) {
if (a <= l and r <= b) {
swap(ff0[v], ff1[v]);
flag[v] ^= 1;
return;
}
if (r < a or b < l) return;
if (flag[v]) {
flag[v] = false;
swap(ff0[2 * v], ff1[2 * v]);
swap(ff0[2 * v + 1], ff1[2 * v + 1]);
flag[2 * v] ^= 1, flag[2 * v + 1] ^= 1;
}
int m = (l + r) / 2;
f(2 * v, l, m, a, b);
f(2 * v + 1, m + 1, r, a, b);
ff0[v] = max(ff0[2 * v], ff0[2 * v + 1]);
ff1[v] = max(ff1[2 * v], ff1[2 * v + 1]);
}
void process(int x) { f(1, 0, MAXN - 1, from[x], to[x]); }
vector<int> solve(int root) {
dist[root] = 0;
cnt = 0;
for (int i = 1; i < 2 * MAXN; i++) ff0[i] = ff1[i] = 0, flag[i] = false;
preproc(root, -1);
for (int i = MAXN - 1; i >= 1; i--) {
ff0[i] = max(ff0[2 * i], ff0[2 * i + 1]);
}
for (int q : prequery) process(q);
vector<int> ans(Q);
for (int q = 0; q < Q; q++) {
process(queries[q]);
ans[q] = ff0[1];
}
return ans;
}
int main() {
ios::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;
aa[u].push_back(v);
aa[v].push_back(u);
ids[u].push_back(i + 1);
ids[v].push_back(i + 1);
if (t) prequery.push_back(i + 1);
}
dfs(1, 0);
int A = 1;
for (int v = 2; v <= N; v++)
if (dep[v] > dep[A]) A = v;
dep[A] = 0;
dfs(A, 0);
int B = 1;
for (int v = 2; v <= N; v++)
if (dep[v] > dep[B]) B = v;
cin >> Q;
for (int i = 0; i < Q; i++) cin >> queries[i];
vector<int> ans1 = solve(A);
vector<int> ans2 = solve(B);
for (int i = 0; i < Q; i++) cout << max(ans1[i], ans2[i]) << "\n";
}
|
#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;
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 std::swap;
template <typename T>
T& setmax(T& a, const T& b) {
if (b > a) a = b;
return a;
}
template <typename T>
T& setmin(T& a, const T& b) {
if (b < a) a = b;
return a;
}
const int INF = 1e9;
struct top_tree_node {
mutable top_tree_node* p = nullptr;
top_tree_node* c[3] = {nullptr, nullptr, nullptr};
int d() const {
assert(p);
if (this == p->c[0]) {
return 0;
} else if (this == p->c[1]) {
return 1;
} else if (this == p->c[2]) {
return 2;
} else
assert(false);
}
top_tree_node*& p_c() const { return p->c[d()]; }
bool is_path;
bool is_vert;
bool r() const { return !p || p->is_path != is_path; }
bool flip_path = false;
bool own_parity;
int path_len;
bool path_parity;
int best_path;
std::array<int, 2> best_up;
std::array<int, 2> best_down;
void do_flip_path() {
assert(is_path);
flip_path ^= 1;
swap(best_up, best_down);
}
void do_flip_edge_parity() {
assert(!is_vert);
own_parity ^= 1;
update();
}
void downdate() {
if (flip_path) {
assert(is_path);
if (!is_vert) {
if (c[0]) c[0]->do_flip_path();
if (c[1]) c[1]->do_flip_path();
}
swap(c[0], c[1]);
flip_path = false;
}
}
void update() {
if (is_path && !is_vert) {
assert(!c[2]);
assert(c[0] && c[1]);
path_len = c[0]->path_len + 1 + c[1]->path_len;
path_parity = c[0]->path_parity ^ own_parity ^ c[1]->path_parity;
best_up = c[0]->best_up;
for (int z = 0; z < 2; z++) {
setmax(best_up[c[0]->path_parity ^ own_parity ^ z],
c[0]->path_len + 1 + c[1]->best_up[z]);
}
best_down = c[1]->best_down;
for (int z = 0; z < 2; z++) {
setmax(best_down[c[1]->path_parity ^ own_parity ^ z],
c[1]->path_len + 1 + c[0]->best_down[z]);
}
best_path = std::max(c[0]->best_path, c[1]->best_path);
for (int z = 0; z < 2; z++) {
setmax(best_path,
c[0]->best_down[z] + 1 + c[1]->best_up[z ^ own_parity]);
}
} else {
assert((is_vert && is_path) || (!is_vert && !is_path));
if (is_vert) {
path_len = 0;
path_parity = 0;
best_path = 0;
best_up = {0, -INF};
} else {
best_path = c[2]->best_path;
best_up = c[2]->best_up;
if (own_parity) {
swap(best_up[0], best_up[1]);
}
best_up[0]++, best_up[1]++;
}
for (int d = 0; d < 2; d++) {
if (!c[d]) continue;
setmax(best_path, c[d]->best_path);
for (int z = 0; z < 2; z++) {
setmax(best_path, c[d]->best_up[z] + best_up[z]);
setmax(best_up[z], c[d]->best_up[z]);
}
}
best_down = best_up;
}
if (flip_path) {
assert(is_path);
swap(best_up, best_down);
}
}
void downdate_all() {
if (p) p->downdate_all();
downdate();
}
void update_all() {
update();
if (p) p->update_all();
}
private:
void rot() {
assert(!is_vert);
assert(!r());
top_tree_node* pa = p;
int x = d();
assert(x == 0 || x == 1);
top_tree_node* ch = c[!x];
if (pa->p) pa->p_c() = this;
this->p = pa->p;
pa->c[x] = ch;
if (ch) ch->p = pa;
this->c[!x] = pa;
pa->p = this;
pa->update();
}
void rot_2(int c_d) {
assert(!is_vert);
assert(!r());
assert(c[c_d]);
assert(!c[c_d]->is_vert);
if (d() == c_d) {
rot();
return;
}
top_tree_node* pa = p;
int x = d();
assert(x == 0 || x == 1);
assert(c_d == !x);
top_tree_node* ch = c[c_d]->c[!x];
if (pa->p) pa->p_c() = this;
this->p = pa->p;
pa->c[x] = ch;
if (ch) ch->p = pa;
this->c[c_d]->c[!x] = pa;
pa->p = this->c[c_d];
pa->update();
}
void splay_dir(int x) {
while (!r() && d() == x) {
if (!p->r() && p->d() == x) {
p->rot();
}
rot();
}
}
void splay_2(int c_d) {
assert(!is_vert && is_path);
assert(c[c_d] && !c[c_d]->is_vert);
while (!r()) {
if (!p->r()) {
if (p->d() == d()) {
p->rot();
} else {
rot_2(c_d);
}
}
rot_2(c_d);
}
}
void splay_2() {
assert(!is_vert && is_path);
assert(!r());
p->splay_2(d());
}
void splay_vert() {
assert(is_vert);
if (r()) {
return;
}
p->splay_dir(d());
if (p->r()) {
return;
}
assert(p->d() != d());
if (d() == 1) {
p->rot();
}
assert(d() == 0);
p->splay_2();
assert(d() == 0);
assert(p->d() == 1);
assert(p->p->r());
}
void splay() {
assert(!is_vert);
while (!r()) {
if (!p->r()) {
if (p->d() == d()) {
p->rot();
} else {
rot();
}
}
rot();
}
}
top_tree_node* cut_right() {
assert(is_vert && is_path);
splay_vert();
if (r() || d() == 1) {
assert(r() || (d() == 1 && p->r()));
assert(c[0] == nullptr);
return nullptr;
}
top_tree_node* pa = p;
assert(pa->r() || (pa->d() == 1 && pa->p->r()));
assert(!pa->is_vert);
assert(pa->is_path);
assert(pa->c[0] == this);
assert(pa->c[2] == nullptr);
if (pa->p) pa->p_c() = this;
this->p = pa->p;
pa->is_path = false;
pa->c[2] = pa->c[1];
pa->c[0] = c[0];
if (c[0]) c[0]->p = pa;
pa->c[1] = c[1];
if (c[1]) c[1]->p = pa;
c[0] = nullptr;
c[1] = pa;
pa->p = this;
assert(c[2] == nullptr);
assert(c[0] == nullptr);
pa->update();
return pa;
}
top_tree_node* splice_non_path() {
assert(!is_path);
assert(!is_vert);
splay();
assert(p && p->is_vert && p->is_path);
p->cut_right();
if (!p->is_path) rot();
assert(p && p->is_vert && p->is_path);
assert(p->r() || (p->d() == 1 && p->p->r()));
assert(p->c[d()] == this && p->c[!d()] == nullptr);
top_tree_node* pa = p;
if (pa->p) pa->p_c() = this;
this->p = pa->p;
pa->c[0] = c[0];
if (c[0]) c[0]->p = pa;
pa->c[1] = c[1];
if (c[1]) c[1]->p = pa;
assert(c[2] && c[2]->is_path);
c[1] = c[2];
c[0] = pa;
pa->p = this;
c[2] = nullptr;
is_path = true;
pa->update();
return pa;
}
void splice_all(top_tree_node*& res) {
if (!is_path) {
res = splice_non_path();
}
assert(is_path);
if (!p) return;
p->splice_all(res);
}
public:
top_tree_node* expose() {
assert(is_vert);
downdate_all();
top_tree_node* res = nullptr;
splice_all(res);
cut_right();
update_all();
return res;
}
void meld_path_end() {
assert(!p);
top_tree_node* rt = this;
while (true) {
rt->downdate();
if (rt->is_vert) break;
rt = rt->c[1];
}
assert(rt->is_vert);
rt->splay_vert();
if (rt->c[0] && rt->c[1]) {
top_tree_node* ch = rt->c[1];
while (true) {
ch->downdate();
if (!ch->c[0]) break;
ch = ch->c[0];
}
ch->splay();
assert(ch->c[0] == nullptr);
ch->c[0] = rt->c[0];
ch->c[0]->p = ch;
rt->c[0] = nullptr;
ch->update();
} else if (rt->c[0]) {
rt->c[1] = rt->c[0];
rt->c[0] = nullptr;
}
assert(rt->c[0] == nullptr);
rt->update_all();
}
void make_root() {
expose();
top_tree_node* rt = this;
while (rt->p) {
assert(rt->d() == 1);
rt = rt->p;
}
rt->do_flip_path();
rt->meld_path_end();
expose();
assert(!p);
}
friend void link(top_tree_node* e, top_tree_node* v1, top_tree_node* v2) {
assert(e && v1 && v2);
assert(!e->c[0] && !e->c[1] && !e->c[2]);
v1->expose();
while (v1->p) v1 = v1->p;
v2->make_root();
assert(!v1->p);
assert(!v2->p);
e->is_path = true, e->is_vert = false;
e->c[0] = v1;
v1->p = e;
e->c[1] = v2;
v2->p = e;
e->update();
}
friend std::pair<top_tree_node*, top_tree_node*> cut(top_tree_node* e) {
assert(!e->p);
assert(e->is_path);
assert(!e->is_vert);
e->downdate();
top_tree_node* l = e->c[0];
top_tree_node* r = e->c[1];
assert(l && r);
e->c[0] = e->c[1] = nullptr;
l->p = r->p = nullptr;
assert(e->c[2] == nullptr);
l->meld_path_end();
return {l, r};
}
friend top_tree_node* get_path(top_tree_node* a, top_tree_node* b) {
assert(a->is_vert && b->is_vert);
a->make_root();
b->expose();
if (a == b) {
assert(!b->p);
return b;
}
assert(!b->p->p);
return b->p;
}
friend top_tree_node* get_subtree(top_tree_node* rt, top_tree_node* n) {
rt->make_root();
n->expose();
return n;
}
};
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N;
cin >> N;
vector<top_tree_node> nodes(N + (N - 1));
for (int i = 0; i < N; i++) {
top_tree_node* n = &nodes[i];
n->is_path = n->is_vert = true;
n->update();
}
vector<array<int, 2>> edges(N - 1);
for (int e = 0; e < N - 1; e++) {
int u, v, t;
cin >> u >> v >> t;
u--, v--;
edges[e] = {u, v};
nodes[N + e].own_parity = t;
link(&nodes[N + e], &nodes[u], &nodes[v]);
}
int Q;
cin >> Q;
while (Q--) {
int e;
cin >> e;
e--;
auto [u, v] = edges[e];
auto pth = get_path(&nodes[u], &nodes[v]);
assert(pth == &nodes[N + e]);
pth->do_flip_edge_parity();
cout << pth->best_path << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 555555;
const int M = 1111111;
const int MOD = 998244353;
const int intINF = 1e9;
const long long llINF = 2e18;
const double pi = acos(-1.0);
const int inv2 = 5e8 + 4;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
unsigned long long readull() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
void predo() {}
int head[N], vet[M], len[M], nxt[M], tot, n;
void add(int a, int b, int c) {
nxt[++tot] = head[a];
vet[tot] = b;
len[tot] = c;
head[a] = tot;
}
struct edge {
int x, y;
} E[M];
void init() {
n = read();
for (int i = (int)1; i <= (int)n - 1; i++) {
int x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
E[i].x = x;
E[i].y = y;
}
}
int st[N], ed[N], dis[N], dep[N], id[N], tim;
void dfs(int u, int fa) {
st[u] = ++tim;
id[tim] = u;
int e = head[u];
while (e) {
int v = vet[e];
if (v != fa) {
dep[v] = dep[u] + 1;
dis[v] = dis[u] ^ len[e];
dfs(v, u);
}
e = nxt[e];
}
ed[u] = tim;
}
int ST[N][2], ED[N][2], d[N][2], dep1[N], dep2[N], r1, r2;
struct seg_tree {
struct node {
int s[2], tag;
} t[N << 2];
void pushup(int p) {
t[p].s[0] = max(t[p << 1].s[0], t[p << 1 | 1].s[0]);
t[p].s[1] = max(t[p << 1].s[1], t[p << 1 | 1].s[1]);
}
void pushdown(int p) {
if (t[p].tag) {
swap(t[p << 1].s[0], t[p << 1].s[1]);
swap(t[p << 1 | 1].s[0], t[p << 1 | 1].s[1]);
t[p << 1].tag ^= 1;
t[p << 1 | 1].tag ^= 1;
t[p].tag = 0;
}
}
void update(int l, int r, int x, int y, int p) {
if (x <= l && r <= y) {
swap(t[p].s[0], t[p].s[1]);
t[p].tag ^= 1;
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) update(l, mid, x, y, p << 1);
if (y > mid) update(mid + 1, r, x, y, p << 1 | 1);
pushup(p);
}
} T1, T2;
int id1[N], id2[N];
void build1(int l, int r, int p) {
T1.t[p].s[0] = T1.t[p].s[1] = 0;
T1.t[p].tag = 0;
if (l == r) {
if (id1[l]) T1.t[p].s[d[id1[l]][0]] = dep1[id1[l]];
return;
}
int mid = (l + r) >> 1;
build1(l, mid, p << 1);
build1(mid + 1, r, p << 1 | 1);
T1.pushup(p);
}
void build2(int l, int r, int p) {
T2.t[p].s[0] = T2.t[p].s[1] = 0;
T2.t[p].tag = 0;
if (l == r) {
if (id2[l]) T2.t[p].s[d[id2[l]][1]] = dep2[id2[l]];
return;
}
int mid = (l + r) >> 1;
build2(l, mid, p << 1);
build2(mid + 1, r, p << 1 | 1);
T2.pushup(p);
}
void solve() {
tim = 0;
dis[1] = dep[1] = 0;
dfs(1, 0);
int r1 = 1;
for (int i = (int)1; i <= (int)n; i++) {
if (dep[i] > dep[r1]) r1 = i;
}
tim = 0;
dis[r1] = dep[r1] = 0;
dfs(r1, 0);
int r2 = 1;
for (int i = (int)1; i <= (int)n; i++) {
if (dep[i] > dep[r2]) r2 = i;
}
for (int i = (int)1; i <= (int)n; i++) {
ST[i][0] = st[i];
ED[i][0] = ed[i];
d[i][0] = dis[i];
dep1[i] = dep[i];
id1[i] = id[i];
}
tim = 0;
dis[r2] = dep[r2] = 0;
dfs(r2, 0);
for (int i = (int)1; i <= (int)n; i++) {
ST[i][1] = st[i];
ED[i][1] = ed[i];
d[i][1] = dis[i];
dep2[i] = dep[i];
id2[i] = id[i];
}
build1(1, n, 1);
build2(1, n, 1);
int q = read();
while (q--) {
int id = read();
int x = E[id].x, y = E[id].y;
int u;
if (dep1[x] > dep1[y])
u = x;
else
u = y;
T1.update(1, n, ST[u][0], ED[u][0], 1);
if (dep2[x] > dep2[y])
u = x;
else
u = y;
T2.update(1, n, ST[u][1], ED[u][1], 1);
int ans = 0;
ans = max(ans, T1.t[1].s[0]);
ans = max(ans, T2.t[1].s[0]);
printf("%d\n", ans);
}
}
int main() {
predo();
int cas = 1;
while (cas--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << ", ";
}
}
template <typename T>
void debug_out(vector<vector<T>> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << endl;
}
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
debug_out(H);
cerr << " ";
debug_out(T...);
}
template <typename T>
void debug_out(set<T> a) {
vector<T> _a;
for (T t : a) _a.push_back(t);
debug_out(_a);
}
class segtree {
public:
struct node {
int black = INT_MIN;
int white = INT_MIN;
bool exchange = false;
void apply(int l, int r, int v) {
if (v >= 0) {
int t = v & 1;
v >>= 1;
if (t)
black = v;
else
white = v;
} else {
swap(black, white);
exchange ^= true;
}
}
};
node unite(const node &a, const node &b) const {
node res;
res.black = max(a.black, b.black);
res.white = max(a.white, b.white);
return res;
}
inline void push(int x, int l, int r) {
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
if (tree[x].exchange) {
tree[x + 1].apply(l, y, -1);
tree[z].apply(y + 1, r, -1);
tree[x].exchange = false;
}
}
inline void pull(int x, int z) { tree[x] = unite(tree[x + 1], tree[z]); }
int n;
vector<node> tree;
void build(int x, int l, int r) {
if (l == r) {
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y);
build(z, y + 1, r);
pull(x, z);
}
template <typename M, typename... T>
void build(int x, int l, int r, const vector<M> &v, const T &...t) {
if (l == r) {
tree[x].apply(l, r, v[l], t...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y, v, t...);
build(z, y + 1, r, v, t...);
pull(x, z);
}
template <typename M, typename... T>
segtree(const vector<M> &v, const T &...t) {
n = v.size();
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1, v, t...);
}
segtree(int _n) : n(_n) {
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1);
}
segtree(){};
node get(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
return tree[x];
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
node res{};
if (rr <= y) {
res = get(x + 1, l, y, ll, rr);
} else {
if (ll > y) {
res = get(z, y + 1, r, ll, rr);
} else {
res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
}
}
pull(x, z);
return res;
}
node get(int ll, int rr) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return get(0, 0, n - 1, ll, rr);
}
node get(int p) {
assert(0 <= p && p <= n - 1);
return get(0, 0, n - 1, p, p);
}
template <typename... M>
void modify(int x, int l, int r, int ll, int rr, const M &...v) {
if (ll <= l && r <= rr) {
tree[x].apply(l, r, v...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
if (ll <= y) {
modify(x + 1, l, y, ll, rr, v...);
}
if (rr > y) {
modify(z, y + 1, r, ll, rr, v...);
}
pull(x, z);
}
template <typename... M>
void modify(int ll, int rr, const M &...v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify(0, 0, n - 1, ll, rr, v...);
}
};
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<vector<int>> g(n);
vector<int> from(n - 1);
vector<int> to(n - 1);
vector<int> d(n - 1);
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--;
v--;
g[u].push_back(i);
g[v].push_back(i);
from[i] = u;
to[i] = v;
d[i] = t;
}
vector<int> dep(n);
function<void(int, int)> dfs0 = [&](int v, int p) {
if (~p)
dep[v] = dep[p] + 1;
else
dep[v] = 0;
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs0(id, v);
}
};
dfs0(0, -1);
int left_root = max_element(dep.begin(), dep.end()) - dep.begin();
dfs0(left_root, -1);
int right_root = max_element(dep.begin(), dep.end()) - dep.begin();
vector<int> order;
vector<int> din(n);
vector<int> dout(n);
vector<int> par(n);
function<void(int, int)> dfs = [&](int v, int p) {
par[v] = p;
if (~p)
dep[v] = dep[p] + 1;
else
dep[v] = 0;
din[v] = order.size();
order.push_back(v);
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs(id, v);
}
dout[v] = order.size() - 1;
};
vector<int> R_order, R_in, R_out, R_dep, R_par, L_order, L_in, L_out, L_dep,
L_par;
dfs(right_root, -1);
R_order = order;
R_in = din;
R_out = dout;
R_dep = dep;
R_par = par;
order.clear();
dfs(left_root, -1);
L_order = order;
L_in = din;
L_out = dout;
L_dep = dep;
L_par = par;
vector<int> pos(n);
function<void(int, int, int)> dfs1 = [&](int v, int p, int t) {
pos[v] = t;
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs1(id, v, t ^ d[i]);
}
};
dfs1(0, -1, 0);
for (int i = 0; i < n; i++) {
L_dep[i] = L_dep[i] * 2 + pos[i];
R_dep[i] = R_dep[i] * 2 + pos[i];
}
for (int i = 0; i < n; i++) {
L_order[i] = L_dep[L_order[i]];
R_order[i] = R_dep[R_order[i]];
}
segtree Lst(L_order);
segtree Rst(R_order);
int q;
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int u = from[id];
int v = to[id];
int ret = 0;
{
if (L_par[v] == u) swap(u, v);
Lst.modify(L_in[u], L_out[u], -1);
segtree::node x = Lst.get(0, n - 1);
int cc = pos[left_root] ? x.black : x.white;
ret = max(ret, cc);
}
{
if (R_par[v] == u) swap(u, v);
Rst.modify(R_in[u], R_out[u], -1);
segtree::node x = Rst.get(0, n - 1);
int cc = pos[right_root] ? x.black : x.white;
ret = max(ret, cc);
}
cout << ret << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1 << 19;
vector<pair<int, int>> adj[500000];
pair<int, int> E[500000];
int node_cnt, num[500000], R[500000], parent[500000], depth[500000],
tree[2 * SZ][3], Q[500000], ans[500000];
void lazy_propagation(int bit, int s, int e) {
if (tree[bit][2]) {
swap(tree[bit][0], tree[bit][1]);
if (s < e) {
tree[2 * bit][2] ^= 1;
tree[2 * bit + 1][2] ^= 1;
}
tree[bit][2] = 0;
}
}
int bfs(int c) {
queue<int> Q;
memset(depth, -1, sizeof(depth));
depth[c] = 0;
Q.push(c);
while (!Q.empty()) {
c = Q.front();
Q.pop();
for (auto [n, w] : adj[c])
if (depth[n] == -1) {
depth[n] = depth[c] + 1;
Q.push(n);
}
}
return c;
}
void dfs(int c, int v) {
num[c] = ++node_cnt;
tree[SZ + num[c]][v] = depth[c];
for (auto [n, w] : adj[c])
if (num[n] == 0) {
parent[n] = c;
depth[n] = depth[c] + 1;
dfs(n, w ^ v);
}
R[c] = node_cnt;
}
void flip(int n1, int n2, int bit = 1, int s = 0, int e = SZ - 1) {
int m = (s + e) >> 1;
lazy_propagation(bit, s, e);
if (n2 < n1 || n2 < s || e < n1) return;
if (n1 <= s && e <= n2) {
tree[bit][2] = 1;
lazy_propagation(bit, s, e);
return;
}
flip(n1, n2, 2 * bit, s, m);
flip(n1, n2, 2 * bit + 1, m + 1, e);
tree[bit][0] = max(tree[2 * bit][0], tree[2 * bit + 1][0]);
tree[bit][1] = max(tree[2 * bit][1], tree[2 * bit + 1][1]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
((void)0);
((void)0);
((void)0);
int N, M, r;
cin >> N;
for (int i = 1; i < N; i++) {
int v;
cin >> E[i].first >> E[i].second >> v;
adj[--E[i].first].emplace_back(--E[i].second, v);
adj[E[i].second].emplace_back(E[i].first, v);
}
r = bfs(0);
depth[parent[r] = r] = 0;
dfs(r, 0);
for (int i = SZ; --i;)
for (int j = 0; j < 2; j++)
tree[i][j] = max(tree[2 * i][j], tree[2 * i + 1][j]);
cin >> M;
for (int c = 0; c < M; c++) {
int i;
cin >> Q[c];
if (parent[E[Q[c]].first] == E[Q[c]].second)
i = E[Q[c]].first;
else
i = E[Q[c]].second;
flip(num[i], R[i]);
ans[c] = tree[1][0];
}
r = bfs(r);
memset(num, 0, sizeof(num));
memset(tree, 0, sizeof(tree));
node_cnt = depth[parent[r] = r] = 0;
dfs(r, 0);
for (int i = SZ; --i;)
for (int j = 0; j < 2; j++)
tree[i][j] = max(tree[2 * i][j], tree[2 * i + 1][j]);
for (int c = 0; c < M; c++) {
int i;
if (parent[E[Q[c]].first] == E[Q[c]].second)
i = E[Q[c]].first;
else
i = E[Q[c]].second;
flip(num[i], R[i]);
cout << max(ans[c], tree[1][0]) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 500005;
tuple<int, int, int> edges[MX];
int queries[MX];
int ans[MX];
vector<pair<int, int>> neigh[MX];
int depth[MX];
int pos[MX];
int sz[MX];
int val[MX];
int order[MX];
void calc_depth(int v, int p, int d) {
depth[v] = d;
for (auto e : neigh[v]) {
if (e.first == p) continue;
calc_depth(e.first, v, d + 1);
}
}
int cnt;
void dfs(int v, int p, int s) {
pos[v] = cnt;
order[cnt] = v;
sz[v] = 1;
val[v] = s;
cnt++;
for (auto e : neigh[v]) {
if (e.first == p) continue;
dfs(e.first, v, (s + e.second) % 2);
sz[v] += sz[e.first];
}
}
struct {
int L, R;
int pl, pr;
int d0, d1, flip;
} T[2 * MX];
int tsz;
int buildTree(int L, int R) {
int cur = tsz++;
T[cur].L = L;
T[cur].R = R;
if (L < R) {
T[cur].pl = buildTree(L, (L + R) / 2);
T[cur].pr = buildTree((L + R) / 2 + 1, R);
T[cur].d0 = max(T[T[cur].pl].d0, T[T[cur].pr].d0);
T[cur].d1 = max(T[T[cur].pl].d1, T[T[cur].pr].d1);
T[cur].flip = 0;
} else {
int v = order[L];
if (val[v] == 0) {
T[cur].d0 = depth[v];
T[cur].d1 = 0;
} else {
T[cur].d0 = 0;
T[cur].d1 = depth[v];
}
T[cur].flip = 0;
}
return cur;
}
void update(int L, int R, int cur) {
if (L <= T[cur].L && R >= T[cur].R) {
swap(T[cur].d0, T[cur].d1);
T[cur].flip ^= 1;
return;
}
if (T[cur].flip) {
swap(T[T[cur].pl].d0, T[T[cur].pl].d1);
swap(T[T[cur].pr].d0, T[T[cur].pr].d1);
T[T[cur].pl].flip ^= 1;
T[T[cur].pr].flip ^= 1;
T[cur].flip = 0;
}
if (L <= T[T[cur].pl].R) {
update(L, R, T[cur].pl);
}
if (T[T[cur].pr].L <= R) {
update(L, R, T[cur].pr);
}
T[cur].d0 = max(T[T[cur].pl].d0, T[T[cur].pr].d0);
T[cur].d1 = max(T[T[cur].pl].d1, T[T[cur].pr].d1);
}
int n, m;
void Solve(int root) {
calc_depth(root, 0, 0);
cnt = 0;
dfs(root, 0, 0);
tsz = 0;
buildTree(1, n);
for (int i = 0; i < m; i++) {
int u, v;
tie(u, v, ignore) = edges[queries[i]];
if (depth[u] > depth[v]) {
swap(u, v);
}
int L = pos[v];
int R = pos[v] + sz[v] - 1;
update(L, R, 0);
ans[i] = max(ans[i], T[0].d0);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ignore = scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v, t;
ignore = scanf("%d %d %d", &u, &v, &t);
edges[i] = tie(u, v, t);
neigh[u].emplace_back(v, t);
neigh[v].emplace_back(u, t);
}
int A = 1, B = 1;
calc_depth(1, 0, 0);
for (int v = 1; v <= n; v++) {
if (depth[v] > depth[A]) A = v;
}
calc_depth(A, 0, 0);
for (int v = 1; v <= n; v++) {
if (depth[v] > depth[B]) B = v;
}
ignore = scanf("%d", &m);
for (int i = 0; i < m; i++) {
ignore = scanf("%d", &queries[i]);
}
Solve(A);
Solve(B);
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 9;
const long long int MOD = 1e9 + 696969;
mt19937_64 rng(time(0));
int random(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
const long long INF = 1e18;
const int maxn = 500100;
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 atcoder;
int n, d[maxn];
bool odw[maxn];
vector<int> v[maxn];
int init[maxn];
int A[maxn], B[maxn];
int pre[maxn], maxpre[maxn];
int DL;
int zap[maxn], q;
struct S {
int zero, one;
};
using F = bool;
S op(S l, S r) { return S{max(l.zero, r.zero), max(l.one, r.one)}; }
S e() { return S{0, 0}; }
S mapping(F l, S r) {
if (!l) return r;
return S{r.one, r.zero};
}
F composition(F l, F r) { return (l ^ r); }
F id() { return false; }
void initdfs(int x) {
odw[x] = 1;
for (auto u : v[x]) {
if (!odw[u]) {
d[u] = d[x] + 1;
initdfs(u);
}
}
}
void dfs(int x) {
odw[x] = 1;
pre[x] = ++DL;
maxpre[x] = pre[x];
for (auto u : v[x]) {
if (!odw[u]) {
d[u] = d[x] + 1;
dfs(u);
maxpre[x] = max(maxpre[x], maxpre[u]);
}
}
}
void toggle(int edge,
lazy_segtree<S, op, e, F, mapping, composition, id> &seg) {
int node = B[edge];
int a = pre[node], b = maxpre[node] + 1;
seg.apply(a, b, true);
}
vector<int> solve(int root) {
0 && cerr;
DL = -1;
for (int i = (1); i <= (n); ++i)
odw[i] = 0, d[i] = 0, maxpre[i] = 0, pre[i] = 0;
dfs(root);
for (int i = (1); i <= (n - 1); ++i) {
if (d[A[i]] > d[B[i]]) swap(A[i], B[i]);
}
vector<int> res(q + 1, 0);
vector<S> vec(n);
for (int i = (1); i <= (n); ++i) {
int kt = pre[i];
vec[kt] = {d[i], 0};
}
lazy_segtree<S, op, e, F, mapping, composition, id> seg(vec);
for (int i = (1); i <= (n - 1); ++i) {
if (init[i]) toggle(i, seg);
}
for (int i = (1); i <= (q); ++i) {
toggle(zap[i], seg);
S wyn = seg.all_prod();
res[i] = wyn.zero;
}
return res;
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
cin >> n;
for (int i = (1); i <= (n - 1); ++i) {
cin >> A[i] >> B[i] >> init[i];
v[A[i]].push_back(B[i]);
v[B[i]].push_back(A[i]);
}
cin >> q;
for (int i = (1); i <= (q); ++i) cin >> zap[i];
for (int i = (1); i <= (n); ++i) odw[i] = 0, d[i] = 0;
initdfs(1);
int opt = 1;
for (int i = (2); i <= (n); ++i) {
if (d[i] > d[opt]) opt = i;
}
int one_end = opt;
for (int i = (1); i <= (n); ++i) odw[i] = 0, d[i] = 0;
initdfs(opt);
opt = 1;
for (int i = (2); i <= (n); ++i) {
if (d[i] > d[opt]) opt = i;
}
int second_end = opt;
auto a1 = solve(one_end);
auto a2 = solve(second_end);
for (int i = (1); i <= (q); ++i) cout << max(a1[i], a2[i]) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1111222, inf = 100111222;
const int max_v = 2 * max_n;
struct state {
int max_suf, max_pref, max_h, res;
state() : max_suf(0), max_pref(0), max_h(0), res(0) {}
state(int max_suf, int max_pref, int max_h, int res)
: max_suf(max_suf), max_pref(max_pref), max_h(max_h), res(res) {}
};
struct node {
state a[2];
int min_h;
node() {}
node(int h, int col) {
min_h = h;
a[col] = {-h, -h, h, 0};
a[col ^ 1] = {-inf, -inf, -inf, -inf};
}
void flip() { swap(a[0], a[1]); }
int get_res() const { return max(a[0].res, a[1].res); }
};
state merge(const state &a, const state &b, int amnh, int bmnh) {
return {
max(b.max_suf, max(a.max_suf, a.max_h - 2 * bmnh)),
max(a.max_pref, max(b.max_pref, b.max_h - 2 * amnh)),
max(a.max_h, b.max_h),
max(a.res, max(b.res, max(a.max_suf + b.max_h, a.max_h + b.max_pref)))};
}
node merge(const node &a, const node &b) {
node res;
res.min_h = min(a.min_h, b.min_h);
res.a[0] = merge(a.a[0], b.a[0], a.min_h, b.min_h);
res.a[1] = merge(a.a[1], b.a[1], a.min_h, b.min_h);
return res;
}
ostream &operator<<(ostream &os, const state &s) {
os << s.max_suf << " " << s.max_pref << " " << s.max_h << " " << s.res;
return os;
}
ostream &operator<<(ostream &os, const node &nd) {
os << nd.min_h << "col0 = " << nd.a[0] << " "
<< "col1 = " << nd.a[1];
return os;
}
struct tree {
node a[max_v];
bool f[max_v];
void build(int v, int l, int r, const vector<int> &h,
const vector<int> &col) {
if (l == r) {
assert(v < max_v);
a[v] = node(h[l], col[l]);
f[v] = 0;
return;
}
int mid = (l + r) / 2;
build(2 * v, l, mid, h, col);
build(2 * v + 1, mid + 1, r, h, col);
a[v] = merge(a[2 * v], a[2 * v + 1]);
}
void push(int v) {
if (f[v]) {
f[2 * v] ^= 1;
f[2 * v + 1] ^= 1;
a[2 * v].flip();
a[2 * v + 1].flip();
f[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
f[v] ^= 1;
a[v].flip();
return;
}
push(v);
int mid = (tl + tr) / 2;
if (r <= mid) {
update(2 * v, tl, mid, l, r);
} else if (l > mid) {
update(2 * v + 1, mid + 1, tr, l, r);
} else {
update(2 * v, tl, mid, l, mid);
update(2 * v + 1, mid + 1, tr, mid + 1, r);
}
a[v] = merge(a[2 * v], a[2 * v + 1]);
}
};
int n, m, col[max_n], h[max_n], l[max_n], r[max_n];
int U[max_n], V[max_n], x[max_n];
vector<int> g[max_n], order_h, order_col;
tree t;
void dfs(int v, int p) {
l[v] = order_h.size();
order_h.push_back(h[v]);
order_col.push_back(col[v]);
for (int id : g[v]) {
const int to = U[id] ^ V[id] ^ v;
if (to == p) {
continue;
}
if (to != V[id]) {
swap(U[id], V[id]);
}
col[to] = col[v] ^ x[id];
h[to] = h[v] + 1;
dfs(to, v);
order_h.push_back(h[v]);
order_col.push_back(col[v]);
}
r[v] = order_h.size() - 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &U[i], &V[i], &x[i]);
--U[i];
--V[i];
g[U[i]].push_back(i);
g[V[i]].push_back(i);
}
dfs(0, -1);
t.build(1, 0, order_h.size() - 1, order_h, order_col);
scanf("%d", &m);
while (m--) {
int id;
scanf("%d", &id);
t.update(1, 0, order_h.size() - 1, l[V[id]], r[V[id]]);
int ans = t.a[1].get_res();
ans = max(ans, 0);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<vector<pair<int, int> > > graph;
vector<pair<int, int> > edges;
class SegmentTree {
struct node_t {
int best[2];
int lazy;
node_t() {
best[0] = 0;
best[1] = 0;
lazy = 0;
}
node_t operator+(const node_t &other) const {
node_t ans;
for (int i = 0; i < 2; i++) {
ans.best[i] = max(this->best[i], other.best[i]);
}
ans.lazy = 0;
return ans;
}
void propag(int lazy) {
if (lazy) {
swap(best[0], best[1]);
this->lazy ^= lazy;
}
}
};
int n;
vector<node_t> aint;
void propag(int nod, int st, int dr) {
if (st == dr || aint[nod].lazy == 0) {
return;
}
aint[nod * 2].propag(aint[nod].lazy);
aint[nod * 2 + 1].propag(aint[nod].lazy);
aint[nod].lazy = 0;
}
void build(int nod, int st, int dr, const vector<int> &lvl,
const vector<int> &tp) {
if (st == dr) {
aint[nod].best[tp[st]] = lvl[st];
aint[nod].best[tp[st] ^ 1] = 0;
return;
}
int mid = (st + dr) / 2;
build(nod * 2, st, mid, lvl, tp);
build(nod * 2 + 1, mid + 1, dr, lvl, tp);
aint[nod] = aint[nod * 2] + aint[nod * 2 + 1];
}
void flip(int nod, int st, int dr, int l, int r) {
propag(nod, st, dr);
if (dr < l || st > r) {
return;
}
if (l <= st && dr <= r) {
aint[nod].propag(1);
return;
}
int mid = (st + dr) / 2;
flip(nod * 2, st, mid, l, r);
flip(nod * 2 + 1, mid + 1, dr, l, r);
aint[nod] = aint[nod * 2] + aint[nod * 2 + 1];
}
public:
SegmentTree(int n, const vector<int> &lvl, const vector<int> &tp) {
this->n = n;
aint = vector<node_t>(4 * n + 5, node_t());
build(1, 1, n, lvl, tp);
}
SegmentTree() { ; }
void flip(int l, int r) { flip(1, 1, n, l, r); }
int query() { return aint[1].best[0]; }
};
class TreeWrapper {
SegmentTree aint;
vector<int> lvl;
vector<int> tp;
vector<int> l;
vector<int> r;
int lst = 0;
void dfs(int nod, pair<int, int> tata,
const vector<vector<pair<int, int> > > &graph) {
l[nod] = ++lst;
lvl[l[nod]] = 1 + lvl[l[tata.first]];
tp[l[nod]] = tp[l[tata.first]] ^ tata.second;
for (auto it : graph[nod]) {
if (it.first == tata.first) {
continue;
}
dfs(it.first, {nod, it.second}, graph);
}
r[nod] = lst;
}
public:
TreeWrapper(int root, const vector<vector<pair<int, int> > > &graph) {
lst = 0;
l = vector<int>(graph.size(), 0);
r = vector<int>(graph.size(), 0);
lvl = vector<int>(graph.size(), 0);
tp = vector<int>(graph.size(), 0);
dfs(root, {0, 0}, graph);
aint = SegmentTree((int)graph.size() - 1, lvl, tp);
}
void flip(pair<int, int> a) {
if (lvl[l[a.first]] > lvl[l[a.second]]) {
swap(a.first, a.second);
}
aint.flip(l[a.second], r[a.second]);
}
int query() { return aint.query(); }
};
pair<int, int> dfs(int nod, int tata) {
pair<int, int> ans = {0, nod};
for (auto it : graph[nod]) {
if (it.first == tata) {
continue;
}
pair<int, int> tmp = dfs(it.first, nod);
tmp.first++;
ans = max(ans, tmp);
}
return ans;
}
int main() {
scanf("%d", &n);
graph = vector<vector<pair<int, int> > >(n + 1, vector<pair<int, int> >());
edges = vector<pair<int, int> >(n, {0, 0});
for (int i = 1; i < n; i++) {
int x, y, t;
scanf("%d %d %d", &x, &y, &t);
graph[x].push_back({y, t});
graph[y].push_back({x, t});
edges[i] = {x, y};
}
int a = dfs(1, 0).second;
int b = dfs(a, 0).second;
TreeWrapper fst(a, graph), snd(b, graph);
scanf("%d", &q);
while (q--) {
int id;
scanf("%d", &id);
fst.flip(edges[id]);
snd.flip(edges[id]);
printf("%d\n", max(fst.query(), snd.query()) - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int next_x[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const int next_y[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const double PI = acos(-1.0);
const int MAXN = 1e6 + 5;
const int N = 4e6 + 5;
const long double eps = 1e-8;
const long double fix = 1e-2;
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;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
return 1;
}
inline bool read(char &x) {
while ((x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
x == '\n' || x == '\r')
;
return x != EOF;
}
inline bool read(char *x) {
while ((*x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*x == ' ' || *x == '\r')
;
if (*x == EOF) return 0;
while (!(*x == '\n' || *x == ' ' || *x == '\r' || *x == EOF))
*(++x) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*x = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &x, B &...y) {
return read(x) && read(y...);
}
template <typename A>
inline bool write(A x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char x) {
putc(x);
return 0;
}
inline bool write(const char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
inline bool write(char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A x, B... y) {
return write(x) || write(y...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
namespace seg {
int mx[MAXN * 4][2], rev[MAXN * 4];
void dorev(int cnt) { rev[cnt] ^= 1, swap(mx[cnt][0], mx[cnt][1]); }
void up(int cnt) {
for (int k = (0), I = (1) + 1; k < I; ++k)
mx[cnt][k] = max(mx[(cnt << 1)][k], mx[(cnt << 1 | 1)][k]);
}
void down(int cnt) {
if (rev[cnt]) dorev((cnt << 1)), dorev((cnt << 1 | 1)), rev[cnt] = 0;
}
void build(int l, int r, int a[], int d[], int cnt) {
rev[cnt] = 0;
if (l == r) {
mx[cnt][a[l]] = d[l], mx[cnt][!a[l]] = 0;
return;
}
build(l, ((l + r) / 2), a, d, (cnt << 1)),
build(((l + r) / 2) + 1, r, a, d, (cnt << 1 | 1)), up(cnt);
}
void flip(int l, int r, int nl, int nr, int cnt) {
if (l == nl && r == nr) return dorev(cnt);
down(cnt);
if (nr <= ((l + r) / 2))
flip(l, ((l + r) / 2), nl, nr, (cnt << 1));
else if (nl > ((l + r) / 2))
flip(((l + r) / 2) + 1, r, nl, nr, (cnt << 1 | 1));
else
flip(l, ((l + r) / 2), nl, ((l + r) / 2), (cnt << 1)),
flip(((l + r) / 2) + 1, r, ((l + r) / 2) + 1, nr, (cnt << 1 | 1));
up(cnt);
}
} // namespace seg
int n, m, tim = 0;
int u[MAXN], v[MAXN], w[MAXN], q[MAXN];
int a[MAXN], d[MAXN], _a[MAXN], _d[MAXN], ans[MAXN], st[MAXN], ed[MAXN],
node[MAXN];
struct edge {
int u, v, w, next;
} e[MAXN * 2];
int pre[MAXN], edge_cnt = 0;
void addedge(int u, int v, int w = 0) {
edge_cnt = edge_cnt + 1, e[edge_cnt].u = u, e[edge_cnt].v = v,
e[edge_cnt].w = w, e[edge_cnt].next = pre[u], pre[u] = edge_cnt;
};
void dfs(int u, int fa) {
st[u] = ++tim, node[tim] = u, d[u] = d[fa] + 1;
for (long long i = pre[u], v = e[i].v, w = e[i].w; i;
i = e[i].next, v = e[i].v, w = e[i].w)
if (v != fa) a[v] = a[u] ^ w, dfs(v, u);
ed[u] = tim;
}
void solve(int root) {
tim = 0, a[root] = 0, d[0] = -1, dfs(root, 0);
for (int i = (1), I = (n) + 1; i < I; ++i)
_a[i] = a[node[i]], _d[i] = d[node[i]];
seg::build(1, n, _a, _d, 1);
for (int i = (1), I = (m) + 1; i < I; ++i) {
int x = d[u[q[i]]] > d[v[q[i]]] ? u[q[i]] : v[q[i]];
seg::flip(1, n, st[x], ed[x], 1), ans[i] = max(ans[i], seg::mx[1][0]);
}
}
int find(int u, int fa) {
int ans = u;
d[u] = d[fa] + 1;
for (int i = pre[u], v = e[i].v; i; i = e[i].next, v = e[i].v)
if (v != fa) {
int res = find(v, u);
if (d[res] > d[ans]) ans = res;
}
return ans;
}
int work() {
scanf("%d", &n);
for (int i = (1), I = (n - 1) + 1; i < I; ++i) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
addedge(u[i], v[i], w[i]), addedge(v[i], u[i], w[i]);
}
scanf("%d", &m);
for (int i = (1), I = (m) + 1; i < I; ++i) scanf("%d", &q[i]);
int root;
solve(root = find(1, 0)), solve(find(root, 0));
for (int i = (1), I = (m) + 1; i < I; ++i) printf("%d\n", ans[i]);
return 0;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 6e5;
int n, m, root, tim, edge;
int U[MAXN | 1], V[MAXN | 1], W[MAXN | 1], dfn[MAXN | 1], size[MAXN | 1],
xorv[MAXN | 1], ID[MAXN | 1], depth[MAXN | 1], fst[MAXN | 1], ans[MAXN | 1];
std::vector<int> que;
struct Edge {
int to, w, nxt;
Edge(int _to = 0, int _w = 0, int _nxt = 0) : to(_to), w(_w), nxt(_nxt) {}
} e[MAXN << 1];
inline int read() {
register int x = 0, v = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') v = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * v;
}
inline void add_edge(int a, int b, int c) {
e[++edge] = Edge(b, c, fst[a]);
fst[a] = edge;
}
int BFS(int x) {
int ans = 1;
bool vis[MAXN | 1];
std::queue<int> q;
memset(vis, 0, sizeof(vis));
q.push(x);
vis[x] = 1;
do {
int from = q.front();
q.pop();
ans = from;
for (int k = fst[from]; k; k = e[k].nxt) {
int to = e[k].to;
if (vis[to]) continue;
vis[to] = 1;
q.push(to);
}
} while (!q.empty());
return ans;
}
void dfs(int x, int fa) {
ID[dfn[x] = ++tim] = x;
size[x] = 1;
depth[x] = depth[fa] + 1;
for (int k = fst[x]; k; k = e[k].nxt) {
int to = e[k].to, w = e[k].w;
if (to == fa) continue;
xorv[to] = xorv[x] ^ w;
dfs(to, x);
size[x] += size[to];
}
}
namespace SegmentTree {
int max0[MAXN << 2 | 1], max1[MAXN << 1 | 1], tag[MAXN << 1 | 1];
void push_up(int o) {
max0[o] = std::max(max0[o << 1], max0[o << 1 | 1]);
max1[o] = std::max(max1[o << 1], max1[o << 1 | 1]);
}
void push_down(int o) {
if (!tag[o]) return;
std::swap(max0[o << 1], max1[o << 1]);
std::swap(max0[o << 1 | 1], max1[o << 1 | 1]);
tag[o << 1] ^= 1;
tag[o << 1 | 1] ^= 1;
tag[o] = 0;
}
void build(int o, int l, int r) {
tag[o] = 0;
max0[o] = max1[o] = 0;
if (l == r) {
if (xorv[ID[l]])
max1[o] = depth[ID[l]];
else
max0[o] = depth[ID[l]];
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
push_up(o);
}
void flip(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
std::swap(max0[o], max1[o]);
tag[o] ^= 1;
return;
}
int mid = (l + r) >> 1;
push_down(o);
if (ql <= mid) flip(o << 1, l, mid, ql, qr);
if (mid < qr) flip(o << 1 | 1, mid + 1, r, ql, qr);
push_up(o);
}
int query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return max1[o];
int mid = (l + r) >> 1, res = 0;
push_down(o);
if (ql <= mid) res = query(o << 1, l, mid, ql, qr);
if (mid < qr) res = std::max(res, query(o << 1 | 1, mid + 1, r, ql, qr));
return res;
}
} // namespace SegmentTree
using namespace SegmentTree;
int main() {
n = read();
for (int i = 1; i < n; ++i) {
U[i] = read();
V[i] = read();
W[i] = read();
add_edge(U[i], V[i], W[i]);
add_edge(V[i], U[i], W[i]);
}
root = BFS(1);
int lst = root;
dfs(root, 0);
build(1, 1, n);
m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), u = U[x], v = V[x];
que.push_back(x);
if (depth[u] < depth[v]) std::swap(u, v);
flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
ans[i] = max0[1] - 1;
}
root = BFS(root);
xorv[root] = 0;
tim = 0;
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x = que[i - 1], u = U[x], v = V[x];
if (depth[u] < depth[v]) std::swap(u, v);
flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
ans[i] = std::max(max0[1] - 1, ans[i]);
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#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>;
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 &rakeToPath(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;
}
Info &rake(Info a, Info b) {
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]);
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() {
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; }
SplayTree *sch(int d, SplayTree *c) { return ch[d] = c, c->fa = this; }
void rotate() {
SplayTree *p = fa;
p->pushdown(), pushdown();
bool d = dir();
fa = p->fa;
if (fa != null) {
fa->ch[fa->ch[2] == p ? 2 : p->dir()] = this;
}
p->sch(d, ch[!d])->pushup();
sch(!d, p)->pushup();
}
SplayTree *splay(SplayTree *p = null) {
for (pushdown(); fa != p && notRoot(); rotate()) {
if (fa->fa != p && fa->notRoot()) {
fa->fa->pushdown();
(fa->dir() == dir() ? fa : this)->rotate();
}
}
return this;
}
SplayTree *splayExt(int d) {
SplayTree *o = this;
while (o->pushdown(), o->ch[d] != null) o = o->ch[d];
return o->splay(fa);
}
virtual void pushup() {}
virtual void pushdown() {}
};
SplayTree *SplayTree::null;
struct CompressTree : SplayTree {
void pushup() {
info.compress(ch[0]->info, Info().rakeToPath(ch[2]->info, ch[1]->info));
}
void pushdown() {
if (rev) {
rev = false;
ch[0]->reverse(), ch[1]->reverse();
}
}
};
struct RakeTree : SplayTree {
void pushup() {
info.rake(ch[0]->info, Info().rake(ch[2]->info, ch[1]->info));
}
};
void splice(SplayTree *o) {
o->splay();
o = o->fa->splay();
SplayTree *c = o->ch[2];
c->pushdown();
if (o->ch[1] != SplayTree::null) {
std::swap(o->ch[1]->fa, c->ch[2]->fa);
std::swap(o->ch[1], c->ch[2]);
} else {
o->sch(1, c->ch[2]);
if (c->ch[0] != SplayTree::null) {
c->ch[0]->splayExt(1);
c->ch[0]->sch(1, c->ch[1]);
o->ch[2] = c->ch[0];
} else {
c->ch[1]->pushdown();
o->ch[2] = c->ch[1];
}
c = o->ch[2], c->fa = o;
}
c->pushup(), o->pushup();
o->ch[1]->rotate();
}
void access(SplayTree *o) {
o->splay();
if (o->ch[1] != SplayTree::null) {
SplayTree *c = new RakeTree;
c->sch(0, o->ch[2]);
c->sch(2, o->ch[1]);
c->pushup();
o->ch[1] = SplayTree::null;
o->sch(2, c);
o->pushup();
}
while (o->fa != SplayTree::null) splice(o->fa);
}
void evert(SplayTree *o) { access(o), o->reverse(), o->pushdown(); }
void link(SplayTree *x, SplayTree *y, int c) {
access(x);
evert(y);
y->pushdown();
SplayTree *e = new CompressTree;
e->info.len = 1, e->info.c = c;
y->sch(0, e)->pushup();
x->sch(1, y)->pushup();
}
constexpr int N(3e5 + 5);
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, m;
std::cin >> n;
SplayTree *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--;
evert(t + u[i]), access(t + v[i]);
t[v[i]].pushdown();
t[u[i]].pushdown();
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;
int n;
int u[600001], v[600001], z[600001];
int id1, id2;
int dist[600001];
vector<pair<int, int> > nxt[600001];
void DFS(int u, int par, int dd) {
dist[u] = dd;
for (auto t : nxt[u]) {
int tt = t.first;
if (tt != par) DFS(tt, u, dd + 1);
}
}
int l[600001 * 2][2], r[600001 * 2][2], ma[600001 * 2][2], mi[600001 * 2][2],
fu[600001 * 2][2];
int lu[600001][2], ru[600001][2], a[600001][2];
int ff;
int h[2];
void build2(int id, int u, int lb, int rb) {
if (lb == rb) {
ma[u][id] = mi[u][id] = a[lb][id];
return;
}
int mid = (lb + rb) / 2;
build2(id, l[u][id] = ++h[id], lb, mid);
build2(id, r[u][id] = ++h[id], mid + 1, rb);
int fl = l[u][id];
int fr = r[u][id];
ma[u][id] = max(ma[fl][id], ma[fr][id]);
mi[u][id] = min(mi[fl][id], mi[fr][id]);
}
void eval(int id, int u) {
int lr = l[u][id];
int rr = r[u][id];
int mal = ma[lr][id];
int mil = mi[lr][id];
if (fu[lr][id]) {
int t = mal;
mal = -mil;
mil = -t;
}
int mar = ma[rr][id];
int mir = mi[rr][id];
if (fu[rr][id]) {
int t = mar;
mar = -mir;
mir = -t;
}
ma[u][id] = max(mal, mar);
mi[u][id] = min(mil, mir);
}
void push_down(int id, int u) {
int lr = l[u][id];
int rr = r[u][id];
fu[lr][id] ^= fu[u][id];
fu[rr][id] ^= fu[u][id];
fu[u][id] = 0;
eval(id, u);
}
void update(int id, int u, int lb, int rb, int lq, int rq) {
if (rq < lb || rb < lq) {
return;
}
if (lq <= lb && rb <= rq) {
fu[u][id] ^= 1;
return;
}
push_down(id, u);
int mid = (lb + rb) / 2;
update(id, l[u][id], lb, mid, lq, rq);
update(id, r[u][id], mid + 1, rb, lq, rq);
eval(id, u);
}
int query(int id, int u) { return (fu[u][id] ? -mi[u][id] : ma[u][id]); }
void DFS3(int id, int u, int par, int depth, int multi) {
ff++;
lu[u][id] = ff;
a[ff][id] = depth * multi;
for (auto t : nxt[u]) {
int tt = t.first;
int nm = multi * (z[t.second] == 1 ? -1 : 1);
if (tt != par) DFS3(id, tt, u, depth + 1, nm);
}
ru[u][id] = ff;
}
void build(int u, int id) {
h[id] = ff = 0;
DFS3(id, u, -1, 0, 1);
build2(id, h[id], 1, n);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d", &u[i], &v[i], &z[i]);
nxt[u[i]].push_back(make_pair(v[i], i));
nxt[v[i]].push_back(make_pair(u[i], i));
}
DFS(1, -1, 0);
id1 = 1;
for (int i = 2; i <= n; i++)
if (dist[i] > dist[id1]) id1 = i;
for (int i = 1; i <= n; i++) dist[i] = 0;
DFS(id1, -1, 0);
id2 = 1;
for (int i = 2; i <= n; i++)
if (dist[i] > dist[id2]) id2 = i;
build(id1, 0);
build(id2, 1);
int m;
scanf("%d", &m);
while (m--) {
int id;
scanf("%d", &id);
int uu = u[id];
int vv = v[id];
int ret = 0;
for (int j = 0; j <= 1; j++) {
int x = (lu[uu][j] < lu[vv][j] ? vv : uu);
int ll = lu[x][j];
int rr = ru[x][j];
update(j, 0, 1, n, ll, rr);
ret = max(ret, query(j, 0));
}
printf("%d\n", ret);
}
}
|
#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() {
cin.tie(0);
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);
VI is_odd(n);
for (int i = 0; i < (n - 1); ++i) {
int u = es[i].u, v = es[i].v, s = es[i].state;
if (hld.parent[u] == v) {
swap(u, v);
swap(es[i].u, es[i].v);
}
is_odd[v] = s;
}
queue<int> que;
que.push(a);
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : to[u]) {
if (v == hld.parent[u]) continue;
is_odd[v] ^= is_odd[u];
que.push(v);
}
}
vector<S> init_vec(n);
for (int i = 0; i < (n); ++i) {
if (is_odd[i]) {
init_vec[hld.idx[i]] = {-1, hld.depth[i]};
} else {
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 < (m); ++i) {
int ei = query[i];
int v = es[ei].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>
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;
template <class T>
void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = (1 << 20) + 5;
int cur[N], in[N], out[N], rev[N], owo[N], col[N], n, Q, x, y;
vector<pair<int, int> > e[N];
namespace tree {
int d[N], in[N], out[N];
int mn[N][21], lg[N], clk, clk2;
int Min(int x, int y) { return d[x] < d[y] ? x : y; }
void dfs1(int u, int fa) {
d[u] = d[fa] + 1;
mn[in[u] = ++clk][0] = u;
::rev[::in[u] = ++clk2] = u;
for (auto v : e[u]) {
if (v.first == fa) continue;
cur[v.second] = v.first;
col[v.first] = col[u] ^ owo[v.second];
dfs1(v.first, u);
mn[++clk][0] = u;
}
out[u] = clk;
::out[u] = clk2;
}
void init() {
dfs1(1, 0);
lg[0] = -1;
for (int i = (1); i <= (clk); i++) {
lg[i] = lg[i >> 1] + 1;
}
for (int i = (clk); i >= (1); i--) {
for (int j = 1; i + (1 << j) - 1 <= clk; j++) {
mn[i][j] = Min(mn[i][j - 1], mn[i + (1 << (j - 1))][j - 1]);
}
}
}
int lca(int x, int y) {
x = in[x], y = in[y];
if (x > y) swap(x, y);
int t = lg[y - x + 1];
return Min(mn[x][t], mn[y - (1 << t) + 1][t]);
}
int dist(int x, int y) {
if (!x || !y) return -1;
return d[x] + d[y] - 2 * d[lca(x, y)];
}
void upd(pair<int, int> &res, int x) {
int mx = dist(res.first, res.second);
int t1 = dist(res.first, x);
int t2 = dist(res.second, x);
if (t1 >= mx && t1 >= t2)
res.second = x;
else if (t2 >= mx)
res.first = x;
}
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
pair<int, int> res = a;
if (!res.first) res = b;
if (b.first) upd(res, b.first);
if (b.second) upd(res, b.second);
return res;
}
} // namespace tree
namespace seg {
pair<pair<int, int>, pair<int, int> > T[N << 2];
int tag[N << 2];
void up(int o) {
T[o].first = tree::merge(T[(o << 1)].first, T[(o << 1 | 1)].first);
T[o].second = tree::merge(T[(o << 1)].second, T[(o << 1 | 1)].second);
}
void app(int o) {
swap(T[o].first, T[o].second);
tag[o] ^= 1;
}
void down(int o) {
if (tag[o]) {
app((o << 1)), app((o << 1 | 1));
tag[o] = 0;
}
}
void upd(int o, int l, int r, int x, int y) {
if (l == x && y == r) {
app(o);
return;
}
down(o);
if (x <= ((l + r) >> 1))
upd((o << 1), l, ((l + r) >> 1), x, min(y, ((l + r) >> 1)));
if (((l + r) >> 1) < y)
upd((o << 1 | 1), ((l + r) >> 1) + 1, r, max(((l + r) >> 1) + 1, x), y);
up(o);
}
void build(int o, int l, int r) {
if (l == r) {
if (!col[rev[l]]) {
T[o].first = make_pair(rev[l], rev[l]);
T[o].second = make_pair(0, 0);
} else {
T[o].second = make_pair(rev[l], rev[l]);
T[o].first = make_pair(0, 0);
}
return;
}
build((o << 1), l, ((l + r) >> 1));
build((o << 1 | 1), ((l + r) >> 1) + 1, r);
up(o);
}
} // namespace seg
int main() {
read(n);
for (int i = (1); i <= (n - 1); i++) {
read(x), read(y), read(owo[i]);
e[x].push_back(make_pair(y, i));
e[y].push_back(make_pair(x, i));
}
tree::init();
seg::build(1, 1, n);
read(Q);
while (Q--) {
read(x);
seg::upd(1, 1, n, in[cur[x]], out[cur[x]]);
pair<pair<int, int>, pair<int, int> > ret = seg::T[1];
int ans1 = tree::dist(ret.first.first, ret.first.second);
int ans2 = tree::dist(ret.second.first, ret.second.second);
printf("%d\n", max(ans1, ans2));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 100;
struct Node {
int dist[2];
int flip;
};
struct segment_tree {
Node T[N * 4 + 512];
long long val[N];
int bit[N];
void build(int node, int cl, int cr) {
if (cl == cr) {
T[node].flip = 0;
T[node].dist[bit[cl]] = val[cl];
return;
}
int mid = (cl + cr) / 2;
build(node * 2, cl, mid);
build(node * 2 + 1, mid + 1, cr);
for (int q = 0; q < 2; q++) {
T[node].dist[q] = max(T[node * 2].dist[q], T[node * 2 + 1].dist[q]);
}
}
void push(int node, int cl, int cr) {
if (T[node].flip) {
swap(T[node].dist[0], T[node].dist[1]);
if (cl != cr) {
T[node * 2].flip ^= 1;
T[node * 2 + 1].flip ^= 1;
}
T[node].flip = 0;
}
}
void update(int node, int cl, int cr, int tl, int tr) {
push(node, cl, cr);
if (cr < tl || cl > tr) return;
if (cl >= tl && cr <= tr) {
T[node].flip = 1;
push(node, cl, cr);
return;
}
int mid = (cl + cr) / 2;
update(node * 2, cl, mid, tl, tr);
update(node * 2 + 1, mid + 1, cr, tl, tr);
T[node].dist[0] = max(T[node * 2].dist[0], T[node * 2 + 1].dist[0]);
T[node].dist[1] = max(T[node * 2].dist[1], T[node * 2 + 1].dist[1]);
}
};
vector<pair<int, int> > E[N];
int dis[N];
int pap[N];
int tin[N];
int tout[N];
int cc;
int ta[N];
int tb[N];
int uu[N];
int vv[N];
int dfs(int node, int pp) {
int best = node;
int nex;
cc++;
tin[node] = cc;
for (auto x : E[node]) {
if (x.first == pp) continue;
dis[x.first] = dis[node] + 1;
pap[x.first] = (pap[node] ^ x.second);
nex = dfs(x.first, node);
if (dis[nex] > dis[best]) {
best = nex;
}
}
tout[node] = cc;
return best;
}
segment_tree n1, n2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int u, v, d;
for (int i = 1; i < n; i++) {
cin >> u >> v >> d;
uu[i] = u;
vv[i] = v;
E[u].push_back(make_pair(v, d));
E[v].push_back(make_pair(u, d));
}
int A = dfs(1, -1);
dis[A] = 0;
pap[A] = 0;
cc = 0;
int B = dfs(A, -1);
for (int i = 1; i <= n; i++) {
n1.val[tin[i]] = dis[i];
n1.bit[tin[i]] = pap[i];
ta[i] = tin[i];
tb[i] = tout[i];
}
n1.build(1, 1, n);
dis[B] = 0;
pap[B] = 0;
cc = 0;
dfs(B, -1);
for (int i = 1; i <= n; i++) {
n2.val[tin[i]] = dis[i];
n2.bit[tin[i]] = pap[i];
}
n2.build(1, 1, n);
int q;
cin >> q;
int iq;
int goal;
for (int it = 1; it <= q; it++) {
cin >> iq;
if (ta[vv[iq]] < ta[uu[iq]]) {
goal = uu[iq];
} else {
goal = vv[iq];
}
n1.update(1, 1, n, ta[goal], tb[goal]);
if (tin[vv[iq]] < tin[uu[iq]]) {
goal = uu[iq];
} else {
goal = vv[iq];
}
n2.update(1, 1, n, tin[goal], tout[goal]);
cout << max(n1.T[1].dist[0], n2.T[1].dist[0]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const int ts = 1 << 21;
int n;
int eu[N], ev[N], ew[N];
vector<int> adj[N];
int e[N], d2[N];
;
int st[N], en[N];
int ptr = 0;
int seq[N];
void dfs(int id, int p) {
st[id] = ++ptr;
seq[ptr] = id;
for (auto c : adj[id]) {
if (c == p) continue;
e[c] = e[id] + 1;
dfs(c, id);
seq[++ptr] = id;
}
en[id] = ptr;
}
array<int, 9> a[ts];
bool lz[ts];
void putlz(int id) {
swap(a[id][1], a[id][2]);
swap(a[id][3], a[id][4]);
swap(a[id][5], a[id][6]);
swap(a[id][7], a[id][8]);
}
void pull(int id) {
int lc = id * 2, rc = id * 2 + 1;
for (int i = 0; i <= 8; i++) {
a[id][i] = max(a[lc][i], a[rc][i]);
}
a[id][3] = max(a[id][3], a[lc][1] + a[rc][0]);
a[id][4] = max(a[id][4], a[lc][2] + a[rc][0]);
a[id][5] = max(a[id][5], a[lc][0] + a[rc][1]);
a[id][6] = max(a[id][6], a[lc][0] + a[rc][2]);
a[id][7] = max(a[id][7], a[lc][1] + a[rc][5]);
a[id][7] = max(a[id][7], a[lc][3] + a[rc][1]);
a[id][8] = max(a[id][8], a[lc][2] + a[rc][6]);
a[id][8] = max(a[id][8], a[lc][4] + a[rc][2]);
}
void push(int id) {
if (!lz[id]) return;
putlz(id * 2);
putlz(id * 2 + 1);
lz[id * 2] ^= 1;
lz[id * 2 + 1] ^= 1;
lz[id] = false;
}
void build(int id, int l, int r) {
for (int i = 0; i <= 8; i++) a[id][i] = -1e6;
if (l == r) {
int d = e[seq[l]];
a[id][0] = -2 * d;
a[id][1] = d;
a[id][3] = -d;
a[id][5] = -d;
a[id][7] = 0;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
pull(id);
}
void upd(int id, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return;
if (ql <= l && r <= qr) {
putlz(id);
lz[id] ^= 1;
return;
}
push(id);
int mid = (l + r) / 2;
upd(id * 2, l, mid, ql, qr);
upd(id * 2 + 1, mid + 1, r, ql, qr);
pull(id);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> eu[i] >> ev[i] >> ew[i];
int u = eu[i], v = ev[i];
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
build(1, 1, 2 * n - 1);
for (int i = 1; i < n; i++) {
if (st[eu[i]] > st[ev[i]]) swap(eu[i], ev[i]);
if (ew[i]) upd(1, 1, 2 * n - 1, st[ev[i]], en[ev[i]]);
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int x;
cin >> x;
upd(1, 1, 2 * n - 1, st[ev[x]], en[ev[x]]);
ew[x] ^= 1;
cout << max(a[1][7], a[1][8]) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
template <class T>
void chmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
void chmax(T &a, const T &b) {
if (a < b) a = b;
}
struct Edge {
int to, id;
long long dist;
Edge(int to, long long dist = 1, int id = 0) : to(to), dist(dist), id(id) {}
};
struct HeavyLightDecomposition {
vector<vector<Edge>> g;
vector<int> in, out, head, par, dep, sz;
int times;
int root;
HeavyLightDecomposition(int V, vector<vector<Edge>> &G, int root = 0)
: g(G), in(V), out(V), head(V), par(V), dep(V), sz(V), root(root) {
times = 0;
sz_dfs(root, -1);
hld_dfs(root, -1);
}
void sz_dfs(int now, int p) {
par[now] = p;
sz[now] = 1;
if (p == -1)
dep[now] = 0;
else
dep[now] = dep[p] + 1;
for (auto &e : g[now]) {
if (e.to == p) continue;
sz_dfs(e.to, now);
sz[now] += sz[e.to];
if (sz[e.to] > sz[g[now][0].to]) swap(e, g[now][0]);
}
}
void hld_dfs(int now, int p) {
in[now] = times++;
for (auto e : g[now]) {
if (e.to == p) continue;
head[e.to] = (e.to == g[now][0].to ? head[now] : e.to);
hld_dfs(e.to, now);
}
out[now] = times;
}
int lca(int u, int v) {
for (;; v = par[head[v]]) {
if (in[u] > in[v]) swap(u, v);
if (head[u] == head[v]) return u;
}
}
int distance(int u, int v) { return dep[u] + dep[v] - 2 * dep[lca(u, v)]; }
template <class T, class G>
void update(int v, const T &x, const G &g) {
g(in[v], out[v], x);
}
template <class F>
void query(int u, int v, const F &f, bool isedge) {
for (;; v = par[head[v]]) {
if (in[u] > in[v]) swap(u, v);
if (head[u] == head[v]) break;
f(in[head[v]], in[v] + 1);
}
if (isedge && u == v) return;
f(in[u] + isedge, in[v] + 1);
}
};
template <typename T, typename S>
struct LazySegmentTree {
int n;
vector<T> data;
vector<S> lazy;
T te;
S se;
inline void merge_functions(S &lazy, S &val) { lazy ^= val; }
inline void operate(T &data, S &val, int len) {
swap(data.first, data.second);
}
inline T merge_values(T &x, T &y) {
return make_pair(max(x.first, y.first), max(x.second, y.second));
}
LazySegmentTree() {}
LazySegmentTree(int sz, T te, S se) : te(te), se(se) {
n = 1;
while (n < sz) n *= 2;
data.resize(2 * n - 1, te);
lazy.resize(2 * n - 1, se);
}
void build(const vector<T> &A) {
for (int k = 0; k < int(A.size()); k++) data[k + n - 1] = A[k];
for (int k = n - 2; k >= 0; k--)
data[k] = merge_values(data[2 * k + 1], data[2 * k + 2]);
}
void eval(int k, int l, int r) {
if (lazy[k] == se) return;
operate(data[k], lazy[k], r - l);
if (r - l > 1) {
merge_functions(lazy[2 * k + 1], lazy[k]);
merge_functions(lazy[2 * k + 2], lazy[k]);
}
lazy[k] = se;
}
void update(int a, int b, S val, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (b <= l || r <= a) return;
if (a <= l && r <= b) {
merge_functions(lazy[k], val);
eval(k, l, r);
} else {
update(a, b, val, 2 * k + 1, l, (l + r) / 2);
update(a, b, val, 2 * k + 2, (l + r) / 2, r);
data[k] = merge_values(data[2 * k + 1], data[2 * k + 2]);
}
}
T query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
eval(k, l, r);
if (b <= l || r <= a) return te;
if (a <= l && r <= b) return data[k];
T vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
T vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return merge_values(vl, vr);
}
T get(int p) { return query(p, p + 1); }
};
int findFar(int st, vector<vector<Edge>> &g) {
int N = g.size();
vector<int> dist(N, MOD);
dist[st] = 0;
queue<int> Q;
Q.push(st);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (auto e : g[now]) {
if (dist[e.to] == MOD) {
dist[e.to] = dist[now] + 1;
Q.push(e.to);
}
}
}
int mat = 0;
for (int i = 0; i < (N); ++i)
if (dist[mat] < dist[i]) mat = i;
return mat;
}
pair<int, int> getDiameter(vector<vector<Edge>> &g) {
int st = findFar(0, g);
st = findFar(st, g);
int ed = findFar(st, g);
return make_pair(st, ed);
}
void dfs(int now, int par, int col, vector<vector<Edge>> &g,
vector<int> &dist) {
dist[now] = col;
for (auto e : g[now]) {
if (e.to == par) continue;
dfs(e.to, now, col ^ e.dist, g, dist);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<vector<Edge>> g(N);
struct E {
int from, to, col;
E() {}
E(int from, int to, int col) : from(from), to(to), col(col) {}
};
vector<E> edges;
for (int i = 0; i < (N - 1); ++i) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g[a].emplace_back(Edge{b, c});
g[b].emplace_back(Edge{a, c});
edges.emplace_back(E{a, b, c});
}
auto f = getDiameter(g);
int st = f.first;
int ed = f.second;
const pair<int, int> unit = make_pair(0, 0);
HeavyLightDecomposition hld1(N, g, st), hld2(N, g, ed);
LazySegmentTree<pair<int, int>, int> seg1(N, unit, 0);
LazySegmentTree<pair<int, int>, int> seg2(N, unit, 0);
{
vector<pair<int, int>> init(N);
vector<int> dist(N);
dfs(st, -1, 0, g, dist);
for (int i = 0; i < (N); ++i) {
if (dist[i] == 0)
init[hld1.in[i]] = make_pair(hld1.dep[i], 0);
else
init[hld1.in[i]] = make_pair(0, hld1.dep[i]);
}
seg1.build(init);
}
{
vector<pair<int, int>> init(N);
vector<int> dist(N);
dfs(ed, -1, 0, g, dist);
for (int i = 0; i < (N); ++i) {
if (dist[i] == 0)
init[hld2.in[i]] = make_pair(hld2.dep[i], 0);
else
init[hld2.in[i]] = make_pair(0, hld2.dep[i]);
}
seg2.build(init);
}
int Q;
cin >> Q;
for (int q = 0; q < (Q); ++q) {
int A;
cin >> A;
A--;
{
int now = 0;
if (hld1.dep[edges[A].from] < hld1.dep[edges[A].to])
now = edges[A].to;
else
now = edges[A].from;
hld1.update(now, 1, [&](int l, int r, int x) { seg1.update(l, r, x); });
}
{
int now = 0;
if (hld2.dep[edges[A].from] < hld2.dep[edges[A].to])
now = edges[A].to;
else
now = edges[A].from;
hld2.update(now, 1, [&](int l, int r, int x) { seg2.update(l, r, x); });
}
auto res = max(seg1.query(0, N).first, seg2.query(0, N).first);
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, nxt, dis;
} e[1000005];
int n, m, num, x = 1, y = 1, tim, h[500005], dep[500005], q[500005];
int dfn[500005], out[500005], ans[500005], dis[500005];
int p[500005], mx[2][2000005], U[500005], V[500005], lazy[2000005];
void cmax(int &a, int b) { a = max(a, b); }
void add(int u, int v, int d) {
e[++num].to = v;
e[num].dis = d;
e[num].nxt = h[u];
h[u] = num;
}
void dfs(int u, int fa) {
int v, i;
dep[u] = dep[fa] + 1;
for (i = h[u]; i; i = e[i].nxt) {
v = e[i].to;
if (v != fa) dfs(v, u);
}
}
void dfs2(int u, int fa) {
int v, i;
dfn[u] = ++tim;
dep[u] = dep[fa] + 1;
for (i = h[u]; i; i = e[i].nxt) {
v = e[i].to;
if (v != fa) {
dis[v] = (dis[u] + e[i].dis) & 1;
dfs2(v, u);
}
}
out[u] = tim;
}
void push_up(int ind) {
mx[0][ind] = max(mx[0][ind << 1], mx[0][ind << 1 | 1]);
mx[1][ind] = max(mx[1][ind << 1], mx[1][ind << 1 | 1]);
}
void push_down(int ind) {
if (lazy[ind]) {
lazy[ind << 1] = !lazy[ind << 1];
lazy[ind << 1 | 1] = !lazy[ind << 1 | 1];
swap(mx[0][ind << 1], mx[1][ind << 1]);
swap(mx[0][ind << 1 | 1], mx[1][ind << 1 | 1]);
lazy[ind] = 0;
}
}
void build(int ind, int L, int R) {
if (L == R) {
mx[dis[p[L]]][ind] = dep[p[L]];
return;
}
int mid = (L + R) >> 1;
build(ind << 1, L, mid);
build(ind << 1 | 1, mid + 1, R);
push_up(ind);
}
void upd(int ind, int L, int R, int l, int r) {
if (l <= L && R <= r) {
lazy[ind] = !lazy[ind];
swap(mx[0][ind], mx[1][ind]);
return;
}
push_down(ind);
int mid = (L + R) >> 1;
if (l <= mid) upd(ind << 1, L, mid, l, r);
if (r > mid) upd(ind << 1 | 1, mid + 1, R, l, r);
push_up(ind);
}
void solve(int r) {
int i, t;
tim = 0;
dis[r] = 0;
memset(mx, 0, sizeof(mx));
memset(lazy, 0, sizeof(lazy));
dfs2(r, 0);
for (i = 1; i <= n; i++) p[dfn[i]] = i;
build(1, 1, n);
for (i = 1; i <= m; i++) {
t = dep[V[q[i]]] > dep[U[q[i]]] ? V[q[i]] : U[q[i]];
upd(1, 1, n, dfn[t], out[t]);
cmax(ans[i], mx[0][1] - 1);
}
}
int main() {
ios::sync_with_stdio(false);
int i, d;
cin >> n;
for (i = 1; i <= n - 1; i++) {
cin >> U[i] >> V[i] >> d;
add(U[i], V[i], d);
add(V[i], U[i], d);
}
dfs(1, 0);
for (i = 1; i <= n; i++)
if (dep[i] > dep[x]) x = i;
dfs(x, 0);
for (i = 1; i <= n; i++)
if (dep[i] > dep[y]) y = i;
cin >> m;
for (i = 1; i <= m; i++) cin >> q[i];
solve(x);
solve(y);
for (i = 1; i <= m; i++) cout << ans[i] << endl;
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() {
ios::sync_with_stdio(false);
cin.tie(0);
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);
VI is_odd(n);
for (int i = 0; i < (n - 1); ++i) {
int u = es[i].u, v = es[i].v, s = es[i].state;
if (hld.parent[u] == v) {
swap(u, v);
swap(es[i].u, es[i].v);
}
is_odd[v] = s;
}
queue<int> que;
que.push(a);
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : to[u]) {
if (v == hld.parent[u]) continue;
is_odd[v] ^= is_odd[u];
que.push(v);
}
}
vector<S> init_vec(n);
for (int i = 0; i < (n); ++i) {
if (is_odd[i]) {
init_vec[hld.idx[i]] = {-1, hld.depth[i]};
} else {
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 < (m); ++i) {
int ei = query[i];
int v = es[ei].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>
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) {
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() {}
};
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 CompressTree;
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 N = 2000005;
int n, m, rt, dep[N], dfn[N][2], f[N][2], dis[N], rf[N][2], cnt;
int v[N], nxt[N], head[N], w[N], id[N][2], s[2][N][2], tag[2][N];
void dfs(int x, int fa) {
dfn[x][1] = ++cnt, f[cnt][1] = x;
for (int i = head[x]; i > 0; i = nxt[i]) {
if (v[i] == fa) continue;
dis[v[i]] = dis[x] + w[i];
dep[v[i]] = dep[x] + 1, dfs(v[i], x);
if (i < n)
id[i][1] = v[i];
else
id[i - n][1] = v[i];
}
rf[x][1] = cnt;
}
void build(int x, int l, int r, int d) {
if (l == r) {
s[d][x][dis[f[l][d]] & 1] = dep[f[l][d]];
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid, d), build(x << 1 | 1, mid + 1, r, d);
s[d][x][0] = max(s[d][x << 1][0], s[d][x << 1 | 1][0]);
s[d][x][1] = max(s[d][x << 1][1], s[d][x << 1 | 1][1]);
}
void pushdown(int x, int l, int r, int d) {
if (!tag[d][x]) return;
swap(s[d][x << 1][0], s[d][x << 1][1]);
swap(s[d][x << 1 | 1][0], s[d][x << 1 | 1][1]);
tag[d][x << 1] ^= 1, tag[d][x << 1 | 1] ^= 1;
tag[d][x] = 0;
}
void modify(int x, int l, int r, int L, int R, int d) {
if (l >= L && R >= r) {
tag[d][x] ^= 1;
swap(s[d][x][0], s[d][x][1]);
return;
}
pushdown(x, l, r, d);
int mid = (l + r) >> 1;
if (L <= mid) modify(x << 1, l, mid, L, R, d);
if (R > mid) modify(x << 1 | 1, mid + 1, r, L, R, d);
s[d][x][0] = max(s[d][x << 1][0], s[d][x << 1 | 1][0]);
s[d][x][1] = max(s[d][x << 1][1], s[d][x << 1 | 1][1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &v[i], &v[i + n]);
nxt[i] = head[v[i + n]], head[v[i + n]] = i;
nxt[i + n] = head[v[i]], head[v[i]] = i + n;
scanf("%d", &w[i]), w[i + n] = w[i];
}
dfs(1, 0), rt = 1, cnt = 0;
for (int i = 1; i <= n; i++)
if (dep[rt] < dep[i]) rt = i;
dep[rt] = dis[rt] = 0, dfs(rt, 0);
for (int i = 1; i <= n; i++) dfn[i][0] = dfn[i][1], rf[i][0] = rf[i][1];
for (int i = 1; i <= n; i++) id[i][0] = id[i][1], f[i][0] = f[i][1];
build(1, 1, n, 0), cnt = 0;
for (int i = 1; i <= n; i++)
if (dep[rt] < dep[i]) rt = i;
dep[rt] = dis[rt] = 0, dfs(rt, 0), build(1, 1, n, 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
modify(1, 1, n, dfn[id[x][0]][0], rf[id[x][0]][0], 0);
modify(1, 1, n, dfn[id[x][1]][1], rf[id[x][1]][1], 1);
printf("%d\n", max(s[0][1][0], s[1][1][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 Int = long long;
using Real = long double;
using CP = complex<Real>;
using P = pair<Int, Int>;
const Int MOD = 1000000007;
const Int MOD2 = 998244353;
const Int LINF = (1LL << 60);
const int INF = (1000000007);
const Real EPS = 1e-10;
const long double PI = 3.141592653589793238462643383279502884L;
vector<P> edge[550000];
void dfs(int x, vector<int>& dep, int last = -1) {
if (last == -1) dep[x] = 0;
for (auto [to, _] : edge[x]) {
if (to == last) continue;
dep[to] = dep[x] + 1;
dfs(to, dep, x);
}
}
int n;
int u[550000];
int v[550000];
int t[550000];
P op(P x, P y) {
if (x.first == INF) return y;
if (y.first == INF) return x;
return {max({x.first, x.second, y.first, y.second}),
min({x.first, x.second, y.first, y.second})};
}
P e() { return {INF, INF}; }
P mapping(bool x, P y) {
if (y.first == INF) return y;
return x ? P(-y.first, -y.second) : y;
}
bool composition(bool x, bool y) { return x ^ y; }
bool id() { return false; }
using lazy_seg =
atcoder::lazy_segtree<P, op, e, bool, mapping, composition, id>;
struct Euler {
lazy_seg seg;
vector<int> in, out;
vector<P> tmp;
int p;
void dfs2(int v, int last = -1, int dep = 0, int fliped = 1) {
in[v] = p++;
tmp[in[v]] = P(dep * fliped, dep * fliped);
for (auto [to, ind] : edge[v]) {
if (to == last) continue;
dfs2(to, v, dep + 1, fliped * (t[ind] ? -1 : 1));
}
out[v] = p;
}
Euler(int v) : p(0), in(n + 1), out(n + 1), tmp(n) {
dfs2(v);
seg = lazy_seg(tmp);
}
void flip(int u, int v) {
if (in[u] < in[v]) swap(u, v);
seg.apply(in[u], out[u], true);
}
int get_max() {
auto res = seg.all_prod();
return max(res.first, res.second);
}
};
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d%d", &u[i], &v[i], &t[i]);
edge[u[i]].emplace_back(v[i], i);
edge[v[i]].emplace_back(u[i], i);
}
vector<int> dep1(n + 1), dep2(n + 1);
dfs(1, dep2);
int farest1 = 1;
for (int i = 1; i <= n; i++) {
if (dep2[i] > dep2[farest1]) farest1 = i;
}
dfs(farest1, dep1);
int farest2 = 1;
for (int i = 1; i <= n; i++)
if (dep1[i] > dep1[farest2]) farest2 = i;
dfs(farest2, dep2);
Euler tree1(farest1), tree2(farest2);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int q;
scanf("%d", &q);
tree1.flip(u[q], v[q]);
tree2.flip(u[q], v[q]);
printf("%d\n", max(tree1.get_max(), tree2.get_max()));
}
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>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 998244353;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int edgenum = 1, head[MAXN], to[MAXN], nxt[MAXN], c[MAXN];
int DFN = 0, low[MAXN], lowu[MAXN], lowv[MAXN], dfn[MAXN], dfnu[MAXN],
dfnv[MAXN], y[MAXN], yu[MAXN], yv[MAXN], dep[MAXN], w[MAXN], id[MAXN];
void add(int u, int v, int C) {
edgenum++, to[edgenum] = v, c[edgenum] = C, nxt[edgenum] = head[u],
head[u] = edgenum;
}
void dfs(int x, int father) {
id[dfn[x] = ++DFN] = x, dep[x] = dep[father] + 1;
for (int i = head[x]; i; i = nxt[i]) {
if (to[i] == father) continue;
w[to[i]] = w[x] ^ c[i];
y[i >> 1] = to[i];
dfs(to[i], x);
}
low[x] = DFN;
}
struct Segment_Tree {
int mx0[MAXN << 2], mx1[MAXN << 2], tag[MAXN << 2];
void down(int x) {
if (tag[x])
swap(mx0[x << 1], mx1[x << 1]), swap(mx0[x << 1 | 1], mx1[x << 1 | 1]),
tag[x << 1] ^= 1, tag[x << 1 | 1] ^= 1, tag[x] = 0;
}
void build(int x, int l, int r) {
if (l == r) {
if (w[id[l]])
mx0[x] = -1, mx1[x] = dep[id[l]];
else
mx0[x] = dep[id[l]], mx1[x] = -1;
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
mx0[x] = max(mx0[x << 1], mx0[x << 1 | 1]);
mx1[x] = max(mx1[x << 1], mx1[x << 1 | 1]);
}
void reverse(int x, int l, int r, int L, int R) {
if (l >= L && r <= R) {
swap(mx0[x], mx1[x]);
tag[x] ^= 1;
return;
}
down(x);
int mid = (l + r) >> 1;
if (R <= mid)
reverse(x << 1, l, mid, L, R);
else if (L > mid)
reverse(x << 1 | 1, mid + 1, r, L, R);
else
reverse(x << 1, l, mid, L, mid),
reverse(x << 1 | 1, mid + 1, r, mid + 1, R);
mx0[x] = max(mx0[x << 1], mx0[x << 1 | 1]);
mx1[x] = max(mx1[x << 1], mx1[x << 1 | 1]);
}
} Tu, Tv;
signed main() {
int n = read(), U = 0, V = 0;
for (int i = 1; i < n; i++) {
int u = read(), v = read(), c = read();
add(u, v, c), add(v, u, c);
}
DFN = 0, w[1] = 0, dfs(1, 0);
for (int i = 1; i <= n; i++)
if (dep[i] > dep[U]) U = i;
DFN = 0, w[U] = 0, dfs(U, 0);
for (int i = 1; i <= n; i++) dfnu[i] = dfn[i], lowu[i] = low[i], yu[i] = y[i];
Tu.build(1, 1, n);
for (int i = 1; i <= n; i++)
if (dep[i] > dep[V]) V = i;
DFN = 0, w[V] = 0, dfs(V, 0);
for (int i = 1; i <= n; i++) dfnv[i] = dfn[i], lowv[i] = low[i], yv[i] = y[i];
Tv.build(1, 1, n);
int Case = read();
while (Case--) {
int t = read(), x = yu[t], y = yv[t];
Tu.reverse(1, 1, n, dfnu[x], lowu[x]);
Tv.reverse(1, 1, n, dfnv[y], lowv[y]);
printf("%d\n", max(Tu.mx0[1], Tv.mx0[1]) - 1);
}
return 0;
}
|
#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>
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);
VI is_odd(n);
for (int i = 0; i < (n - 1); ++i) {
int u = es[i].u, v = es[i].v, s = es[i].state;
if (hld.parent[u] == v) {
swap(u, v);
swap(es[i].u, es[i].v);
}
is_odd[v] = s;
}
queue<int> que;
que.push(a);
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : to[u]) {
if (v == hld.parent[u]) continue;
is_odd[v] ^= is_odd[u];
que.push(v);
}
}
vector<S> init_vec(n);
for (int i = 0; i < (n); ++i) {
if (is_odd[i]) {
init_vec[hld.idx[i]] = {-1, hld.depth[i]};
} else {
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 < (m); ++i) {
int ei = query[i];
int v = es[ei].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;
inline int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int _tmp[20];
int _tn;
inline void printint(int x) {
int f = 1;
if (x == 0) {
puts("0");
return;
}
if (x < 0) {
f = -1;
x = -x;
}
_tn = 0;
while (x) {
_tmp[++_tn] = x % 10;
x /= 10;
}
if (f == -1) putchar('-');
for (int i = _tn; i >= 1; i--) putchar('0' + _tmp[i]);
puts("");
}
inline void chmax(int &x, int y) { x = max(x, y); }
const int N = 5e5 + 5;
const int INF = 123456789;
int n, m, t = 1, q;
int X[N], Y[N], Z[N], p[N], B[N], E[N], d[N], poi[N * 2];
vector<int> nei[N];
void dfs(int x) {
B[x] = E[x] = ++m;
poi[m] = x;
for (int i = 0; i < int(nei[x].size()); i++) {
int to = nei[x][i];
if (to != p[x]) {
p[to] = x;
d[to] = d[x] + 1;
dfs(to);
E[x] = ++m;
poi[m] = x;
}
}
}
int lson[N * 4];
int rson[N * 4];
int val1[2][N * 4];
int val2[N * 4];
int val3[2][N * 4];
int val4[2][N * 4];
int val5[2][N * 4];
int tag[N * 4];
void update(int pos) {
for (int i = 0; i < 2; i++) {
val1[i][pos] = max(val1[i][lson[pos]], val1[i][rson[pos]]);
val3[i][pos] = max(val3[i][lson[pos]], val3[i][rson[pos]]);
val4[i][pos] = max(val4[i][lson[pos]], val4[i][rson[pos]]);
val5[i][pos] = max(val5[i][lson[pos]], val5[i][rson[pos]]);
}
val2[pos] = max(val2[lson[pos]], val2[rson[pos]]);
for (int i = 0; i < 2; i++) {
if (val1[i][lson[pos]] != -INF && val2[rson[pos]] != -INF)
chmax(val3[i][pos], val1[i][lson[pos]] + val2[rson[pos]]);
if (val2[lson[pos]] != -INF && val1[i][rson[pos]] != -INF)
chmax(val4[i][pos], val2[lson[pos]] + val1[i][rson[pos]]);
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
if (val1[i][lson[pos]] != -INF && val4[i][rson[pos]] != -INF)
chmax(val5[i ^ j][pos], val1[i][lson[pos]] + val4[i][rson[pos]]);
if (val3[i][lson[pos]] != -INF && val1[i][rson[pos]] != -INF)
chmax(val5[i ^ j][pos], val3[i][lson[pos]] + val1[i][rson[pos]]);
}
}
void flip(int pos) {
tag[pos] ^= 1;
swap(val1[0][pos], val1[1][pos]);
swap(val3[0][pos], val3[1][pos]);
swap(val4[0][pos], val4[1][pos]);
}
void pushdown(int pos) {
if (tag[pos]) {
flip(lson[pos]);
flip(rson[pos]);
tag[pos] = 0;
}
}
void build(int pos, int x, int y) {
for (int i = 0; i < 2; i++)
val1[i][pos] = val3[i][pos] = val4[i][pos] = val5[i][pos] = -INF;
val2[pos] = -INF;
if (x == y) {
val1[0][pos] = d[poi[x]];
val2[pos] = -2 * d[poi[x]];
val3[0][pos] = val4[0][pos] = -d[poi[x]];
val5[0][pos] = 0;
return;
}
int mid = (x + y) >> 1;
lson[pos] = ++t;
rson[pos] = ++t;
build(lson[pos], x, mid);
build(rson[pos], mid + 1, y);
update(pos);
}
void modify(int pos, int x, int y, int l, int r) {
if (x >= l && y <= r) {
flip(pos);
return;
}
if (x > r || y < l) return;
pushdown(pos);
int mid = (x + y) >> 1;
modify(lson[pos], x, mid, l, r);
modify(rson[pos], mid + 1, y, l, r);
update(pos);
}
int main() {
n = readint();
for (int i = 1; i < n; i++) {
X[i] = readint();
Y[i] = readint();
Z[i] = readint();
nei[X[i]].push_back(Y[i]);
nei[Y[i]].push_back(X[i]);
}
p[1] = 1;
dfs(1);
build(1, 1, m);
for (int i = 1; i < n; i++)
if (Z[i]) {
int x = X[i], y = Y[i];
if (p[y] == x) swap(x, y);
modify(1, 1, m, B[x], E[x]);
}
q = readint();
for (int i = 1; i <= q; i++) {
int id;
id = readint();
int x = X[id], y = Y[id];
if (p[y] == x) swap(x, y);
modify(1, 1, m, B[x], E[x]);
printint(val5[0][1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nxt[1000010 << 1], to[1000010 << 1], head[1000010], cnt = 1;
int w[1000010 << 1];
void add(int u, int v, int w1) {
nxt[++cnt] = head[u];
to[cnt] = v;
w[cnt] = w1;
head[u] = cnt;
}
int id[1000010], lid[1000010], rid[1000010], idx;
int dep[1000010], pos[1000010], wd[1000010];
namespace segment {
int val[1000010 << 2][2], maxn[1000010 << 2], vl[1000010 << 2][2],
vr[1000010 << 2][2], ml[1000010 << 2][2], tag[1000010 << 2];
void update(int u) {
maxn[u] = max(maxn[u << 1], maxn[u << 1 | 1]);
for (int _ = 0; _ <= 1; _++)
val[u][_] = max(val[u << 1][_], val[u << 1 | 1][_]),
vl[u][_] = max(vl[u << 1][_], vl[u << 1 | 1][_]),
vr[u][_] = max(vr[u << 1][_], vr[u << 1 | 1][_]),
ml[u][_] = max(ml[u << 1][_], ml[u << 1 | 1][_]),
vl[u][_] = max(vl[u][_], val[u << 1][_] + maxn[u << 1 | 1]),
vr[u][_] = max(vr[u][_], maxn[u << 1] + val[u << 1 | 1][_]);
for (int l = 0; l <= 1; l++)
for (int r = 0; r <= 1; r++)
ml[u][l ^ r] = max(ml[u][l ^ r], max(vl[u << 1][l] + val[u << 1 | 1][r],
val[u << 1][l] + vr[u << 1 | 1][r]));
}
void set_tag(int u) {
swap(val[u][0], val[u][1]), swap(vl[u][0], vl[u][1]),
swap(vr[u][0], vr[u][1]);
tag[u] ^= 1;
}
void push_down(int u) {
if (!tag[u]) return;
set_tag(u << 1), set_tag(u << 1 | 1);
tag[u] = 0;
}
void build(int u, int l, int r) {
if (l == r) {
int x = id[l], i = wd[x] & 1;
val[u][i] = dep[x], maxn[u] = -2 * dep[x];
vl[u][i] = vr[u][i] = -dep[x];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
update(u);
}
void insert(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
set_tag(u);
return;
}
int mid = (l + r) >> 1;
push_down(u);
if (L <= mid) insert(u << 1, l, mid, L, R);
if (R > mid) insert(u << 1 | 1, mid + 1, r, L, R);
update(u);
}
} // namespace segment
void dfs(int u, int p) {
dep[u] = dep[p] + 1;
id[lid[u] = ++idx] = u;
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == p) continue;
pos[i >> 1] = v;
wd[v] = wd[u] + w[i];
dfs(v, u);
id[++idx] = u;
}
rid[u] = idx;
}
int main() {
memset(segment::val, 0xcf, sizeof(segment::val));
memset(segment::vl, 0xcf, sizeof(segment::vl));
memset(segment::vr, 0xcf, sizeof(segment::vr));
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w), add(v, u, w);
}
dep[0] = -1;
dfs(1, 0);
segment::build(1, 1, idx);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
segment::insert(1, 1, idx, lid[pos[x]], rid[pos[x]]);
printf("%d\n", segment::ml[1][0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
const long long N = 5e5 + 5;
const int32_t maxn = N;
template <typename NODE, typename UPDATE>
struct segtree {
bool built = false, lazy[4 * maxn];
NODE zero = NODE(), t[4 * maxn];
UPDATE noop = UPDATE(), upds[4 * maxn];
int32_t tl[4 * maxn], tr[4 * maxn];
inline void pushdown(int32_t v) {
if (lazy[v]) {
apply(v * 2, upds[v]);
apply(v * 2 + 1, upds[v]);
lazy[v] = 0;
upds[v] = noop;
}
}
inline void apply(int32_t v, UPDATE &val) {
if (tl[v] != tr[v]) {
lazy[v] = 1;
upds[v].combine(val, tl[v], tr[v]);
}
val.apply(t[v], tl[v], tr[v]);
}
template <typename T>
void build(T a, int32_t v, int32_t l, int32_t r) {
tl[v] = l;
tr[v] = r;
if (l == r) {
t[v] = a[l];
return;
} else {
int32_t tm = (l + r) / 2;
build(a, v * 2, l, tm);
build(a, v * 2 + 1, tm + 1, r);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
}
NODE query(int32_t v, long long l, long long r) {
if (l > tr[v] || r < tl[v]) return zero;
if (l <= tl[v] && tr[v] <= r) {
return t[v];
}
pushdown(v);
NODE a, b, ans;
a = query(v * 2, l, r);
b = query(v * 2 + 1, l, r);
ans.merge(a, b);
return ans;
}
void rupd(int32_t v, long long l, long long r, UPDATE &val) {
if (l > tr[v] || r < tl[v]) return;
if (l <= tl[v] && tr[v] <= r) {
apply(v, val);
return;
}
pushdown(v);
rupd(v * 2, l, r, val);
rupd(v * 2 + 1, l, r, val);
t[v].merge(t[v * 2], t[v * 2 + 1]);
}
template <typename T>
long long descent_right(long long l, T x, int32_t v, NODE &prev) {
if (l > tr[v]) return len;
if (l <= tl[v]) {
NODE cur;
cur.merge(prev, t[v]);
if (!cur.check(x)) {
swap(prev, cur);
return len;
}
if (tl[v] == tr[v]) {
return tr[v];
}
}
pushdown(v);
long long ans = descent_right(l, x, v * 2, prev);
if (ans != len) return ans;
return descent_right(l, x, v * 2 + 1, prev);
}
template <typename T>
long long descent_left(long long r, T x, int32_t v, NODE &prev) {
if (r < tl[v]) return -1;
if (r >= tr[v]) {
NODE cur;
cur.merge(t[v], prev);
if (!cur.check(x)) {
swap(cur, prev);
return -1;
}
if (tl[v] == tr[v]) {
return tl[v];
}
}
pushdown(v);
long long ans = descent_left(r, x, v * 2 + 1, prev);
if (ans != -1) return ans;
return descent_left(r, x, v * 2, prev);
}
long long len = maxn;
void clear() {
fill(t, t + 4 * len, zero);
fill(lazy, lazy + 4 * len, false);
fill(upds, upds + 4 * len, noop);
}
template <typename T>
void build(T a) {
build(a, 1, 0, len - 1);
built = true;
}
template <typename T>
long long descent_right(long long l, T x) {
NODE prev = zero;
return descent_right(l, x, 1, prev);
}
template <typename T>
long long descent_left(long long r, T x) {
NODE prev = zero;
return descent_left(r, x, 1, prev);
}
NODE query(long long l, long long r) {
if (!built) build(t);
return query(1, l, r);
}
void rupd(long long l, long long r, UPDATE val) {
if (!built) build(t);
rupd(1, l, r, val);
}
};
struct node1 {
long long e = 0, o = 0;
node1() {}
node1(long long val) { e = val; }
void merge(node1 &l, node1 &r) {
e = max(l.e, r.e);
o = max(l.o, r.o);
}
bool check(long long x) { return false; }
};
struct update1 {
long long v = 0;
update1() {}
update1(long long val) { v = val; }
void combine(update1 &other, int32_t tl, int32_t tr) { v ^= other.v; }
void apply(node1 &x, int32_t tl, int32_t tr) {
if (v) {
swap(x.e, x.o);
}
}
};
segtree<node1, update1> t;
long long n, m;
pair<long long, long long> edgs[N];
vector<long long> f, q;
long long tim;
long long st[N], et[N], dep[N], ev[N];
vector<pair<long long, long long> > v[N];
void dfs(long long z, long long p = 0, long long d = 0) {
st[z] = tim++;
dep[st[z]] = d;
for (pair<long long, long long> x : v[z]) {
if (x.first == p) continue;
ev[x.second] = x.first;
dfs(x.first, z, d + 1);
}
et[z] = tim - 1;
}
pair<long long, long long> auxdfs(long long z, long long p = 0,
long long d = 0) {
pair<long long, long long> ret = {d, z};
for (pair<long long, long long> x : v[z]) {
if (x.first == p) continue;
pair<long long, long long> tmp = auxdfs(x.first, z, d + 1);
amax(ret, tmp);
}
return ret;
}
long long ans[N];
void solve() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long x, y, z;
cin >> x >> y >> z;
edgs[i] = {x, y};
v[x].push_back({y, i});
v[y].push_back({x, i});
if (z) f.push_back(i);
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long x;
cin >> x;
q.push_back(x);
}
long long root = 1;
for (long long zz = 0; zz < 2; zz++) {
root = auxdfs(root).second;
tim = 0;
dfs(root);
t.clear();
t.build(dep);
for (long long x : f) {
long long y = ev[x];
t.rupd(st[y], et[y], 1);
}
for (long long i = 0; i < m; i++) {
long long x = q[i];
long long y = ev[x];
t.rupd(st[y], et[y], 1);
amax(ans[i], t.query(st[root], et[root]).e);
}
}
for (long long i = 0; i < m; i++) {
cout << ans[i] << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
#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>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline bool setmin(T &a, T b) {
if (a > b) return a = b, 1;
return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
if (a < b) return a = b, 1;
return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
for (auto &u : container) os >> u;
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
for (auto &u : container) os << u << " ";
return os;
}
template <class T>
inline T gcd(T a, T b) {
while (b) swap(a %= b, b);
return abs(a);
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 20;
const long double inf = 1e18;
const long double eps = 1e-14;
long long n, m, k;
vector<vector<pair<int, int> > > G(N);
int najd = 1, dist, cnt_pre;
vector<int> preorder(N), glebokosc(N), rev_pre(N), kolor(N);
vector<pair<int, int> > przedzial_na_drzewie(N);
struct Tree {
vector<int> merge(vector<int> &a, vector<int> &b) {
return {max(a[0], b[0]), max(a[1], b[1])};
}
vector<vector<int> > tree;
vector<int> lazy;
Tree() {
tree = vector<vector<int> >(T * 2, vector<int>(2, -1));
lazy = vector<int>(T * 2, false);
for (int i = 1; i <= cnt_pre; i++)
tree[i + T][kolor[rev_pre[i]]] = glebokosc[rev_pre[i]];
for (int i = T - 1; i >= 0; i--)
tree[i] = merge(tree[i * 2], tree[i * 2 + 1]);
};
void push(int v) {
if (lazy[v]) {
swap(tree[v][0], tree[v][1]);
if (v < T) {
lazy[v * 2] ^= 1;
lazy[v * 2 + 1] ^= 1;
}
lazy[v] = 0;
}
}
void flip(int a, int b, int u = 1, int lo = 0, int hi = T - 1) {
push(u);
if (hi < a or b < lo) return;
if (a <= lo and hi <= b) {
lazy[u] ^= 1;
push(u);
return;
}
int mid = (lo + hi) / 2;
flip(a, b, u * 2, lo, mid);
flip(a, b, u * 2 + 1, mid + 1, hi);
tree[u] = merge(tree[u * 2], tree[u * 2 + 1]);
}
void flip(pair<int, int> kraw) {
int v = (glebokosc[kraw.first] < glebokosc[kraw.second] ? kraw.second
: kraw.first);
flip(przedzial_na_drzewie[v].first, przedzial_na_drzewie[v].second);
}
int ask() { return tree[1][0]; }
};
void dfs2(int second, int p = -1, int gl = 0, int kol = 0) {
if (p == -1) cnt_pre = 0;
preorder[second] = ++cnt_pre;
rev_pre[cnt_pre] = second;
glebokosc[second] = gl;
kolor[second] = kol;
for (auto &u : G[second])
if (u.first != p) dfs2(u.first, second, gl + 1, kol ^ u.second);
przedzial_na_drzewie[second] = {preorder[second], cnt_pre};
}
vector<int> solve(vector<pair<int, int> > &kraw, vector<int> zap, int root) {
dfs2(root);
Tree tree;
vector<int> ret;
for (auto &u : zap) {
tree.flip(kraw[u]);
ret.push_back(tree.ask());
}
return ret;
}
void dfs(int second = najd, int gl = 0, int przodek = -1) {
if (gl == 0) dist = -1;
if (gl > dist) {
dist = gl;
najd = second;
}
for (auto &u : G[second])
if (u.first != przodek) dfs(u.first, gl + 1, second);
}
void solve() {
cin >> n;
vector<pair<int, int> > kraw(n, {-1, -1});
for (int i = 1; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
G[a].push_back({b, c});
G[b].push_back({a, c});
kraw[i] = {a, b};
}
vector<int> konce;
dfs();
konce.push_back(najd);
dfs();
konce.push_back(najd);
cin >> m;
vector<int> zapytania(m);
cin >> zapytania;
vector<int> A = solve(kraw, zapytania, konce[0]);
vector<int> B = solve(kraw, zapytania, konce[1]);
for (int i = 0; i < m; i++) cout << max(A[i], B[i]) << '\n';
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
|
#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 = 1, int p = 0) {
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 = 1, int r = n) {
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, 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 = 1, int r = n) {
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);
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 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;
const int MN = 5e5 + 5;
struct node {
int val[2];
} T[MN << 2];
node operator+(node a, node b) {
return (node){max(a.val[0], b.val[0]), max(a.val[1], b.val[1])};
}
int N, M, idx[MN], ans[MN], fa[MN], dep[MN], rt;
vector<pair<int, int> > a[MN];
vector<pair<int, int> > G;
inline void chkmax(int &x, int y) { x = max(x, y); }
struct sol {
int f[MN], l[MN], siz, r[MN], rev[MN], tg[MN << 2], dep[MN], fa[MN];
inline void dfs(int x) {
rev[l[x] = ++siz] = x;
for (auto o : a[x]) {
if (o.first == fa[x]) continue;
int y = o.first;
fa[y] = x, dep[y] = dep[x] + 1;
f[y] = (f[x] + o.second) & 1;
dfs(y);
}
r[x] = siz;
}
inline void build(int idx, int l, int r) {
tg[idx] = 0;
if (l == r) {
T[idx].val[f[rev[l]]] = dep[rev[l]];
T[idx].val[f[rev[l]] ^ 1] = 0;
return;
}
int mid = l + r >> 1;
build(idx << 1, l, mid), build(idx << 1 | 1, mid + 1, r);
T[idx] = T[idx << 1] + T[idx << 1 | 1];
}
inline void R(int o) {
swap(T[o].val[0], T[o].val[1]);
tg[o] ^= 1;
}
inline void pushdown(int o) {
if (tg[o]) R(o << 1), R(o << 1 | 1), tg[o] = 0;
}
inline void modify(int now, int l, int r, int ql, int qr) {
if (l == ql && r == qr) return R(now);
int mid = l + r >> 1;
pushdown(now);
if (mid >= qr)
modify(now << 1, l, mid, ql, qr);
else if (mid + 1 <= ql)
modify(now << 1 | 1, mid + 1, r, ql, qr);
else
modify(now << 1, l, mid, ql, mid),
modify(now << 1 | 1, mid + 1, r, mid + 1, qr);
T[now] = T[now << 1] + T[now << 1 | 1];
}
inline void run(int rt) {
fa[rt] = dep[rt] = siz = 0;
dfs(rt);
build(1, 1, N);
for (int i = 1; i <= M; ++i) {
int x = G[idx[i] - 1].first, y = G[idx[i] - 1].second;
if (fa[x] == y) swap(x, y);
modify(1, 1, N, l[y], r[y]);
chkmax(ans[i], T[1].val[0]);
}
}
} A, B;
inline void dfs(int x) {
for (auto o : a[x]) {
if (o.first == fa[x]) continue;
int y = o.first;
fa[y] = x, dep[y] = dep[x] + 1;
dfs(y);
}
if (!rt || dep[x] > dep[rt]) rt = x;
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
a[u].emplace_back(make_pair(v, w));
a[v].emplace_back(make_pair(u, w));
G.emplace_back(make_pair(u, v));
}
scanf("%d", &M);
for (int i = 1; i <= M; ++i) scanf("%d", &idx[i]);
rt = 0, fa[1] = dep[1] = 0;
dfs(1);
int r1 = rt, r2;
rt = 0;
fa[r1] = dep[r1] = 0;
dfs(r1);
r2 = rt;
A.run(r1);
B.run(r2);
for (int i = 1; i <= M; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500000;
int s[N], t[N], type[N];
int q, qind[N];
void dfs(int n, vector<vector<int>>& adj, int root, void preVisit(int, int) = 0,
void postVisit(int, int) = 0, void traverseTreeEdge(int, int, int) = 0,
void traverseBackEdge(int, int) = 0) {
vector<int> parent(n, -2);
vector<int> stackNode(n);
vector<int> stackEdgeIndex(n);
int stackSize = 1;
stackNode[0] = root;
stackEdgeIndex[0] = 0;
parent[root] = -1;
while (stackSize > 0) {
int node = stackNode[stackSize - 1];
int edgeIndex = stackEdgeIndex[stackSize - 1];
if (edgeIndex == 0 && preVisit) {
preVisit(node, parent[node]);
}
if (edgeIndex == adj[node].size()) {
stackSize--;
if (postVisit) {
postVisit(node, parent[node]);
}
} else {
int e = adj[node][edgeIndex];
int other = s[e] == node ? t[e] : s[e];
stackEdgeIndex[stackSize - 1]++;
if (parent[other] == -2) {
parent[other] = node;
if (traverseTreeEdge) traverseTreeEdge(node, other, e);
stackNode[stackSize] = other;
stackEdgeIndex[stackSize] = 0;
stackSize++;
} else if (other != parent[node]) {
if (traverseBackEdge) traverseBackEdge(node, other);
}
}
}
}
int depth[N];
bool good[N];
int preorder[N], postorder[N];
int subtreeRoot[N];
int curorder;
void preVisit(int v, int p) {
preorder[v] = curorder++;
if (p == -1) {
depth[v] = 0;
good[v] = true;
} else {
depth[v] = depth[p] + 1;
}
}
void postVisit(int v, int p) { postorder[v] = curorder - 1; }
void traverseTreeEdge(int p, int v, int e) {
if (type[e])
good[v] = !good[p];
else
good[v] = good[p];
subtreeRoot[e] = v;
}
int getFurthest(int n, vector<vector<int>>& adj, int root) {
dfs(n, adj, root, preVisit);
int ans = 0;
for (int i = 1; i < n; i++)
if (depth[i] > depth[ans]) ans = i;
return ans;
}
int ans[N];
struct Node {
Node* left = 0;
Node* right = 0;
int leftValue;
int rightValue;
bool inverted = false;
int goodDepth = 0, badDepth = 0;
};
class SegmentTree {
public:
SegmentTree(int n) { root = buildTree(0, n - 1); }
~SegmentTree() { dispose(root); }
void dispose(Node* node) {
if (!node) return;
dispose(node->left);
dispose(node->right);
delete node;
}
Node* buildTree(int l, int r) {
Node* node = new Node();
node->leftValue = l;
node->rightValue = r;
if (l < r) {
int mid = (l + r) / 2;
node->left = buildTree(l, mid);
node->right = buildTree(mid + 1, r);
}
return node;
}
void setDepth(int ind, int depth, bool good) {
setDepth(root, ind, depth, good);
}
void setDepth(Node* node, int ind, int depth, bool good) {
if (node->rightValue == ind && node->leftValue == ind) {
if (good)
node->goodDepth = depth;
else
node->badDepth = depth;
return;
}
if (ind <= node->left->rightValue)
setDepth(node->left, ind, depth, good);
else
setDepth(node->right, ind, depth, good);
node->goodDepth = max(node->left->goodDepth, node->right->goodDepth);
node->badDepth = max(node->left->badDepth, node->right->badDepth);
}
void addSegment(int left, int right) { addSegment(root, left, right); }
void pushLazy(Node* node) {
if (node->inverted) {
swap(node->goodDepth, node->badDepth);
if (node->left) node->left->inverted = !node->left->inverted;
if (node->right) node->right->inverted = !node->right->inverted;
node->inverted = false;
}
}
void addSegment(Node* node, int left, int right) {
if (node->rightValue < left || node->leftValue > right) return;
if (left <= node->leftValue && right >= node->rightValue) {
node->inverted = !node->inverted;
return;
}
pushLazy(node);
addSegment(node->left, left, right);
addSegment(node->right, left, right);
node->goodDepth = node->badDepth = 0;
if (node->left) {
pushLazy(node->left);
node->goodDepth = node->left->goodDepth;
node->badDepth = node->left->badDepth;
}
if (node->right) {
pushLazy(node->right);
node->goodDepth = max(node->goodDepth, node->right->goodDepth);
node->badDepth = max(node->badDepth, node->right->badDepth);
}
}
int query(int left, int right) { return query(root, left, right); }
int query(Node* node, int left, int right) {
if (!node || node->rightValue < left || node->leftValue > right) return 0;
pushLazy(node);
if (left <= node->leftValue && right >= node->rightValue) {
return node->goodDepth;
}
return max(query(node->left, left, right), query(node->right, left, right));
}
Node* root;
};
void solve(int n, vector<vector<int>>& adj, int root) {
curorder = 0;
dfs(n, adj, root, preVisit, postVisit, traverseTreeEdge);
SegmentTree tree(n);
for (int i = 0; i < n; i++) tree.setDepth(preorder[i], depth[i], good[i]);
for (int i = 0; i < q; i++) {
int v = subtreeRoot[qind[i]];
tree.addSegment(preorder[v], postorder[v]);
ans[i] = max(ans[i], tree.query(0, n - 1));
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 0; i < n - 1; i++) {
cin >> s[i] >> t[i] >> type[i];
s[i]--;
t[i]--;
adj[s[i]].push_back(i);
adj[t[i]].push_back(i);
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> qind[i];
qind[i]--;
}
int v1 = getFurthest(n, adj, 0);
int v2 = getFurthest(n, adj, v1);
memset(ans, 0, sizeof(ans));
solve(n, adj, v1);
solve(n, adj, v2);
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using pii = pair<int, int>;
using PLL = pair<LL, LL>;
using UI = unsigned int;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int N = 5e5 + 10;
int n, Q, dfs_cnt;
bool edge[N];
vector<pii> V[N];
int buf[N];
bool tag[N];
struct Tree {
int lft[N], rgt[N], bottom[N], l[N << 2], r[N << 2], S[N << 2][2];
bool lazy[N << 2];
void dfs(int x, int fa, int dep, bool f) {
lft[x] = ++dfs_cnt;
buf[dfs_cnt] = dep;
tag[dfs_cnt] = f;
for (auto p : V[x]) {
if (p.first == fa) continue;
bottom[p.second] = p.first;
dfs(p.first, x, dep + 1, f ^ edge[p.second]);
}
rgt[x] = dfs_cnt;
}
void build(int o, int ll, int rr) {
l[o] = ll;
r[o] = rr;
lazy[o] = 0;
if (ll < rr) {
int mid = l[o] + r[o] >> 1;
build(o << 1, ll, mid);
build(o << 1 | 1, mid + 1, rr);
S[o][0] = max(S[o << 1][0], S[o << 1 | 1][0]);
S[o][1] = max(S[o << 1][1], S[o << 1 | 1][1]);
} else {
if (tag[ll]) {
S[o][0] = 0;
S[o][1] = buf[ll];
} else {
S[o][0] = buf[ll];
S[o][1] = 0;
}
}
}
int pushdown(int o) {
int mid = l[o] + r[o] >> 1;
if (lazy[o]) {
update(o << 1, l[o], mid);
update(o << 1 | 1, mid + 1, r[o]);
lazy[o] = 0;
}
return mid;
}
void update(int o, int ll, int rr) {
if (l[o] == ll && r[o] == rr) {
lazy[o] ^= 1;
swap(S[o][0], S[o][1]);
return;
}
int mid = pushdown(o);
if (rr <= mid)
update(o << 1, ll, rr);
else if (ll > mid)
update(o << 1 | 1, ll, rr);
else {
update(o << 1, ll, mid);
update(o << 1 | 1, mid + 1, rr);
}
S[o][0] = max(S[o << 1][0], S[o << 1 | 1][0]);
S[o][1] = max(S[o << 1][1], S[o << 1 | 1][1]);
}
void init(int x) {
dfs_cnt = 0;
dfs(x, -1, 0, 0);
build(1, 1, n);
}
void flip(int x) {
x = bottom[x];
update(1, lft[x], rgt[x]);
}
} tree[2];
int dist[N];
int bfs(int x) {
for (int i = (1); i < (n + 1); ++i) dist[i] = inf;
dist[x] = 0;
int ret = x;
queue<int> Q;
Q.emplace(x);
while (!Q.empty()) {
x = Q.front();
Q.pop();
if (dist[x] > dist[ret]) ret = x;
for (pii p : V[x]) {
if (dist[p.first] == inf) {
dist[p.first] = dist[x] + 1;
Q.emplace(p.first);
}
}
}
return ret;
}
int main() {
int x, y, z;
scanf("%d", &n);
for (int i = (1); i < (n); ++i) {
scanf("%d %d %d", &x, &y, &z);
V[x].emplace_back(y, i);
V[y].emplace_back(x, i);
edge[i] = z;
}
x = bfs(1);
y = bfs(x);
tree[0].init(x);
tree[1].init(y);
scanf("%d", &Q);
while (Q--) {
scanf("%d", &x);
tree[0].flip(x);
tree[1].flip(x);
printf("%d\n", max(tree[0].S[1][0], tree[1].S[1][0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > AdjList[500005];
int id[500005];
int A[500005];
int B[500005];
int T[500005];
int ans[500005];
int n, m;
int dist1[500005];
int dist2[500005];
int indx[500005];
int right1[500005];
int inv[500005];
bool visited[500005];
int cnt;
void dfs(int u, int d1, int d2) {
if (visited[u]) {
return;
}
visited[u] = true;
dist1[u] = d1;
dist2[u] = d2;
indx[u] = cnt;
inv[cnt] = u;
cnt++;
for (pair<int, int> v : AdjList[u]) {
if (!visited[v.first]) {
dfs(v.first, d1 + 1, d2 ^ v.second);
}
}
right1[u] = cnt - 1;
}
int findFurthestVertex(int root) {
for (int i = 1; i <= n; i++) {
visited[i] = 0;
}
cnt = 1;
dfs(root, 0, 0);
int maxDist = -1;
int bestVertex = -1;
for (int i = 1; i <= n; i++) {
if (dist1[i] > maxDist) {
maxDist = dist1[i];
bestVertex = i;
}
}
return bestVertex;
}
int max0[(1 << 20) + 5];
int max1[(1 << 20) + 5];
int lazyterbalik[(1 << 20) + 5];
void init(int i = 1, int s = 1, int e = n) {
if (s == e) {
lazyterbalik[i] = 0;
if (dist2[inv[s]] == 0) {
max0[i] = dist1[inv[s]];
max1[i] = -1;
} else {
max1[i] = dist1[inv[s]];
max0[i] = -1;
}
return;
} else {
int l = (i << 1);
int r = (i << 1) | 1;
int m = (s + e) >> 1;
init(l, s, m);
init(r, m + 1, e);
max0[i] = max(max0[l], max0[r]);
max1[i] = max(max1[l], max1[r]);
lazyterbalik[i] = 0;
}
}
void propagate(int i, int s, int e) {
if (lazyterbalik[i]) {
if (s == e) {
swap(max0[i], max1[i]);
lazyterbalik[i] = 0;
return;
} else {
int l = (i << 1);
int r = (i << 1) | 1;
lazyterbalik[l] ^= 1;
lazyterbalik[r] ^= 1;
swap(max0[i], max1[i]);
lazyterbalik[i] = 0;
return;
}
}
}
void update(int x, int y, int i = 1, int s = 1, int e = n) {
propagate(i, s, e);
if (x <= s && e <= y) {
lazyterbalik[i] ^= 1;
return;
} else {
int l = (i << 1);
int r = (i << 1) | 1;
int m = (s + e) >> 1;
if (x > m) {
update(x, y, r, m + 1, e);
} else if (y <= m) {
update(x, y, l, s, m);
} else {
update(x, y, l, s, m);
update(x, y, r, m + 1, e);
}
propagate(l, s, m);
propagate(r, m + 1, e);
max0[i] = max(max0[l], max0[r]);
max1[i] = max(max1[l], max1[r]);
}
}
int query() {
propagate(1, 1, n);
return max0[1];
}
void findAns(int root) {
findFurthestVertex(root);
init();
for (int i = 1; i <= m; i++) {
int u = A[id[i]];
int v = B[id[i]];
if (dist1[u] < dist1[v]) {
swap(u, v);
}
update(indx[u], right1[u]);
ans[i] = max(ans[i], query());
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &A[i], &B[i], &T[i]);
AdjList[A[i]].push_back(pair<int, int>(B[i], T[i]));
AdjList[B[i]].push_back(pair<int, int>(A[i], T[i]));
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &id[i]);
}
memset(ans, -1, sizeof(ans));
int root = findFurthestVertex(1);
findAns(root);
int root2 = findFurthestVertex(root);
findAns(root2);
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
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;
const int maxn = 1e6;
int n, x[555555], y[555555], t[555555], cnt, beg[555555], en[555555],
dep[555555], crt, vl[555555], b[555555], e[555555], id, Log[1111111],
ww[555555], q;
struct treenode {
int lazy, x0, y0, x1, y1, mx0, mx1;
treenode() {
x0 = y0 = x1 = y1 = -1;
mx0 = mx1 = -1e9;
lazy = 0;
}
} tree[2222222];
vector<pair<int, int> > g[555555];
int arr[1111111], st[22][1111111];
void dfs(int i, int fa) {
dep[i] = dep[fa] + 1;
beg[i] = ++cnt;
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j].first, val = g[i][j].second;
if (to == fa) continue;
vl[to] = vl[i] ^ val;
dfs(to, i);
}
en[i] = cnt;
}
void rfs(int i, int fa) {
++crt;
b[i] = crt;
arr[crt] = dep[i];
for (int j = 0; j < g[i].size(); j++) {
int to = g[i][j].first;
if (to == fa) continue;
rfs(to, i);
++crt;
arr[crt] = dep[i];
}
e[i] = crt;
}
int get(int l, int r) {
int x = Log[r - l + 1];
return min(st[x][l], st[x][r - (1 << x) + 1]);
}
int dist(int x, int y) {
if (x == -1 || y == -1) return -1e9;
if (b[x] > b[y]) swap(x, y);
return dep[x] + dep[y] - (get(b[x], e[y]) << 1);
}
void pushup(int node) {
int mx = -2e9, cr;
if (tree[node << 1].mx0 > mx) {
mx = tree[node << 1].mx0;
tree[node].x0 = tree[node << 1].x0;
tree[node].y0 = tree[node << 1].y0;
}
if (tree[(node << 1) | 1].mx0 > mx) {
mx = tree[(node << 1) | 1].mx0;
tree[node].x0 = tree[(node << 1) | 1].x0;
tree[node].y0 = tree[(node << 1) | 1].y0;
}
cr = dist(tree[node << 1].x0, tree[(node << 1) | 1].x0);
if (cr > mx) {
mx = cr;
tree[node].x0 = tree[node << 1].x0;
tree[node].y0 = tree[(node << 1) | 1].x0;
}
cr = dist(tree[node << 1].x0, tree[(node << 1) | 1].y0);
if (cr > mx) {
mx = cr;
tree[node].x0 = tree[node << 1].x0;
tree[node].y0 = tree[(node << 1) | 1].y0;
}
cr = dist(tree[node << 1].y0, tree[(node << 1) | 1].x0);
if (cr > mx) {
mx = cr;
tree[node].x0 = tree[node << 1].y0;
tree[node].y0 = tree[(node << 1) | 1].x0;
}
cr = dist(tree[node << 1].y0, tree[(node << 1) | 1].y0);
if (cr > mx) {
mx = cr;
tree[node].x0 = tree[node << 1].y0;
tree[node].y0 = tree[(node << 1) | 1].y0;
}
tree[node].mx0 = mx;
mx = -2e9;
if (tree[node << 1].mx1 > mx) {
mx = tree[node << 1].mx1;
tree[node].x1 = tree[node << 1].x1;
tree[node].y1 = tree[node << 1].y1;
}
if (tree[(node << 1) | 1].mx1 > mx) {
mx = tree[(node << 1) | 1].mx1;
tree[node].x1 = tree[(node << 1) | 1].x1;
tree[node].y1 = tree[(node << 1) | 1].y1;
}
cr = dist(tree[node << 1].x1, tree[(node << 1) | 1].x1);
if (cr > mx) {
mx = cr;
tree[node].x1 = tree[node << 1].x1;
tree[node].y1 = tree[(node << 1) | 1].x1;
}
cr = dist(tree[node << 1].x1, tree[(node << 1) | 1].y1);
if (cr > mx) {
mx = cr;
tree[node].x1 = tree[node << 1].x1;
tree[node].y1 = tree[(node << 1) | 1].y1;
}
cr = dist(tree[node << 1].y1, tree[(node << 1) | 1].x1);
if (cr > mx) {
mx = cr;
tree[node].x1 = tree[node << 1].y1;
tree[node].y1 = tree[(node << 1) | 1].x1;
}
cr = dist(tree[node << 1].y1, tree[(node << 1) | 1].y1);
if (cr > mx) {
mx = cr;
tree[node].x1 = tree[node << 1].y1;
tree[node].y1 = tree[(node << 1) | 1].y1;
}
tree[node].mx1 = mx;
}
void push(int node) {
tree[node].lazy ^= 1;
swap(tree[node].x0, tree[node].x1);
swap(tree[node].y0, tree[node].y1);
swap(tree[node].mx0, tree[node].mx1);
}
void pushdown(int node) {
if (tree[node].lazy) {
push(node << 1);
push((node << 1) | 1);
tree[node].lazy = 0;
}
}
void build(int l, int r, int node) {
if (l == r) {
if (vl[ww[l]] == 1) {
tree[node].x0 = tree[node].y0 = ww[l];
tree[node].x1 = tree[node].y1 = -1;
tree[node].mx0 = 0;
tree[node].mx1 = -1e9;
} else {
tree[node].x1 = tree[node].y1 = ww[l];
tree[node].x0 = tree[node].y0 = -1;
tree[node].mx0 = -1e9;
tree[node].mx1 = 0;
}
return;
}
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, (node << 1) | 1);
pushup(node);
}
void update(int beg, int en, int l, int r, int node) {
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
push(node);
return;
}
int mid = (l + r) >> 1;
pushdown(node);
update(beg, en, l, mid, node << 1);
update(beg, en, mid + 1, r, (node << 1) | 1);
pushup(node);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x[i], &y[i], &t[i]);
g[x[i]].push_back(make_pair(y[i], t[i]));
g[y[i]].push_back(make_pair(x[i], t[i]));
}
dfs(1, 0);
rfs(1, 0);
for (int i = 2; i <= maxn; i++) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= crt; i++) st[0][i] = arr[i];
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= crt; j++) {
st[i][j] = st[i - 1][j];
if (j + (1 << (i - 1)) <= crt)
st[i][j] = min(st[i][j], st[i - 1][j + (1 << (i - 1))]);
}
}
for (int i = 1; i <= n; i++) ww[beg[i]] = i;
build(1, n, 1);
scanf("%d", &q);
while (q--) {
scanf("%d", &id);
if (dep[x[id]] < dep[y[id]]) swap(x[id], y[id]);
update(beg[x[id]], en[x[id]], 1, n, 1);
printf("%d\n", max(tree[1].mx0, tree[1].mx1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int next_x[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const int next_y[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const double PI = acos(-1.0);
const int MAXN = 1e6 + 5;
const int N = 4e6 + 5;
const long double eps = 1e-8;
const long double fix = 1e-2;
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;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
return 1;
}
inline bool read(char &x) {
while ((x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
x == '\n' || x == '\r')
;
return x != EOF;
}
inline bool read(char *x) {
while ((*x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*x == ' ' || *x == '\r')
;
if (*x == EOF) return 0;
while (!(*x == '\n' || *x == ' ' || *x == '\r' || *x == EOF))
*(++x) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*x = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &x, B &...y) {
return read(x) && read(y...);
}
template <typename A>
inline bool write(A x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char x) {
putc(x);
return 0;
}
inline bool write(const char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
inline bool write(char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A x, B... y) {
return write(x) || write(y...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
namespace seg {
int mx[MAXN * 4][2], rev[MAXN * 4];
void dorev(int cnt) { rev[cnt] ^= 1, swap(mx[cnt][0], mx[cnt][1]); }
void up(int cnt) {
for (int k = (0), I = (1) + 1; k < I; ++k)
mx[cnt][k] = max(mx[(cnt << 1)][k], mx[(cnt << 1 | 1)][k]);
}
void down(int cnt) {
if (rev[cnt]) dorev((cnt << 1)), dorev((cnt << 1 | 1)), rev[cnt] = 0;
}
void build(int l, int r, int a[], int d[], int cnt) {
rev[cnt] = 0;
if (l == r) {
mx[cnt][a[l]] = d[l], mx[cnt][!a[l]] = 0;
return;
}
build(l, ((l + r) / 2), a, d, (cnt << 1)),
build(((l + r) / 2) + 1, r, a, d, (cnt << 1 | 1)), up(cnt);
}
void flip(int l, int r, int nl, int nr, int cnt) {
if (l == nl && r == nr) return dorev(cnt);
down(cnt);
if (nr <= ((l + r) / 2))
flip(l, ((l + r) / 2), nl, nr, (cnt << 1));
else if (nl > ((l + r) / 2))
flip(((l + r) / 2) + 1, r, nl, nr, (cnt << 1 | 1));
else
flip(l, ((l + r) / 2), nl, ((l + r) / 2), (cnt << 1)),
flip(((l + r) / 2) + 1, r, ((l + r) / 2) + 1, nr, (cnt << 1 | 1));
up(cnt);
}
} // namespace seg
int n, m, tim = 0;
int u[MAXN], v[MAXN], w[MAXN], q[MAXN];
int a[MAXN], d[MAXN], _a[MAXN], _d[MAXN], ans[MAXN], st[MAXN], ed[MAXN],
node[MAXN];
struct edge {
int u, v, w, next;
} e[MAXN * 2];
int pre[MAXN], edge_cnt = 0;
void addedge(int u, int v, int w = 0) {
edge_cnt = edge_cnt + 1, e[edge_cnt].u = u, e[edge_cnt].v = v,
e[edge_cnt].w = w, e[edge_cnt].next = pre[u], pre[u] = edge_cnt;
};
void dfs(int u, int fa) {
st[u] = ++tim, node[tim] = u, d[u] = d[fa] + 1;
for (long long i = pre[u], v = e[i].v, w = e[i].w; i;
i = e[i].next, v = e[i].v, w = e[i].w)
if (v != fa) a[v] = a[u] ^ w, dfs(v, u);
ed[u] = tim;
}
void solve(int root) {
tim = 0, a[root] = 0, d[0] = -1, dfs(root, 0);
for (int i = (1), I = (n) + 1; i < I; ++i)
_a[i] = a[node[i]], _d[i] = d[node[i]];
seg::build(1, n, _a, _d, 1);
for (int i = (1), I = (m) + 1; i < I; ++i) {
int x = d[u[q[i]]] > d[v[q[i]]] ? u[q[i]] : v[q[i]];
seg::flip(1, n, st[x], ed[x], 1), ans[i] = max(ans[i], seg::mx[1][0]);
}
}
int find(int u, int fa) {
int ans = u;
d[u] = d[fa] + 1;
for (int i = pre[u], v = e[i].v; i; i = e[i].next, v = e[i].v)
if (v != fa) {
int res = find(v, u);
if (d[res] > d[ans]) ans = res;
}
return ans;
}
int work() {
io::read(n);
for (int i = (1), I = (n - 1) + 1; i < I; ++i) {
io::read(u[i]), io::read(v[i]), io::read(w[i]);
addedge(u[i], v[i], w[i]), addedge(v[i], u[i], w[i]);
}
io::read(m);
for (int i = (1), I = (m) + 1; i < I; ++i) io::read(q[i]);
int root;
solve(root = find(1, 0)), solve(find(root, 0));
for (int i = (1), I = (m) + 1; i < I; ++i) io::write(ans[i]), io::write('\n');
io::flush();
return 0;
}
int main() {
work();
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;
int n, m, r1, r2, t1[2000005][2], t2[2000005][2], d1[500005], a1[500005],
d2[500005], a2[500005];
int i1[500005], o1[500005], i2[500005], o2[500005], st, s1[500005], s2[500005],
L, R;
int f1[500005], f2[500005];
bool b1[2000005], b2[2000005];
vector<int> v[500005], e[500005], ve[500005];
int mx(int x, int y) { return x > y ? x : y; }
void dfs(int x, int y) {
d1[x] = d1[y] + 1;
i1[x] = ++st;
s1[st] = x;
for (int i = 0; i < v[x].size(); ++i) {
int z = v[x][i];
if (z != y) {
a1[z] = a1[x] ^ e[x][i];
f1[ve[x][i]] = z;
dfs(z, x);
}
}
o1[x] = st;
}
void bld1(int k, int l, int r) {
if (l == r) {
t1[k][a1[s1[l]]] = d1[s1[l]];
return;
}
int m = (l + r) >> 1, lc = k << 1, rc = lc ^ 1;
bld1(lc, l, m), bld1(rc, m + 1, r);
t1[k][0] = mx(t1[lc][0], t1[rc][0]);
t1[k][1] = mx(t1[lc][1], t1[rc][1]);
}
void bld2(int k, int l, int r) {
if (l == r) {
t2[k][a2[s2[l]]] = d2[s2[l]];
return;
}
int m = (l + r) >> 1, lc = k << 1, rc = lc ^ 1;
bld2(lc, l, m), bld2(rc, m + 1, r);
t2[k][0] = mx(t2[lc][0], t2[rc][0]);
t2[k][1] = mx(t2[lc][1], t2[rc][1]);
}
void mk1(int k, int l, int r) {
if (l >= L && r <= R) {
b1[k] ^= 1;
swap(t1[k][0], t1[k][1]);
return;
}
int m = (l + r) >> 1, lc = k << 1, rc = lc ^ 1;
if (b1[k]) {
b1[lc] ^= 1;
swap(t1[lc][0], t1[lc][1]);
b1[rc] ^= 1;
swap(t1[rc][0], t1[rc][1]);
b1[k] = 0;
}
if (L <= m) mk1(lc, l, m);
if (R > m) mk1(rc, m + 1, r);
t1[k][0] = mx(t1[lc][0], t1[rc][0]);
t1[k][1] = mx(t1[lc][1], t1[rc][1]);
}
void mk2(int k, int l, int r) {
if (l >= L && r <= R) {
b2[k] ^= 1;
swap(t2[k][0], t2[k][1]);
return;
}
int m = (l + r) >> 1, lc = k << 1, rc = lc ^ 1;
if (b2[k]) {
b2[lc] ^= 1;
swap(t2[lc][0], t2[lc][1]);
b2[rc] ^= 1;
swap(t2[rc][0], t2[rc][1]);
b2[k] = 0;
}
if (L <= m) mk2(lc, l, m);
if (R > m) mk2(rc, m + 1, r);
t2[k][0] = mx(t2[lc][0], t2[rc][0]);
t2[k][1] = mx(t2[lc][1], t2[rc][1]);
}
int main() {
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), v[y].push_back(x);
e[x].push_back(z), e[y].push_back(z);
ve[x].push_back(i), ve[y].push_back(i);
}
dfs(1, 0);
r2 = 1;
for (int i = 1; i <= n; ++i)
if (d1[i] > d1[r2]) r2 = i;
a1[r2] = 0;
st = 0;
dfs(r2, 0);
for (int i = 1; i <= n; ++i)
if (d1[i] > d1[r1]) r1 = i;
for (int i = 1; i <= n; ++i)
a2[i] = a1[i], d2[i] = d1[i], i2[i] = i1[i], o2[i] = o1[i], s2[i] = s1[i],
f2[i] = f1[i];
a1[r1] = 0;
st = 0;
dfs(r1, 0);
bld1(1, 1, n);
bld2(1, 1, n);
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
L = i1[f1[x]], R = o1[f1[x]];
mk1(1, 1, n);
L = i2[f2[x]], R = o2[f2[x]];
mk2(1, 1, n);
printf("%d\n", mx(t1[1][0], t2[1][0]) - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long rand(long long x, long long y) {
return rng() % (y + 1 - x) + x;
}
string inline to_string(char c) {
string second(1, c);
return second;
}
template <typename T>
inline T gcd(T a, T b) {
return a == 0 ? llabs(b) : gcd(b % a, a);
}
using ll = long long;
using ld = long double;
using pi = pair<ll, ll>;
using spi = pair<ll, pi>;
using dpi = pair<pi, pi>;
long long LLINF = 1e18;
int INF = 1e9 + 1e6;
ll n, m;
bool on[(500006)];
vector<pi> v[(500006)];
pi E[(500006)];
struct tree {
int r, st[(500006)], en[(500006)], co, dist[(500006)];
bool par[(500006)];
struct node {
int second, e, m;
ll mx[2];
bool flip;
node *l, *r;
node(int S, int E) {
second = S, e = E, m = (second + e) >> 1;
mx[0] = mx[1] = flip = 0;
if (second ^ e) l = new node(second, m), r = new node(m + 1, e);
}
void update(int x, int y) {
if (second == x && e == y) {
flip ^= 1;
return;
}
if (x > m)
r->update(x, y);
else if (y <= m)
l->update(x, y);
else
l->update(x, m), r->update(m + 1, y);
l->value(), r->value();
for (ll i = 0; i <= ll(1); ++i) mx[i] = max(l->mx[i], r->mx[i]);
}
void set(int x, pi nval) {
if (second == e) {
mx[nval.first] = max(mx[nval.first], nval.second);
return;
}
if (x > m)
r->set(x, nval);
else
l->set(x, nval);
for (ll i = 0; i <= ll(1); ++i) mx[i] = max(l->mx[i], r->mx[i]);
}
void value() {
if (!flip) return;
flip = 0;
swap(mx[0], mx[1]);
if (second ^ e) l->flip ^= 1, r->flip ^= 1;
}
void pt() {
value();
if (second ^ e) l->pt(), r->pt();
cerr << second << ' ' << m << ' ' << e << ": " << mx[0] << ' ' << mx[1]
<< '\n';
}
} * seg;
void init(int _r) {
r = _r;
seg = new node(1, n), co = 1;
function<void(ll, ll)> dfs = [&](ll x, ll p) {
st[x] = co++;
for (auto i : v[x])
if (i.first ^ p)
par[i.first] = par[x] ^ on[i.second], dist[i.first] = dist[x] + 1,
dfs(i.first, x);
en[x] = co - 1;
};
par[r] = 0, dist[r] = 0, dfs(r, r);
for (ll i = 1; i <= ll(n); ++i) seg->set(st[i], {par[i], dist[i]});
}
void flip(int id) {
int a = E[id].first, b = E[id].second;
if (st[a] > st[b]) swap(a, b);
seg->update(st[b], en[b]);
}
ll ans() {
seg->value();
return seg->mx[0];
}
} A, B;
pi diam() {
ll r1 = 1, r2 = 1, mx = 0;
function<void(ll, ll, ll)> dfs = [&](ll x, ll p, ll d) {
if (d > mx) r1 = x, mx = d;
for (auto i : v[x])
if (i.first ^ p) dfs(i.first, x, d + 1);
};
dfs(1, 1, 0);
r2 = r1, mx = 0;
dfs(r2, r2, 0);
return pi(r1, r2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (ll i = 1; i <= ll(n - 1); ++i) {
ll a, b;
cin >> a >> b >> on[i];
v[a].emplace_back(b, i), v[b].emplace_back(a, i);
E[i] = {a, b};
}
pi nodes = diam();
A.init(nodes.first), B.init(nodes.second);
cin >> m;
while (m--) {
int id;
cin >> id;
A.flip(id), B.flip(id);
on[id] ^= 1;
cout << max(A.ans(), B.ans()) << '\n';
}
}
|
#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>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, t...);
}
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
template <class A, class B, class C>
struct Triple {
A first;
B second;
C third;
bool operator<(const Triple& t) const {
if (first != t.first) return first < t.first;
if (second != t.second) return second < t.second;
return third < t.third;
}
};
template <class T>
void ResizeVec(T&, vector<long long>) {}
template <class T>
void ResizeVec(vector<T>& vec, vector<long long> sz) {
vec.resize(sz[0]);
sz.erase(sz.begin());
if (sz.empty()) {
return;
}
for (T& v : vec) {
ResizeVec(v, sz);
}
}
template <class A, class B, class C>
ostream& operator<<(ostream& out, Triple<A, B, C> t) {
return out << "(" << t.first << ", " << t.second << ", " << t.third << ")";
}
template <class T>
ostream& operator<<(ostream& out, vector<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class T>
ostream& operator<<(ostream& out, set<T> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
template <class L, class R>
ostream& operator<<(ostream& out, map<L, R> vec) {
out << "(";
for (auto& v : vec) out << v << ", ";
return out << ")";
}
struct Edge {
long long to, id;
};
const long long N = 1e6 + 5;
vector<Edge> slo[N];
long long ktory;
long long vis[N];
long long pre[N][3];
long long sz[N][3];
long long dep[N][3];
const long long M = 1 << 20;
long long d;
void Dfs(long long v, long long id) {
vis[v] = id;
sz[v][id] = 1;
d++;
pre[v][id] = d;
for (auto e : slo[v]) {
long long nei = e.to;
if (vis[nei] == id) {
continue;
}
dep[nei][id] = 1 + dep[v][id];
Dfs(nei, id);
sz[v][id] += sz[nei][id];
}
}
struct Node {
long long ma0, ma1, to_push;
Node() {
ma0 = -N, ma1 = -N;
to_push = 0;
}
};
struct Drz {
vector<Node> drz;
Drz() { drz.resize(2 * M + 5); }
Node& operator[](long long a) { return drz[a]; }
void Touch(long long v) {
if (drz[v].to_push) {
for (long long son = (2 * v); son <= (2 * v + 1); ++son) {
drz[son].to_push ^= 1;
swap(drz[son].ma0, drz[son].ma1);
}
}
drz[v].to_push = 0;
}
void Flip(long long bl, long long br, long long l, long long r, long long v) {
if (l > br || r < bl) {
return;
}
if (l <= bl && br <= r) {
drz[v].to_push ^= 1;
swap(drz[v].ma0, drz[v].ma1);
return;
}
Touch(v);
long long m = (bl + br) / 2;
Flip(bl, m, l, r, 2 * v);
Flip(m + 1, br, l, r, 2 * v + 1);
drz[v].ma0 = max(drz[2 * v].ma0, drz[2 * v + 1].ma0);
drz[v].ma1 = max(drz[2 * v].ma1, drz[2 * v + 1].ma1);
}
};
Drz drz[3];
int32_t main() {
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(10);
if (0) cout << fixed << setprecision(10);
cin.tie(0);
long long n;
cin >> n;
vector<pair<long long, long long> > to_change;
vector<pair<long long, long long> > es;
for (long long i = (1); i <= (n - 1); ++i) {
long long a, b, c;
cin >> a >> b >> c;
es.push_back({a, b});
slo[a].push_back({b, i});
slo[b].push_back({a, i});
if (c) {
to_change.push_back({a, b});
}
}
for (long long i = (1); i <= (n); ++i) {
vis[i] = -1;
}
d = 0;
Dfs(1, 0);
long long sr1 = 1;
for (long long i = (1); i <= (n); ++i) {
if (dep[i][0] > dep[sr1][0]) {
sr1 = i;
}
}
d = 0;
Dfs(sr1, 1);
long long sr2 = 1;
for (long long i = (1); i <= (n); ++i) {
if (dep[i][1] > dep[sr2][1]) {
sr2 = i;
}
}
d = 0;
Dfs(sr2, 2);
(sr1, sr2);
for (long long wh = (1); wh <= (2); ++wh) {
for (long long v = (1); v <= (n); ++v) {
drz[wh][M - 1 + pre[v][wh]].ma0 = dep[v][wh];
}
for (long long i = (M - 1); i >= (1); --i) {
drz[wh][i].ma0 = max(drz[wh][2 * i].ma0, drz[wh][2 * i + 1].ma0);
}
}
function<void(long long, long long)> Change = [&](long long a, long long b) {
for (long long wh = (1); wh <= (2); ++wh) {
if (dep[b][wh] > dep[a][wh]) {
swap(a, b);
}
drz[wh].Flip(1, M, pre[a][wh], pre[a][wh] + sz[a][wh] - 1, 1);
}
};
for (auto ch : to_change) {
Change(ch.first, ch.second);
}
long long m;
cin >> m;
for (long long i = (1); i <= (m); ++i) {
long long id;
cin >> id;
long long a = es[id - 1].first;
long long b = es[id - 1].second;
Change(a, b);
(a, b);
(drz[1][1].ma0, drz[2][1].ma0);
cout << max(drz[1][1].ma0, drz[2][1].ma0) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m;
int x[1111111], y[1111111], l[1111111];
int o[1111111];
std::vector<int> v[1111111];
struct Segt {
int mx[4111111][2], r[4111111];
void push(int p) { std::swap(mx[p][0], mx[p][1]), r[p] ^= 1; }
void pushd(int p) {
if (r[p]) push(p << 1), push(p << 1 | 1), r[p] = 0;
}
void pushu(int p) {
mx[p][0] = std::max(mx[p << 1][0], mx[p << 1 | 1][0]),
mx[p][1] = std::max(mx[p << 1][1], mx[p << 1 | 1][1]);
}
void accord(int* v, int p = 1, int l = 1, int r = n) {
if (l == r) {
mx[p][0] = v[l];
return;
}
int mp = (l + r) >> 1;
pushd(p), accord(v, p << 1, l, mp), accord(v, p << 1 | 1, mp + 1, r),
pushu(p);
}
void rev(int l, int r, int p = 1, int pl = 1, int pr = n) {
if (l > pr || pl > r) return;
if (l <= pl && pr <= r) return push(p);
int mp = (pl + pr) >> 1;
pushd(p), rev(l, r, p << 1, pl, mp), rev(l, r, p << 1 | 1, mp + 1, pr),
pushu(p);
}
};
struct __DFN {
Segt T;
int dfn[1111111], dfr[1111111], fa[1111111], dep, len[1111111], rel[1111111];
void init(int p, int f = 0) {
dfn[p] = ++dep, fa[p] = f, rel[dep] = len[p] = len[f] + 1;
for (int t : v[p])
if (t ^ f) init(t, p);
dfr[p] = dep;
}
void reverse(int x, int y) {
if (fa[y] == x) x = y;
T.rev(dfn[x], dfr[x]);
}
void build(int px) {
init(px), T.accord(rel);
register int i;
for (i = 1; i < n; i++)
if (l[i]) reverse(x[i], y[i]);
}
} Rol, Ror;
int dis[1111111];
void dfs(int p = 1, int f = 0) {
dis[p] = dis[f] + 1;
for (int t : v[p])
if (t ^ f) dfs(t, p);
}
void precalc() {
dfs();
register int i;
int mx = -1, mp = 1;
for (i = 1; i <= n; i++)
if (dis[i] > mx) mx = dis[i], mp = i;
dfs(mp), Rol.build(mp);
for (i = 1, mx = -1, mp = 1; i <= n; i++)
if (dis[i] > mx) mx = dis[i], mp = i;
Ror.build(mp);
}
void revall(int x, int y) { Rol.reverse(x, y), Ror.reverse(x, y); }
void exec() {
scanf("%d", &n);
register int i;
for (i = 1; i < n; i++)
scanf("%d%d%d", x + i, y + i, l + i), v[x[i]].push_back(y[i]),
v[y[i]].push_back(x[i]);
precalc();
scanf("%d", &m);
for (i = 1; i <= m; i++)
scanf("%d", o + i), revall(x[o[i]], y[o[i]]),
printf("%d\n", std::max(Rol.T.mx[1][0], Ror.T.mx[1][0]) - 1);
return;
}
int main() {
int T = 1;
for (; T--;) exec();
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const long long INF = 20000000050000;
const long long mod = 1000000007;
const int MAXN = 500005;
std::pair<int, int> pmax(std::pair<int, int> x, std::pair<int, int> y) {
return {max(x.first, y.first), max(x.second, y.second)};
}
struct tree {
int l;
int r;
int mx[2];
bool rev;
tree *lson;
tree *rson;
tree() {
l = r = 0;
mx[0] = -MAXN;
mx[1] = -MAXN;
rev = false;
lson = rson = NULL;
}
void pushdown() {
if (!rev) return;
std::swap(lson->mx[0], lson->mx[1]);
std::swap(rson->mx[0], rson->mx[1]);
lson->rev ^= 1;
rson->rev ^= 1;
rev = false;
}
void fix() {
mx[0] = max(lson->mx[0], rson->mx[0]);
mx[1] = max(lson->mx[1], rson->mx[1]);
}
void reverse(int L, int R) {
if (l >= L && r <= R) {
std::swap(mx[0], mx[1]);
rev ^= 1;
return;
}
pushdown();
int mid = (l + r) / 2;
if (L <= mid) lson->reverse(L, R);
if (R > mid) rson->reverse(L, R);
fix();
}
std::pair<int, int> query(int L, int R) {
if (l >= L && r <= R) return {mx[0], mx[1]};
pushdown();
int mid = (l + r) / 2;
std::pair<int, int> ans = std::make_pair(-MAXN, -MAXN);
if (L <= mid) ans = pmax(ans, lson->query(L, R));
if (R > mid) ans = pmax(ans, rson->query(L, R));
return ans;
}
void build(int L, int R, int *dep, int *ty) {
l = L, r = R;
if (l == r) {
mx[ty[l] & 1] = dep[l];
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, dep, ty);
rson->build(mid + 1, r, dep, ty);
fix();
}
};
int N, u[MAXN], v[MAXN], S1, S2;
std::vector<std::pair<int, int> > e[MAXN];
void addedge(int u, int v, int ty) {
e[u].push_back({v, ty});
e[v].push_back({u, ty});
}
struct STRUCT {
tree T;
int dep[MAXN], cnt[MAXN], D;
int cur, dfn[MAXN], rn[MAXN], rk[MAXN];
void dfs(int v, int f) {
if (!f) dep[v] = cnt[v] = cur = D = 0;
if (dep[D] < dep[v]) D = v;
dfn[v] = ++cur;
rk[cur] = v;
for (int i = 0; i < e[v].size(); i++) {
std::pair<int, int> P = e[v][i];
if (P.first == f) continue;
dep[P.first] = dep[v] + 1;
cnt[P.first] = cnt[v] + P.second;
dfs(P.first, v);
}
rn[v] = cur;
}
void prepare(int S1) {
static int tdep[MAXN], tcnt[MAXN];
dfs(S1, 0);
for (int i = 1; i <= N; i++) {
tdep[i] = dep[rk[i]];
tcnt[i] = cnt[rk[i]];
}
T.build(1, N, tdep, tcnt);
}
void update(int u, int v) {
int id = dep[u] > dep[v] ? u : v;
T.reverse(dfn[id], rn[id]);
}
};
STRUCT T1, T2;
void init() {
int t;
scanf("%d", &N);
for (int i = 1; i < N; i++) {
scanf("%d %d %d", u + i, v + i, &t);
addedge(u[i], v[i], (bool)t);
}
T1.dfs(1, 0);
S1 = T1.D;
T1.dfs(S1, 0);
S2 = T1.D;
T1.prepare(S1);
T2.prepare(S2);
}
void solve() {
int M, t;
scanf("%d", &M);
while (M--) {
scanf("%d", &t);
T1.update(u[t], v[t]);
T2.update(u[t], v[t]);
printf("%d\n", (max(T1.T.mx[0], T2.T.mx[0])));
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T f = 0, x = 0;
char c = getchar();
while (!isdigit(c)) f = c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return f ? -x : x;
}
namespace run {
const int N = 1e6 + 9, Log = 20;
int head[N], nex[N], to[N], cnt = 1, w[N], id[N];
inline void add(int u, int v, int c) {
nex[++cnt] = head[u];
head[u] = cnt, to[cnt] = v, w[cnt] = c;
}
int log[N], dep[N], f[Log][N], dfn[N], dwn[N], num, top, fs[N], sum[N], rak[N];
inline void dfs(int u, int _f) {
f[0][++top] = u, fs[u] = top, dep[u] = dep[_f] + 1, rak[dfn[u] = ++num] = u;
for (int i = head[u]; i; i = nex[i])
if (to[i] ^ _f)
sum[to[i]] = sum[u] ^ w[i], id[i >> 1] = to[i], dfs(to[i], u),
f[0][++top] = u;
dwn[u] = num;
}
inline int _min(int u, int v) { return dep[u] < dep[v] ? u : v; }
inline void pre() {
log[0] = -1;
for (int i = 1; i <= top; i++) log[i] = log[i >> 1] + 1;
for (int i = 1; i < Log; i++)
for (int j = 1; j + (1 << (i - 1)) <= top; j++)
f[i][j] = _min(f[i - 1][j], f[i - 1][j + (1 << (i - 1))]);
}
inline int lca(int u, int v) {
int l = min(fs[u], fs[v]), r = max(fs[u], fs[v]), k = log[r - l + 1];
return _min(f[k][l], f[k][r - (1 << k) + 1]);
}
inline int dist(int u, int v) {
if (!u && !v) return -2 * N;
if (!u || !v) return -N;
return dep[u] + dep[v] - 2 * dep[lca(u, v)];
}
namespace Seg {
struct lend {
int u, v, d;
explicit lend() {}
lend(int _u, int _v) : u(_u), v(_v) { d = dist(u, v); }
};
inline lend merge(lend x, lend y) {
lend ret = x;
int u1 = x.u, v1 = x.v, u2 = y.u, v2 = y.v;
if (lend(u1, u2).d >= ret.d) ret = lend(u1, u2);
if (lend(u1, v2).d >= ret.d) ret = lend(u1, v2);
if (lend(v1, u2).d >= ret.d) ret = lend(v1, u2);
if (lend(v1, v2).d >= ret.d) ret = lend(v1, v2);
if (y.d >= ret.d) ret = y;
return ret;
}
int rev[N << 2];
lend l0[N << 2], l1[N << 2];
inline void pushr(int k) { swap(l0[k], l1[k]), rev[k] ^= 1; }
inline void pushdown(int k) {
if (rev[k]) pushr((k << 1)), pushr((k << 1 | 1)), rev[k] = 0;
}
inline void pushup(int k) {
l0[k] = merge(l0[(k << 1)], l0[(k << 1 | 1)]),
l1[k] = merge(l1[(k << 1)], l1[(k << 1 | 1)]);
}
inline void build(int k, int l, int r) {
if (l == r) {
l0[k] = l1[k] = lend(0, 0);
if (sum[rak[l]])
l1[k] = lend(rak[l], rak[l]);
else
l0[k] = lend(rak[l], rak[l]);
return;
}
build((k << 1), l, ((l + r) >> 1)),
build((k << 1 | 1), ((l + r) >> 1) + 1, r);
pushup(k);
}
inline void modify(int k, int l, int r, int _l, int _r) {
if (_l <= l && r <= _r) return pushr(k);
pushdown(k);
if (_l <= ((l + r) >> 1)) modify((k << 1), l, ((l + r) >> 1), _l, _r);
if (_r > ((l + r) >> 1)) modify((k << 1 | 1), ((l + r) >> 1) + 1, r, _l, _r);
pushup(k);
}
inline void check(int k, int l, int r) {
cout << l << " " << r << ":----------" << endl;
cout << "l0:"
<< " " << l0[k].u << " " << l0[k].v << " ";
cout << "l1:"
<< " " << l1[k].u << " " << l1[k].v << endl;
if (l == r) return;
pushdown(k);
check((k << 1), l, ((l + r) >> 1)),
check((k << 1 | 1), ((l + r) >> 1) + 1, r);
}
} // namespace Seg
int n, m;
int main() {
n = read<int>();
for (int i = 1; i < n; i++) {
int u = read<int>(), v = read<int>(), p = read<int>();
add(u, v, p), add(v, u, p);
}
dfs(1, 0), pre(), Seg::build(1, 1, n);
m = read<int>();
for (int i = 1; i <= m; i++) {
int u = id[read<int>()];
Seg::modify(1, 1, n, dfn[u], dwn[u]);
printf("%d\n", max(Seg::l0[1].d, Seg::l1[1].d));
}
return 0;
}
} // namespace run
int main() { return run::main(); }
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500010;
vector<pair<pair<int, int>, int>> edge;
vector<pair<int, int>> graph[MAXN];
int n, m;
int depth[MAXN], ap, bp;
class SegmentTree {
public:
SegmentTree() { cnt = 0; }
int dfsArr[MAXN];
int l[MAXN], r[MAXN], f[MAXN], cnt;
int te[MAXN * 4], to[MAXN * 4];
int evenLen[MAXN], oddLen[MAXN];
int lazy[MAXN * 4];
void build(int p, int curLen, int val, int pop) {
if (curLen % 2 == 0) {
this->evenLen[p] = val;
this->oddLen[p] = 0;
} else {
this->oddLen[p] = val;
this->evenLen[p] = 0;
}
l[p] = ++cnt;
dfsArr[cnt] = p;
for (auto i : graph[p]) {
if (i.first == pop) continue;
f[i.first] = p;
build(i.first, curLen + i.second, val + 1, p);
}
r[p] = cnt;
}
void init(int l, int r, int cur) {
if (l == r) {
te[cur] = evenLen[dfsArr[l]];
to[cur] = oddLen[dfsArr[l]];
return;
}
int mid = (l + r) / 2;
init(l, mid, cur * 2);
init(mid + 1, r, cur * 2 + 1);
te[cur] = max(te[cur * 2], te[cur * 2 + 1]);
to[cur] = max(to[cur * 2], to[cur * 2 + 1]);
}
void pushdown(int cur, int l, int r) {
if (l != r) {
lazy[cur * 2] += lazy[cur];
lazy[cur * 2 + 1] += lazy[cur];
if (lazy[cur] % 2 == 1) {
swap(te[cur * 2], to[cur * 2]);
swap(te[cur * 2 + 1], to[cur * 2 + 1]);
}
}
lazy[cur] = 0;
}
void change(int l, int r, int tl, int tr, int cur) {
if (l > tr || r < tl) return;
pushdown(cur, l, r);
if (l >= tl && r <= tr) {
lazy[cur]++;
swap(te[cur], to[cur]);
} else {
int mid = (l + r) / 2;
change(l, mid, tl, tr, cur * 2);
change(mid + 1, r, tl, tr, cur * 2 + 1);
te[cur] = max(te[cur * 2], te[cur * 2 + 1]);
to[cur] = max(to[cur * 2], to[cur * 2 + 1]);
}
}
} t1, t2;
void dfs(int x, int f) {
for (auto i : graph[x]) {
if (i.first == f) continue;
depth[i.first] = depth[x] + 1;
dfs(i.first, x);
}
}
void GetDiameter() {
depth[1] = 0;
dfs(1, -1);
int len = -1;
for (int i = 1; i <= n; i++) {
if (depth[i] > len) {
ap = i;
len = depth[i];
}
}
depth[1] = 0;
dfs(ap, -1);
len = -1;
for (int i = 1; i <= n; i++) {
if (depth[i] > len) {
bp = i;
len = depth[i];
}
}
}
void DEBUG(int l, int r, int cur) {
printf("[%d, %d], lazy: %d even: %d odd: %d\n", l, r, t2.lazy[cur],
t2.te[cur], t2.to[cur]);
if (l == r) return;
int mid = (l + r) / 2;
DEBUG(l, mid, cur * 2);
DEBUG(mid + 1, r, cur * 2 + 1);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v, w;
cin >> u >> v >> w;
edge.push_back(make_pair(make_pair(u, v), w));
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
}
GetDiameter();
t1.build(ap, 0, 0, -1);
t2.build(bp, 0, 0, -1);
t1.f[ap] = -1;
t2.f[bp] = -1;
t1.init(1, n, 1);
t2.init(1, n, 1);
cin >> m;
for (int i = 1; i <= m; i++) {
int x;
cin >> x;
int node = t1.f[edge[x - 1].first.first] == edge[x - 1].first.second
? edge[x - 1].first.first
: edge[x - 1].first.second;
t1.change(1, n, t1.l[node], t1.r[node], 1);
node = t2.f[edge[x - 1].first.first] == edge[x - 1].first.second
? edge[x - 1].first.first
: edge[x - 1].first.second;
t2.change(1, n, t2.l[node], t2.r[node], 1);
int ans = max(t1.te[1], t2.te[1]);
cout << ans << endl;
}
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);
}
}
|
#include <bits/stdc++.h>
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;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
gr.assign(n, {});
for (int i = 0; i < n - 1; ++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 ll = long long;
using ld = long double;
using namespace std;
const int T = 1 << 20;
int mx[T + T][2], flag[T + T];
void combine(int v) {
for (int i = 0; i <= 1; ++i) mx[v][i] = max(mx[2 * v][i], mx[2 * v + 1][i]);
}
void change(int v) {
flag[v] ^= 1;
swap(mx[v][0], mx[v][1]);
}
void push(int v) {
if (!flag[v]) return;
for (auto u : {2 * v, 2 * v + 1}) change(u);
flag[v] = 0;
}
void modify(int x, int y, int v = 1, int l = 0, int r = T - 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);
combine(v);
}
const int N = 5e5 + 500;
int n, a, b, c, q, in[N][2], out[N][2], dis[N], parity[N], czas, edge[N][2];
struct gao {
int u, w, id;
};
vector<gao> G[N];
pair<int, int> e;
void dfs(int v, int p) {
dis[v] = dis[p] + 1;
e = max(e, {dis[v], v});
for (auto it : G[v]) {
int u = it.u;
if (u != p) dfs(u, v);
}
}
void dfs2(int v, int p, int type) {
in[v][type] = ++czas;
for (auto it : G[v]) {
int u = it.u;
if (u != p) {
parity[u] = parity[v] ^ it.w;
edge[it.id][type] = u;
dfs2(u, v, type);
}
}
out[v][type] = czas;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d%d", &a, &b, &c);
G[a].push_back({b, c, i});
G[b].push_back({a, c, i});
}
dfs(1, 0);
int end[2];
end[0] = e.second;
e = {0, 0};
dfs(end[0], 0);
end[1] = e.second;
for (int j = 0; j <= 1; ++j) {
for (int i = 1; i <= n; ++i) parity[i] = 0;
dfs(end[j], 0);
dfs2(end[j], 0, j);
for (int i = 1; i <= n; ++i) mx[in[i][j] + T][parity[i] % 2] = dis[i];
}
for (int i = T - 1; 1 <= i; --i) combine(i);
scanf("%d", &q);
while (q--) {
scanf("%d", &a);
for (int i = 0; i <= 1; ++i) modify(in[edge[a][i]][i], out[edge[a][i]][i]);
printf("%d\n", mx[1][0] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, t;
} e[500005];
int n, dep0[500005];
vector<pair<int, int> > g[500005];
inline void getrt(int x, int f) {
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i].first;
if (y == f) continue;
dep0[y] = dep0[x] + 1;
getrt(y, x);
}
}
struct tree {
struct node {
int l, r, mx[2], lz;
} s[500005 << 2];
inline void build(int k, int l, int r) {
s[k].l = l;
s[k].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
inline void update(int k, int x, int v, int y) {
if (s[k].l == s[k].r) {
s[k].mx[v & 1] = y;
return;
}
int mid = (s[k].l + s[k].r) >> 1;
if (x <= mid)
update(k << 1, x, v, y);
else
update(k << 1 | 1, x, v, y);
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]);
}
inline void pushdown(int k) {
if (s[k].lz) {
swap(s[k << 1].mx[0], s[k << 1].mx[1]);
swap(s[k << 1 | 1].mx[0], s[k << 1 | 1].mx[1]);
}
s[k << 1].lz ^= s[k].lz;
s[k << 1 | 1].lz ^= s[k].lz;
s[k].lz = 0;
}
inline void add(int k, int l, int r) {
if (l <= s[k].l && s[k].r <= r) {
swap(s[k].mx[0], s[k].mx[1]);
s[k].lz ^= 1;
return;
}
pushdown(k);
int mid = (s[k].l + s[k].r) >> 1;
if (r <= mid)
add(k << 1, l, r);
else if (l > mid)
add(k << 1 | 1, l, r);
else
add(k << 1, l, mid), add(k << 1 | 1, mid + 1, r);
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]);
}
};
struct qaqwq {
private:
tree st;
int L[500005], R[500005], rid[500005], tim = 0, cnt[500005], dep[500005];
public:
inline void dfs(int x, int f) {
L[x] = ++tim;
rid[tim] = x;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i].first, z = g[x][i].second;
if (y == f) continue;
dep[y] = dep[x] + 1;
cnt[y] = cnt[x] + z;
dfs(y, x);
}
R[x] = tim;
}
inline void init(int rt) {
st.build(1, 1, n);
dfs(rt, 0);
for (int i = 1; i <= n; i++) st.update(1, L[i], cnt[i], dep[i]);
}
inline void perform(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
st.add(1, L[v], R[v]);
}
inline int query() { return st.s[1].mx[0]; }
} p1, p2;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, t;
scanf("%d%d%d", &u, &v, &t);
e[i] = {u, v, t};
g[u].push_back(make_pair(v, t));
g[v].push_back(make_pair(u, t));
}
getrt(1, 0);
int s1 = 1, s2 = 1, mx = 0;
for (int i = 1; i <= n; i++)
if (dep0[i] > mx) mx = dep0[i], s1 = i;
dep0[s1] = 0;
getrt(s1, 0);
mx = 0;
for (int i = 1; i <= n; i++)
if (dep0[i] > mx) mx = dep0[i], s2 = i;
p1.init(s1);
p2.init(s2);
int m;
scanf("%d", &m);
while (m--) {
int x;
scanf("%d", &x);
p1.perform(e[x].u, e[x].v);
p2.perform(e[x].u, e[x].v);
printf("%d\n", max(p1.query(), p2.query()));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500009;
vector<pair<int, int>> V[maxn];
int va[maxn], vb[maxn], fa[maxn], ans[maxn], stone[maxn], q[maxn], istone[maxn],
tot, dfn[maxn], sz[maxn];
int Max1[maxn << 2], Max2[maxn << 2];
bool lz[maxn << 2];
void build(int rt, int l, int r, int p, int v, int d) {
lz[rt] = 0;
if (l == r) {
if (v & 1)
Max2[rt] = d, Max1[rt] = 0;
else
Max1[rt] = d, Max2[rt] = 0;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
build(rt << 1, l, mid, p, v, d);
else
build(rt << 1 | 1, mid + 1, r, p, v, d);
Max1[rt] = max(Max1[rt << 1], Max1[rt << 1 | 1]);
Max2[rt] = max(Max2[rt << 1], Max2[rt << 1 | 1]);
}
void upd(int rt, int l, int r, int ll, int rr) {
if (ll <= l && rr >= r) {
lz[rt] ^= 1;
swap(Max1[rt], Max2[rt]);
return;
}
int mid = (l + r) >> 1;
if (lz[rt]) {
lz[rt << 1] ^= 1;
lz[rt << 1 | 1] ^= 1;
swap(Max1[rt << 1], Max2[rt << 1]);
swap(Max1[rt << 1 | 1], Max2[rt << 1 | 1]);
lz[rt] = 0;
}
if (ll <= mid) upd(rt << 1, l, mid, ll, rr);
if (rr > mid) upd(rt << 1 | 1, mid + 1, r, ll, rr);
Max1[rt] = max(Max1[rt << 1], Max1[rt << 1 | 1]);
Max2[rt] = max(Max2[rt << 1], Max2[rt << 1 | 1]);
}
int len, st;
int n;
void dfs(int u, int f, int d = 0) {
if (d >= len) len = d, st = u;
for (auto [v, idx] : V[u])
if (v != f) dfs(v, u, d + 1);
}
void gao(int u, int f, int val = 0, int d = 0) {
sz[u] = 1;
dfn[u] = ++tot;
build(1, 1, n, tot, val, d);
for (auto [v, idx] : V[u])
if (v != f) {
if (va[idx] == v)
fa[idx] = 1;
else
fa[idx] = 0;
gao(v, u, val + stone[idx], d + 1);
sz[u] += sz[v];
}
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> va[i] >> vb[i] >> stone[i];
V[va[i]].emplace_back(vb[i], i);
V[vb[i]].emplace_back(va[i], i);
}
int aq;
cin >> aq;
for (int i = 0; i < aq; ++i) cin >> q[i], q[i]--;
dfs(1, 1);
int S = st, T;
len = 0;
dfs(S, S);
T = st;
for (int x : {S, T}) {
tot = 0;
gao(x, x);
for (int i = 0; i < aq; ++i) {
int op;
if (fa[q[i]] == 0) {
op = vb[q[i]];
} else {
op = va[q[i]];
}
upd(1, 1, n, dfn[op], dfn[op] + sz[op] - 1);
ans[i] = max(ans[i], Max1[1]);
}
}
for (int i = 0; i < aq; ++i) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 10000000;
pair<int, int> get_diameter(vector<vector<int>> &E) {
int N = E.size();
queue<int> Q;
Q.push(0);
vector<bool> used(N, false);
used[0] = true;
int s;
while (!Q.empty()) {
s = Q.front();
Q.pop();
for (int w : E[s]) {
if (!used[w]) {
used[w] = true;
Q.push(w);
}
}
}
Q.push(s);
vector<bool> used2(N, false);
used2[s] = true;
int t;
while (!Q.empty()) {
t = Q.front();
Q.pop();
for (int w : E[t]) {
if (!used2[w]) {
used2[w] = true;
Q.push(w);
}
}
}
return make_pair(s, t);
}
struct lazy_segment_tree {
int N;
vector<int> ST1, ST2;
vector<bool> lazy;
lazy_segment_tree() {}
lazy_segment_tree(vector<int> &a) {
int n = a.size();
N = 1;
while (N < n) {
N *= 2;
}
ST1 = vector<int>(N * 2 - 1, 0);
for (int i = 0; i < n; i++) {
ST1[N - 1 + i] = a[i];
}
for (int i = N - 2; i >= 0; i--) {
ST1[i] = max(ST1[i * 2 + 1], ST1[i * 2 + 2]);
}
ST2 = vector<int>(N * 2 - 1, 0);
lazy = vector<bool>(N * 2 - 1, false);
}
void eval(int i) {
if (lazy[i]) {
if (i < N - 1) {
lazy[i * 2 + 1] = !lazy[i * 2 + 1];
lazy[i * 2 + 2] = !lazy[i * 2 + 2];
}
swap(ST1[i], ST2[i]);
lazy[i] = false;
}
}
void flip(int L, int R, int i, int l, int r) {
eval(i);
if (r <= L || R <= l) {
return;
} else if (L <= l && r <= R) {
lazy[i] = !lazy[i];
eval(i);
} else {
int m = (l + r) / 2;
flip(L, R, i * 2 + 1, l, m);
flip(L, R, i * 2 + 2, m, r);
ST1[i] = max(ST1[i * 2 + 1], ST1[i * 2 + 2]);
ST2[i] = max(ST2[i * 2 + 1], ST2[i * 2 + 2]);
}
}
void flip(int L, int R) { flip(L, R, 0, 0, N); }
int all() {
eval(0);
return ST1[0];
}
};
struct euler_tour {
vector<int> in, out, a;
lazy_segment_tree ST;
void dfs(vector<vector<int>> &E, int v, int dist) {
in[v] = a.size();
a.push_back(dist);
for (int w : E[v]) {
if (in[w] == -1) {
dfs(E, w, dist + 1);
}
}
out[v] = a.size();
}
euler_tour(vector<vector<int>> &E, int r) {
int N = E.size();
in = vector<int>(N, -1);
out = vector<int>(N, -1);
dfs(E, r, 0);
ST = lazy_segment_tree(a);
}
int dist(int v) { return a[in[v]]; }
void flip(int v) { ST.flip(in[v], out[v]); }
int query() { return ST.all(); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> u(n - 1), v(n - 1), t(n - 1);
for (int i = 0; i < n - 1; i++) {
cin >> u[i] >> v[i] >> t[i];
u[i]--;
v[i]--;
}
vector<vector<int>> E(n);
for (int i = 0; i < n - 1; i++) {
E[u[i]].push_back(v[i]);
E[v[i]].push_back(u[i]);
}
int r1, r2;
tie(r1, r2) = get_diameter(E);
euler_tour T1(E, r1);
euler_tour T2(E, r2);
vector<int> c1(n - 1);
vector<int> c2(n - 1);
for (int i = 0; i < n - 1; i++) {
if (T1.dist(u[i]) > T1.dist(v[i])) {
c1[i] = u[i];
} else {
c1[i] = v[i];
}
if (T2.dist(u[i]) > T2.dist(v[i])) {
c2[i] = u[i];
} else {
c2[i] = v[i];
}
}
for (int i = 0; i < n - 1; i++) {
if (t[i] == 1) {
T1.flip(c1[i]);
T2.flip(c2[i]);
}
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int id;
cin >> id;
id--;
T1.flip(c1[id]);
T2.flip(c2[id]);
cout << max(T1.query(), T2.query()) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
class segtree {
public:
struct node {
int black = INT_MIN;
int white = INT_MIN;
bool exchange = false;
void apply(int l, int r, int v) {
if (v >= 0) {
int t = v & 1;
v >>= 1;
(t ? black : white) = v;
} else {
swap(black, white);
exchange ^= true;
}
}
};
node unite(const node &a, const node &b) const {
node res;
res.black = max(a.black, b.black);
res.white = max(a.white, b.white);
return res;
}
inline void push(int x, int l, int r) {
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
if (tree[x].exchange) {
tree[x + 1].apply(l, y, -1);
tree[z].apply(y + 1, r, -1);
tree[x].exchange = false;
}
}
inline void pull(int x, int z) { tree[x] = unite(tree[x + 1], tree[z]); }
int n;
vector<node> tree;
void build(int x, int l, int r) {
if (l == r) {
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y);
build(z, y + 1, r);
pull(x, z);
}
template <typename M, typename... T>
void build(int x, int l, int r, const vector<M> &v, const T &...t) {
if (l == r) {
tree[x].apply(l, r, v[l], t...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
build(x + 1, l, y, v, t...);
build(z, y + 1, r, v, t...);
pull(x, z);
}
template <typename M, typename... T>
segtree(const vector<M> &v, const T &...t) {
n = v.size();
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1, v, t...);
}
segtree(int _n) : n(_n) {
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1);
}
segtree(){};
node get(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
return tree[x];
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
node res{};
if (rr <= y) {
res = get(x + 1, l, y, ll, rr);
} else {
if (ll > y) {
res = get(z, y + 1, r, ll, rr);
} else {
res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
}
}
pull(x, z);
return res;
}
node get(int ll, int rr) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return get(0, 0, n - 1, ll, rr);
}
node get(int p) {
assert(0 <= p && p <= n - 1);
return get(0, 0, n - 1, p, p);
}
template <typename... M>
void modify(int x, int l, int r, int ll, int rr, const M &...v) {
if (ll <= l && r <= rr) {
tree[x].apply(l, r, v...);
return;
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
if (ll <= y) {
modify(x + 1, l, y, ll, rr, v...);
}
if (rr > y) {
modify(z, y + 1, r, ll, rr, v...);
}
pull(x, z);
}
template <typename... M>
void modify(int ll, int rr, const M &...v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify(0, 0, n - 1, ll, rr, v...);
}
};
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<vector<int>> g(n);
vector<int> from(n - 1);
vector<int> to(n - 1);
vector<int> d(n - 1);
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--;
v--;
g[u].push_back(i);
g[v].push_back(i);
from[i] = u;
to[i] = v;
d[i] = t;
}
vector<int> dep(n);
function<void(int, int)> dfs0 = [&](int v, int p) {
if (~p)
dep[v] = dep[p] + 1;
else
dep[v] = 0;
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs0(id, v);
}
};
dfs0(0, -1);
int left_root = max_element(dep.begin(), dep.end()) - dep.begin();
dfs0(left_root, -1);
int right_root = max_element(dep.begin(), dep.end()) - dep.begin();
vector<int> order;
vector<int> din(n);
vector<int> dout(n);
vector<int> par(n);
function<void(int, int)> dfs = [&](int v, int p) {
par[v] = p;
if (~p)
dep[v] = dep[p] + 1;
else
dep[v] = 0;
din[v] = order.size();
order.push_back(v);
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs(id, v);
}
dout[v] = order.size() - 1;
};
vector<int> R_order, R_in, R_out, R_dep, R_par, L_order, L_in, L_out, L_dep,
L_par;
dfs(right_root, -1);
R_order = order;
R_in = din;
R_out = dout;
R_dep = dep;
R_par = par;
order.clear();
dfs(left_root, -1);
L_order = order;
L_in = din;
L_out = dout;
L_dep = dep;
L_par = par;
vector<int> pos(n);
function<void(int, int, int)> dfs1 = [&](int v, int p, int t) {
pos[v] = t;
for (int i : g[v]) {
int id = from[i] ^ to[i] ^ v;
if (id == p) continue;
dfs1(id, v, t ^ d[i]);
}
};
dfs1(0, -1, 0);
for (int i = 0; i < n; i++) {
L_dep[i] = L_dep[i] * 2 + pos[i];
R_dep[i] = R_dep[i] * 2 + pos[i];
}
for (int i = 0; i < n; i++) {
L_order[i] = L_dep[L_order[i]];
R_order[i] = R_dep[R_order[i]];
}
segtree Lst(L_order);
segtree Rst(R_order);
int q;
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int u = from[id];
int v = to[id];
int ret = 0;
{
if (L_par[v] == u) swap(u, v);
Lst.modify(L_in[u], L_out[u], -1);
segtree::node x = Lst.get(L_in[left_root], L_out[left_root]);
segtree::node y = Lst.get(L_in[left_root], L_in[left_root]);
int v = (y.black > INT_MIN ? x.black : x.white);
ret = max(ret, v);
}
{
if (R_par[v] == u) swap(u, v);
Rst.modify(R_in[u], R_out[u], -1);
segtree::node x = Rst.get(R_in[right_root], R_out[right_root]);
segtree::node y = Rst.get(R_in[right_root], R_in[right_root]);
int v = (y.black > INT_MIN ? x.black : x.white);
ret = max(ret, v);
}
cout << ret << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int n, m;
struct edge {
int to, nxt, w;
} e[1000005 << 1];
int tot = 1, head[1000005];
inline void adde(int u, int v, int w) {
e[++tot] = (edge){v, head[u], w};
head[u] = tot;
}
int rt, dis[1000005];
void dfs(int u, int pa) {
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == pa) continue;
dis[v] = dis[u] + 1, dfs(v, u);
}
}
int find(int xx = 1) {
dfs(xx, 0);
int u = 1;
for (register int i = (1); i <= (n); ++i)
if (dis[i] > dis[u]) u = i;
return dis[u] = 0, dfs(u, 0), u;
}
int dfn[1000005], ed[1000005], que[1000005], w[1000005], idx;
void getdfn(int u, int pa) {
dfn[u] = ++idx;
que[idx] = u;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == pa) continue;
w[v] = w[u] ^ e[i].w, getdfn(v, u);
}
ed[u] = idx;
}
int cnt, val[1000005 << 4], ls[1000005 << 4], rs[1000005 << 4], rt0, rt1;
inline void pushup(int p) { val[p] = max(val[ls[p]], val[rs[p]]); }
void build(int& p, int l, int r, bool fg) {
p = ++cnt;
if (l == r) {
if (fg == w[que[l]]) val[p] = dis[que[l]];
return;
}
int mid = l + r >> 1;
build(ls[p], l, mid, fg), build(rs[p], mid + 1, r, fg);
pushup(p);
}
bool in(int l, int r, int ll, int rr) { return ll >= l && rr <= r; }
void mdf(int u, int v, int l, int r, int nl, int nr) {
int mid = l + r >> 1;
if (nl <= mid) {
if (in(nl, nr, l, mid))
swap(ls[u], ls[v]);
else
mdf(ls[u], ls[v], l, mid, nl, nr);
}
if (nr > mid) {
if (in(nl, nr, mid + 1, r))
swap(rs[u], rs[v]);
else
mdf(rs[u], rs[v], mid + 1, r, nl, nr);
}
pushup(u), pushup(v);
}
void out(int p, int l, int r) {
if (l == r) {
cout << val[p] << ' ';
return;
}
int mid = l + r >> 1;
out(ls[p], l, mid), out(rs[p], mid + 1, r);
}
int res[1000005];
int idid[1000005];
void work(int rt) {
w[rt] = 0;
getdfn(rt, 0);
for (register int i = (1); i <= (cnt); ++i) ls[i] = rs[i] = val[i] = 0;
cnt = 0;
build(rt0, 1, n, 0), build(rt1, 1, n, 1);
for (register int _ = (1); _ <= (m); ++_) {
int id = idid[_];
int u = e[id << 1].to, v = e[id << 1 | 1].to;
if (dfn[u] < dfn[v]) swap(u, v);
mdf(rt0, rt1, 1, n, dfn[u], ed[u]);
res[_] = max(res[_], val[rt0]);
}
}
signed main() {
n = read();
for (register int i = (2); i <= (n); ++i) {
int u = read(), v = read(), w = read();
adde(u, v, w), adde(v, u, w);
}
m = read();
for (register int i = (1); i <= (m); ++i) idid[i] = read();
rt = find();
work(rt);
rt = find(rt);
idx = 0, w[rt] = 0;
work(rt);
for (register int i = (1); i <= (m); ++i) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5e5;
int n, m, root, tim, edge;
int U[MAXN | 1], V[MAXN | 1], W[MAXN | 1], dfn[MAXN | 1], size[MAXN | 1],
xorv[MAXN | 1], ID[MAXN | 1], depth[MAXN | 1], fst[MAXN | 1], ans[MAXN | 1];
std::vector<int> que;
struct Edge {
int to, w, nxt;
Edge(int _to = 0, int _w = 0, int _nxt = 0) : to(_to), w(_w), nxt(_nxt) {}
} e[MAXN << 1];
inline int read() {
register int x = 0, v = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') v = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * v;
}
inline void add_edge(int a, int b, int c) {
e[++edge] = Edge(b, c, fst[a]);
fst[a] = edge;
}
int BFS(int x) {
int ans = 1;
bool vis[MAXN | 1];
std::queue<int> q;
memset(vis, 0, sizeof(vis));
q.push(x);
vis[x] = 1;
do {
int from = q.front();
q.pop();
ans = from;
for (int k = fst[from]; k; k = e[k].nxt) {
int to = e[k].to;
if (vis[to]) continue;
vis[to] = 1;
q.push(to);
}
} while (!q.empty());
return ans;
}
void dfs(int x, int fa) {
ID[dfn[x] = ++tim] = x;
size[x] = 1;
depth[x] = depth[fa] + 1;
for (int k = fst[x]; k; k = e[k].nxt) {
int to = e[k].to, w = e[k].w;
if (to == fa) continue;
xorv[to] = xorv[x] ^ w;
dfs(to, x);
size[x] += size[to];
}
}
namespace SegmentTree {
int max0[MAXN << 2 | 1], max1[MAXN << 2 | 1], tag[MAXN << 2 | 1];
void push_up(int o) {
max0[o] = std::max(max0[o << 1], max0[o << 1 | 1]);
max1[o] = std::max(max1[o << 1], max1[o << 1 | 1]);
}
void push_down(int o) {
if (!tag[o]) return;
std::swap(max0[o << 1], max1[o << 1]);
std::swap(max0[o << 1 | 1], max1[o << 1 | 1]);
tag[o << 1] ^= 1;
tag[o << 1 | 1] ^= 1;
tag[o] = 0;
}
void build(int o, int l, int r) {
tag[o] = 0;
max0[o] = max1[o] = 0;
if (l == r) {
if (xorv[ID[l]])
max1[o] = depth[ID[l]];
else
max0[o] = depth[ID[l]];
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
push_up(o);
}
void flip(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
std::swap(max0[o], max1[o]);
tag[o] ^= 1;
return;
}
int mid = (l + r) >> 1;
push_down(o);
if (ql <= mid) flip(o << 1, l, mid, ql, qr);
if (mid < qr) flip(o << 1 | 1, mid + 1, r, ql, qr);
push_up(o);
}
int query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return max1[o];
int mid = (l + r) >> 1, res = 0;
push_down(o);
if (ql <= mid) res = query(o << 1, l, mid, ql, qr);
if (mid < qr) res = std::max(res, query(o << 1 | 1, mid + 1, r, ql, qr));
return res;
}
} // namespace SegmentTree
using namespace SegmentTree;
int main() {
n = read();
for (int i = 1; i < n; ++i) {
U[i] = read();
V[i] = read();
W[i] = read();
add_edge(U[i], V[i], W[i]);
add_edge(V[i], U[i], W[i]);
}
root = BFS(1);
int lst = root;
dfs(root, 0);
build(1, 1, n);
m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), u = U[x], v = V[x];
que.push_back(x);
if (depth[u] < depth[v]) std::swap(u, v);
flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
ans[i] = max0[1] - 1;
}
root = BFS(root);
xorv[root] = 0;
tim = 0;
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= m; ++i) {
int x = que[i - 1], u = U[x], v = V[x];
if (depth[u] < depth[v]) std::swap(u, v);
flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
ans[i] = std::max(max0[1] - 1, ans[i]);
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, next, w;
} e[1011000];
int tot, h[500100], n, rt1, rt2, dep[501000], U[501000], V[500100], W[500100];
inline void DFS(int now, int ffa) {
dep[now] = dep[ffa] + 1;
for (register int i = h[now]; i; i = e[i].next) {
int to = e[i].to;
if (to == ffa) continue;
DFS(to, now);
}
}
inline void add(int from, int to, int w) {
e[++tot].next = h[from];
h[from] = tot;
e[tot].to = to;
e[tot].w = w;
}
struct Segment_Tree {
int tag[2001000], Max[2001000][2];
inline void Update(int now) {
Max[now][0] = max(Max[now << 1][0], Max[now << 1 | 1][0]);
Max[now][1] = max(Max[now << 1][1], Max[now << 1 | 1][1]);
}
inline void Pushdown(int now) {
if (tag[now]) {
swap(Max[now << 1][0], Max[now << 1][1]);
swap(Max[now << 1 | 1][0], Max[now << 1 | 1][1]);
tag[now << 1] ^= 1;
tag[now << 1 | 1] ^= 1;
tag[now] = 0;
}
}
inline void Modify(int now, int l, int r, int x, int y) {
if (x <= l && r <= y) {
swap(Max[now][0], Max[now][1]);
tag[now] ^= 1;
return;
}
int mid = (l + r) >> 1;
Pushdown(now);
if (x <= mid) Modify(now << 1, l, mid, x, y);
if (y > mid) Modify(now << 1 | 1, mid + 1, r, x, y);
Update(now);
}
};
struct Tree {
int rt, depp[500100], fa[501000], Seq[501000], cnt, in[500100], out[501000];
Segment_Tree T;
inline void Build(int now, int l, int r) {
if (l == r) {
T.Max[now][0] = depp[Seq[l]], T.Max[now][1] = T.tag[now] = 0;
return;
}
int mid = (l + r) >> 1;
Build(now << 1, l, mid);
Build(now << 1 | 1, mid + 1, r);
T.Update(now);
}
inline void Pre_DFS(int now, int ffa) {
fa[now] = ffa;
Seq[++cnt] = now;
in[now] = cnt;
for (register int i = h[now]; i; i = e[i].next) {
int to = e[i].to;
if (to == ffa) continue;
depp[to] = depp[now] + 1;
Pre_DFS(to, now);
}
out[now] = cnt;
}
inline void Buildd() {
cnt = 0;
Pre_DFS(rt, 0);
Build(1, 1, n);
for (register int i = 1; i < n; ++i) {
if (depp[U[i]] > depp[V[i]]) swap(U[i], V[i]);
if (W[i]) T.Modify(1, 1, n, in[V[i]], out[V[i]]);
}
}
} T1, T2;
int main() {
scanf("%d", &n);
for (register int i = 1; i < n; ++i) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w);
add(v, u, w);
U[i] = u;
V[i] = v;
W[i] = w;
}
DFS(1, 0);
int Max = 0;
for (register int i = 1; i <= n; ++i)
if (dep[i] > Max) Max = dep[i], rt1 = i;
DFS(rt1, 0);
Max = 0;
for (register int i = 1; i <= n; ++i)
if (dep[i] > Max) Max = dep[i], rt2 = i;
T1.rt = rt1, T2.rt = rt2;
T1.Buildd();
T2.Buildd();
int m;
scanf("%d", &m);
for (register int i = 1; i <= m; ++i) {
int idx;
scanf("%d", &idx);
if (T1.depp[U[idx]] > T1.depp[V[idx]]) swap(U[idx], V[idx]);
T1.T.Modify(1, 1, n, T1.in[V[idx]], T1.out[V[idx]]);
if (T2.depp[U[idx]] > T2.depp[V[idx]]) swap(U[idx], V[idx]);
T2.T.Modify(1, 1, n, T2.in[V[idx]], T2.out[V[idx]]);
cout << max(T1.T.Max[1][0], T2.T.Max[1][0]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int read() {
int x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
const int N = 1000005;
const int inf = 1e8;
struct Edge {
int to, nxt, val;
} edge[N << 1];
int head[N], tot;
void add(int u, int v, int w) { edge[++tot] = {v, head[u], w}, head[u] = tot; }
int dfn[N << 1], pos[N], idx;
int dep[N], wdep[N], tin[N], tout[N];
void dfs(int u, int fa) {
dfn[++idx] = u, tin[u] = idx;
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
if (v == fa) continue;
pos[(i + 1) >> 1] = v;
dep[v] = dep[u] + 1;
wdep[v] = wdep[u] + edge[i].val;
dfs(v, u);
dfn[++idx] = u;
}
tout[u] = idx;
}
int n;
int W[N << 2][2], M[N << 2], LM[N << 2][2], MR[N << 2][2], LMR[N << 2][2];
int lzy[N << 2];
void pushup(int u) {
M[u] = max(M[(u << 1)], M[(u << 1 | 1)]);
for (int k = 0; k < 2; k++) {
W[u][k] = max(W[(u << 1)][k], W[(u << 1 | 1)][k]);
LM[u][k] = max(LM[(u << 1)][k], LM[(u << 1 | 1)][k]);
MR[u][k] = max(MR[(u << 1)][k], MR[(u << 1 | 1)][k]);
LMR[u][k] = max(LMR[(u << 1)][k], LMR[(u << 1 | 1)][k]);
LM[u][k] = max(LM[u][k], W[(u << 1)][k] + M[(u << 1 | 1)]);
MR[u][k] = max(MR[u][k], M[(u << 1)] + W[(u << 1 | 1)][k]);
}
for (int k1 = 0; k1 < 2; k1++) {
for (int k2 = 0; k2 < 2; k2++) {
ckmax(LMR[u][k1 ^ k2], max(LM[(u << 1)][k1] + W[(u << 1 | 1)][k2],
W[(u << 1)][k1] + MR[(u << 1 | 1)][k2]));
}
}
}
void build(int u, int l, int r) {
if (l == r) {
int k = wdep[dfn[l]];
if (k % 2 == 0)
k = 0;
else
k = 1;
W[u][k] = dep[dfn[l]], M[u] = -2 * dep[dfn[l]];
LM[u][k] = MR[u][k] = -dep[dfn[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);
pushup(u);
}
void rot(int u) {
swap(W[u][0], W[u][1]);
swap(LM[u][0], LM[u][1]);
swap(MR[u][0], MR[u][1]);
lzy[u] ^= 1;
}
void pushdown(int u) {
if (lzy[u]) {
rot((u << 1)), rot((u << 1 | 1));
lzy[u] = 0;
}
}
void update(int u, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
rot(u);
return;
}
int mid = l + r >> 1;
pushdown(u);
if (ql <= mid) update((u << 1), l, mid, ql, qr);
if (qr > mid) update((u << 1 | 1), mid + 1, r, ql, qr);
pushup(u);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
add(u, v, w), add(v, u, w);
}
dfs(1, 0);
build(1, 1, idx);
int q = read();
while (q--) {
int d = read();
update(1, 1, idx, tin[pos[d]], tout[pos[d]]);
printf("%d\n", LMR[1][0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, d[2], l, comp;
int kr[1000010];
int wg[1000010];
int nr[2][500001];
int mx[2][500001];
int gle[2][500001];
int st[2][1048576][3];
vector<int> v[500001];
void push(int x, int y) {
if (st[y][x][2]) {
int l = x << 1;
int r = l + 1;
swap(st[y][l][0], st[y][l][1]);
swap(st[y][r][0], st[y][r][1]);
st[y][l][2] ^= 1;
st[y][r][2] ^= 1;
st[y][x][2] = 0;
}
}
void update(int x, int y) {
st[y][x][0] = max(st[y][x * 2][0], st[y][x * 2 + 1][0]);
st[y][x][1] = max(st[y][x * 2][1], st[y][x * 2 + 1][1]);
}
void ins(int y, int x, int l, int r, int ll, int rr) {
if (l > rr || r < ll) {
return;
}
if (ll <= l && r <= rr) {
swap(st[y][x][0], st[y][x][1]);
st[y][x][2] ^= 1;
return;
}
push(x, y);
ins(y, x * 2, l, (l + r) / 2, ll, rr);
ins(y, x * 2 + 1, (l + r) / 2 + 1, r, ll, rr);
update(x, y);
}
void dia(int x, int dl, int pop) {
if (b < dl) {
a = x;
b = dl;
}
for (int i : v[x]) {
if (kr[i] != pop) {
dia(kr[i], dl + 1, x);
}
}
}
void dfs_gle(int x, int y, int par, int pop) {
++l;
nr[y][x] = l;
st[y][l + comp - 1][par] = gle[y][x];
st[y][l + comp - 1][par ^ 1] = -1e9;
for (int i : v[x]) {
if (kr[i] != pop) {
gle[y][kr[i]] = gle[y][x] + 1;
dfs_gle(kr[i], y, par ^ wg[i], x);
}
}
mx[y][x] = l;
}
int main() {
scanf("%d", &n);
comp = 1;
while (comp < n) {
comp <<= 1;
}
for (int i = 1; i < n; ++i) {
scanf("%d%d%d", &a, &b, &wg[i * 2]);
kr[i * 2] = a;
kr[i * 2 + 1] = b;
wg[i * 2 + 1] = wg[i * 2];
v[a].push_back(i * 2 + 1);
v[b].push_back(i * 2);
}
b = -1;
dia(1, 0, 0);
d[0] = a;
b = -1;
dia(a, 0, 0);
d[1] = a;
l = 0;
dfs_gle(d[0], 0, 0, 0);
l = 0;
dfs_gle(d[1], 1, 0, 0);
for (int i = comp - 1; i; --i) {
update(i, 0);
update(i, 1);
}
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
int ret = 0;
a = kr[x * 2];
b = kr[x * 2 + 1];
if (gle[0][a] > gle[0][b]) {
swap(a, b);
}
ins(0, 1, 1, comp, nr[0][b], mx[0][b]);
ret = max(ret, st[0][1][0]);
if (gle[1][a] > gle[1][b]) {
swap(a, b);
}
ins(1, 1, 1, comp, nr[1][b], mx[1][b]);
ret = max(ret, st[1][1][0]);
printf("%d\n", ret);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.