text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long SZ = 1e5 + 7;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
void __print(int x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << x; }
void __print(const char *x) { cerr << x; }
void __print(const string &x) { cerr << x; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ", ";
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) {
cerr << (f++ ? ", " : "");
__print(i);
}
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) {
cerr << ", ";
}
_print(v...);
}
long long tc_cnt = 1;
long long int powermod(long long int a, long long int b) {
long long int ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
b = b / 2;
a = (a * a) % mod;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
void krdiyasuru() {
long long n;
cin >> n;
long long int f = 1;
for (long long i = 1; i < (n + 1); i++) {
f = ((f % mod) * (i % mod)) % mod;
};
long long int ans = f - powermod(2, n - 1);
cout << (ans < mod ? (ans + mod) % mod : ans) % mod << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr << endl;
{ krdiyasuru(); }
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long fac[1000001];
long long dp[1000001];
int main() {
fac[0] = 1;
for (int i = 1; i <= 1000000; i++) {
fac[i] = (i * fac[i - 1]) % MOD;
}
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 2;
for (int i = 4; i <= 1000000; i++) {
dp[i] = (fac[i - 1] * (i - 2)) % MOD;
dp[i] = (dp[i] + 2 * dp[i - 1]) % MOD;
}
int n;
cin >> n;
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void solve();
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
long long f[1000010];
long long get(long long x, long long k) {
if (k == 0) return 1;
if (k % 2 == 0) {
long long ans = get(x, k / 2);
return (ans * ans) % mod;
} else {
return (x * get(x, k - 1)) % mod;
}
}
void solve() {
long long n;
cin >> n;
f[0] = 1;
for (long long i = 1; i <= n; i++) {
f[i] = (f[i - 1] * i) % mod;
}
long long ans = 0;
for (long long i = 0; i <= n; i++) {
ans = (ans + f[n] * get((f[i] * f[n - i]) % mod, mod - 2)) % mod;
}
cout << (mod * 2 + f[n] - (ans * get(2, mod - 2)) % mod) % mod << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void Input_Preparing() {}
void Solver() {
long long int n;
cin >> n;
long long int res, fact;
fact = 1;
res = 1;
for (long long int i = 1; i <= n - 1; i++) {
res *= 2;
fact *= i;
fact %= 1000000007;
res %= 1000000007;
}
fact *= n;
fact %= 1000000007;
fact -= res;
fact %= 1000000007;
if (fact < 0) fact += 1000000007;
cout << fact;
}
void Processing() { Solver(); }
int main() {
std::cin.tie(0)->sync_with_stdio(0);
;
Processing();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
long long binpow(long long, long long);
long long mult(long long, long long);
long long add(long long, long long);
long long division(long long, long long);
long long nCr(long long, long long);
long long inv(long long);
void calc();
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
const int N = 1000005;
long long fact[N];
void solve() {
long long n;
cin >> n;
long long ans = 0;
for (long long r = 0; r < n; r++) {
ans = add(ans, mult(nCr(n - 1, r), mult(fact[r], fact[n - 1 - r]) - 1));
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
calc();
for (long long i = 0; i < t; i++) {
solve();
cout << "\n";
}
return 0;
}
long long add(long long a, long long b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
while (a < 0) a += 1000000007;
return a;
}
long long mult(long long a, long long b) { return (a * 1ll * b) % 1000000007; }
long long binpow(long long a, long long b) {
long long c = 1;
while (b > 0) {
if (b % 2 == 1) c = mult(c, a);
a = mult(a, a);
b /= 2;
}
return c;
}
long long inv(long long a) { return binpow(a, 1000000007 - 2); }
long long division(long long a, long long b) { return mult(a, inv(b)); }
long long nCr(long long n, long long r) {
if (r > n) return 0;
return division(fact[n], mult(fact[n - r], fact[r]));
}
void calc() {
fact[0] = 1;
for (long long i = 1; i <= N - 1; i++)
fact[i] = (i * 1ll * fact[i - 1]) % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9 + 7;
long long n, jem = 1, res = 1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= (n); i++) jem = jem * 1ll * i % N;
for (long long i = 1; i <= (n - 1); i++) res = res * 2ll % N;
cout << (jem - res + N) % N;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fact(long long int n) {
long long ans = 1;
for (long long int i = 2; i <= n; i++)
ans = ((ans % 1000000007) * (i % 1000000007)) % 1000000007;
return ans;
}
long long pow(long long int a, long long int b) {
long long int ans = 1;
for (long long int i = 1; i <= b; i++) {
ans = ((ans % 1000000007) * (a % 1000000007)) % 1000000007;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
if (n <= 2) {
cout << n << endl;
}
long long fac = fact(n);
long long ans =
(fac - (pow(2ll, n - 1) % 1000000007) + 1000000007) % 1000000007;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long mod = 1000000007;
long long fact = 1, putere = 2;
for (int c = 2; c <= n; c++) {
fact *= c;
fact %= mod;
if (c < n) putere *= 2;
putere %= mod;
}
cout << (fact - putere + mod) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
int main() {
int n;
cin >> n;
int64_t ans = 1, q = 1;
for (int i = 2; i <= n; ++i) {
ans = (ans * i) % Mod;
q = (q * 2) % Mod;
}
if (ans < q) ans += Mod;
cout << ans - q << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod_power(long long int x, long long int y,
long long int p = 1000000007) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
long long int modInverse(long long int a) {
return mod_power(a, 1000000007 - 2, 1000000007);
}
long long int fact[1000005];
int main() {
long long int n;
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
long long int tmp = mod_power(2, n - 1);
long long int n1 = (fact[n] - tmp + 1000000007) % 1000000007;
cout << n1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ingraph(vector<long long> graph[], long long m) {
long long x, y;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long modmulti(long long a, long long b) {
return ((a % 1000000007) * 1ll * (b % 1000000007)) % 1000000007;
}
long long modadd(long long a, long long b) {
long long asdfgh =
((a % 1000000007) + (b % 1000000007) + 1000000007 + 1000000007) %
1000000007;
asdfgh = (asdfgh + 1000000007) % 1000000007;
return asdfgh;
}
long long modpower(long long a, long long n) {
if (n == 0) return 1;
if (n == 1) return a % 1000000007;
long long b = modpower(a, n / 2);
b = modmulti(b, b);
if (n % 2 == 0) return b;
return modmulti(a, b);
}
long long modinv(long long a) { return modpower(a, 1000000007 - 2); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n;
cin >> n;
long long fact[n + 5];
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; i++) {
fact[i] = modmulti(fact[i - 1], i);
}
long long ans = modpower(2, n - 1);
ans *= (-1);
ans = modadd(fact[n], ans);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
void solve() {
int n;
scanf("%d", &n);
int ans = 1, res = 1;
for (int i = (1); i <= (n); ++i) ans = (ans * 1ll * i) % mod;
for (int i = (1); i <= (n - 1); ++i) res = (res * 2) % mod;
printf("%d", (ans + mod - res) % mod);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
long long res;
long long sub;
long long prime = 1000000007;
res = 1;
for (int c1 = 1; c1 <= n; c1++) {
res = (res * c1) % prime;
}
sub = 1;
for (int c1 = 0; c1 < n - 1; c1++) {
sub = (sub * 2) % prime;
}
sub = (prime - sub) % prime;
res = (res + sub) % prime;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
long long bin_exp(long long a, long long n) {
if (n == 1)
return a;
else if (n % 2 == 1)
return (bin_exp(a, n / 2) * bin_exp(a, n / 2) * a) % 1000000007;
else
return (bin_exp(a, n / 2) * bin_exp(a, n / 2)) % 1000000007;
}
using namespace std;
int main() {
long long t;
{
long long sum = 0, flag = 0, i, j, k, x, y, z, n, m, p, t;
cin >> n;
flag = 1;
y = 0;
x = 0;
for (i = 1; i <= n; i++) {
flag = (i * flag) % 1000000007;
}
x = bin_exp(2, n - 1) % 1000000007;
cout << (flag - x + 1000000007) % 1000000007;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int mod = 1000000007;
using namespace std;
long long factorial(long long n) {
if (n == 1)
return n;
else {
long long p = (n - 1) % mod;
return ((n % mod) * (factorial(p) % mod)) % mod;
}
}
long long power(long long n, long long nn) {
long long ans = 1;
for (int i = 0; i < nn; i++) {
ans = ((ans) * (n % mod)) % mod;
}
return ans;
}
int main() {
long long n;
cin >> n;
long long ans = (factorial(n) % mod);
long long second = (n - 1);
long long temp = (power(2, second) % mod);
ans = ans - temp;
if (ans < 0) {
ans += mod;
cout << ans << '\n';
} else
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
const long long p = 1e9 + 7;
long long factmod(long long n) {
long long res = 1;
while (n > 1) {
res = (res * ((n / p) % 2 ? p - 1 : 1)) % p;
for (long long i = 2; i <= n % p; ++i) res = (res * i) % p;
n /= p;
}
return res % p;
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
cout << (factmod(n) + p - binpow(2, n - 1, p)) % p << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline const char nl = '\n';
inline const long long MOD = 1000000007;
inline const long double pi = 3.141592653589793238;
long long fscn() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
long long sg = 0;
if (c == '-') {
c = getchar();
sg = 1;
}
long long ret = 0;
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return sg ? -ret : ret;
}
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
long long n = fscn();
long long fact = 1;
for (long long i = 1; i < n + 1; i++) {
fact = (fact * i) % MOD;
}
long long x = (fact - power(2, (n - 1), MOD)) % MOD;
cout << (x < 0 ? (MOD + x) : x) << nl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long power(long long a, long long b) {
long long res = 1;
while (b != 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b / 2;
}
return res;
}
int main() {
int n;
cin >> n;
long long f = 1;
for (int i = 1; i <= n; i++) {
f = (f * i) % mod;
}
long long p = power(2, n - 1);
long long ans = (f - p + mod) % mod;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 3e6;
const double eps = 0.00000001;
long long ksm(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
int main() {
long long c, n, ans;
std::ios::sync_with_stdio(false);
cin >> n;
c = 1;
for (int i = 1; i <= n; i++) c = c * i % mod;
ans = (c + mod - ksm(2, n - 1)) % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int n;
scanf("%d", &n);
long long ge1 = 1;
for (int i = 1; i <= n; i++) {
ge1 = (ge1 % mod * i % mod) % mod;
}
long long ge2 = 1;
for (int i = 1; i <= n - 1; i++) {
ge2 = (ge2 % mod * 2) % mod;
}
cout << (ge1 - ge2 + mod) % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int MOD = mod;
using vi = vector<int>;
using vl = vector<long long int>;
using lli = long long int;
lli modexp(lli a, lli n) {
lli res = 1;
while (n > 0) {
if (n & 1) {
res = (res * a) % MOD;
}
a = (a * a) % MOD;
n = (n >> 1);
}
return res;
}
lli facto(lli n) {
lli res = 1;
for (lli i = 1; i <= n; i++) {
res = (res * i) % MOD;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
cout << ((facto(n) - modexp(2, n - 1) + MOD) % MOD);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using u64 = uint64_t;
long long fact[1000006];
void facto() {
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i < 1000006; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1LL;
facto();
long long ans[1000006];
ans[3] = 2;
for (int i = 4; i < 1000006 - 2; i++)
ans[i] =
((fact[i - 1] * (i - 2)) % 1000000007 + ans[i - 1] * 2) % 1000000007;
while (t--) {
long long n;
cin >> n;
cout << ans[n];
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll M = 1000000007;
int n;
ll f[1000002];
int power(ll a) {
if (a == 1) return 1;
ll k = 1;
int p = M - 2;
while (p) {
if (p & 1) k = k * a % M;
p >>= 1;
a = a * a % M;
}
return k;
}
int main() {
cin >> n;
f[0] = f[1] = 1;
for (ll i = 2; i <= n; i++) f[i] = f[i - 1] * i % M;
ll ans = f[n];
for (int i = 0; i < n; i++) {
ll l = (f[n - 1] * power(f[i])) % M * power(f[n - 1 - i]) % M;
ans -= l;
if (ans < 0) ans += M;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
long long n;
long long res, fact;
cin >> n;
res = 1;
fact = 1;
for (int i = 1; i <= n - 1; i++) {
res *= 2;
fact *= i;
fact %= MOD;
res %= MOD;
}
fact *= n;
fact %= MOD;
fact -= res;
fact %= MOD;
if (fact < 0) fact += MOD;
cout << fact;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1000010;
long long powermod(long long x, long long n) {
if (n == 0) return 1;
if (n == 1) return x;
if (n % 2 == 0) return powermod((x * x) % mod, n / 2);
if (n % 2 == 1) return (x * powermod((x * x) % mod, n / 2)) % mod;
}
long long mul(long long x, long long y) { return (x * y) % mod; }
long long inv(long long x) { return powermod(x, mod - 2); }
long long divide(long long x, long long y) { return mul(x, inv(y)); }
long long add(long long x, long long y) {
x = (x + y) % mod;
while (x < 0) x += mod;
return x;
}
long long F[N];
void compF() {
F[0] = 1;
for (long long i = 1; i < N; ++i) F[i] = mul(F[i - 1], i);
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
compF();
long long n;
cin >> n;
long long pos = 1;
for (int i = n; i > 1; --i) pos = mul(pos, i);
long long res = 0;
for (int i = 0; i < n; ++i)
res = res + divide(F[n - 1], mul(F[n - i - 1], F[i]));
cout << add(pos, -res) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << (i + 1 != (int)v.size() ? " " : "");
}
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v) is >> in;
return is;
}
template <int MOD>
struct ModInt {
static constexpr int mod = MOD;
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % MOD : (MOD - (-y) % MOD) % MOD) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += MOD - p.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % MOD);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inv();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inv() const {
int a = x, b = MOD, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<MOD>(t);
return (is);
}
static int get_mod() { return MOD; }
};
const int mod = 1e9 + 7;
using mint = ModInt<mod>;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
mint p(int n, int k) {
if (0 <= k && k <= n) return fact[n] * ifact[n - k];
return 0;
}
};
int main() {
ll n;
cin >> n;
combination nck(2000200);
mint ans = nck.p(n, n);
ans -= mint(2).pow(n - 1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200007], b[200007];
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
long long fact(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (int i = 1; i <= n; i++) result = ((result % p) * (i % p)) % p;
return result;
}
int main() {
long long t = 1;
while (t--) {
long long i, j, k, l, ans = 0, count = 0, n;
cin >> n;
cout << (((fact(n, 1000000007)) + 1000000007) -
(power(2, n - 1, 1000000007)) % 1000000007) %
1000000007
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long F[1000005];
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y % 2 != 0) res = res * x % p;
y = y / 2;
x = x * x % p;
}
return res;
}
long long ncr(long long n, long long r, long long p) {
if (r > n) return 0;
long long res = F[n];
res = (res * power(F[r], p - 2ll, p)) % p;
res = (res * power(F[n - r], p - 2ll, p)) % p;
return res;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0)
return b;
else
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
F[0] = F[1] = 1;
for (long long i = 2; i < 1000005; i++) F[i] = (F[i - 1] * i) % 1000000007;
long long n;
cin >> n;
long long ans =
(F[n] - power(2, n - 1, 1000000007) + 1000000007) % 1000000007;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void self_add(long long &x, long long y) { x = (x + y) % mod; }
long long binpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * a) % mod;
n >>= 1;
a = (a * a) % mod;
}
return res;
}
int main() {
long long n;
cin >> n;
long long fact = 1;
for (long long i = 2; i <= n; i++) {
fact = (fact * (i)) % mod;
}
long long power = binpow(2, n - 1);
long long ans = (fact - power) % mod;
if (ans < 0) ans += mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
ll ans = 1;
for (int i = 1; i <= n; i++) {
ans = ans * i % MOD;
}
ll sub = 1;
for (int i = 1; i < n; i++) sub = sub * 2 % MOD;
ans -= sub;
if (ans < 0) ans += MOD;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed long long N;
const signed long long mo = 1000000007;
signed long long dp[1010101][3];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N;
signed long long ret = 1;
signed long long p2 = 1;
for (i = 1; i <= N; i++) {
ret = ret * i % mo;
if (i < N) p2 = p2 * 2 % mo;
}
cout << (ret + mo - p2) % mo << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
long long int n;
cin >> n;
long long int ans = 1;
for (int i = 1; i <= n; i++) ans = (ans * i) % 1000000007;
long long int term = 1;
for (int i = 1; i < n; i++) term = (term * 2) % 1000000007;
ans = (ans - term + 1000000007) % 1000000007;
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const ll mod = 1e9 + 7;
ll binpow(ll a, ll b) {
a %= mod;
ll res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
ll modFact(ll n) {
vector<ll> fact(n + 1);
fact[0] = 1;
for (ll i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
return fact.back();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q = 1;
while (q--) {
ll n;
cin >> n;
ll ans = (modFact(n) - binpow(2, n - 1) + mod) % mod;
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll OO = 1e18;
int di[8] = {0, 0, 1, -1, -1, 1, -1, 1};
int dj[8] = {1, -1, 0, 0, 1, 1, -1, -1};
string ys = "YES", no = "NO";
const int N = 1 << 20, M = 1 << 10;
const ll mod = 1e9 + 7;
ll fast_power(ll base, ll power) {
ll ans = 1;
while (power > 0) {
if (power & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
power >>= 1;
}
return ans;
}
ll fact(ll n) {
if (n == 1) return 1;
return n * fact(n - 1) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
ll n;
cin >> n;
cout << (fact(n) - fast_power(2, n - 1) + mod) % mod << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long a = 1, b = 1;
for (int i = 1; i <= (int)(n); ++i) a = (a * i) % 1000000007;
for (int i = 1; i <= (int)(n - 1); ++i) b = (b * 2) % 1000000007;
cout << (a - b + 1000000007) % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
const int inf = INT_MAX;
const long int mod = 1000000007;
const int size_s = 100001;
void solve() {
int n;
cin >> n;
long long fact = 1, p2 = 1;
for (int i = 1; i <= n; i++) {
fact = (fact * i) % mod;
}
for (int i = 1; i < n; i++) p2 = (p2 * 2) % mod;
cout << (fact - p2 + mod) % mod << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10, mod = 1e9 + 7;
long long pow_mod(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long fac[N];
signed main() {
fac[0] = 1;
for (long long i = 1; i <= N - 10; i++) fac[i] = fac[i - 1] * i % mod;
long long n;
cin >> n;
cout << (fac[n] - pow_mod(2, n - 1, mod) + mod) % mod << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(array<T, 2> &arr);
template <typename T>
void print(vector<T> &v);
template <typename T>
void print(deque<T> &v);
template <typename T>
T _gcd(T a, T b);
template <typename T>
vector<T> sieve(T n);
template <typename T>
T power(T x, T y, long long p = LLONG_MAX);
long long nxt();
template <typename T>
T modInverse(T n, T p);
long long gcd(vector<long long> &diff);
bool isPowerof2(long long x);
vector<long long> divisors(long long n);
long long nCrModPFermat(long long n, long long r, long long p = LLONG_MAX);
long long sum(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
long long n;
cin >> n;
long long mod = 1e9 + 7;
long long fac = 1;
for (int i = 1; i <= n; i++) {
fac *= i;
fac %= mod;
}
long long ans = fac - power(2ll, n - 1, mod);
if (ans < 0) ans += mod;
cout << ans << endl;
}
}
template <typename T>
T power(T x, T y, long long p) {
T res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
template <typename T>
vector<T> sieve(T n) {
vector<bool> prime(n + 1, true);
for (int i = 2; i * i <= n; i++) {
if (prime[i]) {
for (int j = 2; j * i <= n; j++) {
prime[i * j] = false;
}
}
}
vector<T> ans;
for (int i = 2; i <= n; i++) {
if (prime[i]) ans.push_back(i);
}
return ans;
}
template <typename T>
T _gcd(T a, T b) {
T temp1 = max(a, b), temp2 = min(a, b);
a = temp1, b = temp2;
if (a == 0) return b;
if (b == 0) return a;
if (a % b == 0) return b;
return _gcd(b, a % b);
}
template <typename T>
void print(array<T, 2> &arr) {
cout << arr[0] << " " << arr[1] << endl;
}
template <typename T>
void print(vector<T> &v) {
for (T x : v) cout << x << " ";
cout << endl;
}
template <typename T>
T modInverse(T n, T p) {
return power(n, p - 2, p) % p;
}
template <typename T>
void print(deque<T> &v) {
for (auto x : v) cout << x << " ";
cout << endl;
}
long long nxt() {
long long x;
cin >> x;
return x;
}
bool isPowerof2(long long x) { return !(x && (x & (x - 1))); }
vector<long long> divisors(long long n) {
vector<long long> ans;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
ans.push_back(i);
if (n / i != i) ans.push_back(n / i);
}
}
ans.push_back(1);
return ans;
}
long long nCrModPFermat(long long n, long long r, long long p) {
static bool calc = 0;
static const long long facn = 3e5;
static const long long mod = LLONG_MAX;
static long long fac[facn + 1];
if (!calc) {
fac[0] = 1;
for (int i = 1; i <= facn; i++) fac[i] = (fac[i - 1] * i) % mod;
}
calc = 1;
if (n < r) return 0;
if (r == 0) return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
const long long maxn = 1e6 + 10, N = 1e9, mod = 1e9 + 7, INF = 1e9, lg = 32;
char a[110][110];
long long fac[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
long long n;
cin >> n;
long long bad = 1;
for (int i = 1; i < n; ++i) {
bad = (bad * 2) % mod;
}
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = (fac[i - 1] * i) % mod;
}
long long ans = fac[n] - bad + mod;
cout << ans % mod << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 0x3f3f3f3f3f3f3f3fLL;
long long int i, j, k;
void solve(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
int t = 1;
while (t--) solve();
return 0;
}
inline long long int power(long long int x, long long int n,
long long int m = LLONG_MAX) {
long long int res = 1;
x = (x % m + m) % m;
while (n) {
if (n & 1) res = (res * x) % m;
x = (x * x) % m;
n >>= 1;
}
return res;
}
void solve() {
long long int n;
cin >> n;
long long int cnt = 1;
for (i = (1); i <= (n); ++i) cnt = (i * cnt) % mod;
cnt -= power(2, n - 1, mod);
cnt += mod;
cnt %= mod;
cout << cnt << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long dx[8] = {+1, +1, +1, 0, 0, -1, -1, -1};
long long dy[8] = {+1, 0, -1, +1, -1, +1, 0, -1};
void input_File() {}
long long powmod(long long a, long long b, long long p) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = (ans * a) % p;
b--;
} else {
a = (a * a) % p;
b >>= 1;
}
}
return ans;
}
long long fact(long long n) {
long long ans = 1;
for (long long i = 1; i <= n; i++)
ans = (ans % 1000000007 * i % 1000000007) % 1000000007;
return ans;
}
void solve() {
long long n;
cin >> n;
long long factorial = fact(n);
long long mountain_pattern = powmod(2, n - 1, 1000000007);
long long ans = (factorial - mountain_pattern + 1000000007) % 1000000007;
cout << ans << "\n";
}
signed main() {
input_File();
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long isTestCasePresent = 0;
if (isTestCasePresent == 0) {
long long t = 1;
while (t--) {
solve();
}
} else {
long long t;
cin >> t;
while (t--) {
solve();
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 1;
const long long mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
long long two = 1;
long long fac = 1;
for (int i = 2; i <= n; i++) {
two = (two * 2) % mod;
fac = (fac * i) % mod;
}
long long ans = fac - two;
if (ans < 0) ans += mod;
ans %= mod;
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long jie(int x) {
long long sum = 1;
for (int i = 1; i <= x; i++) {
sum *= i;
sum = sum % (1000000007);
}
return sum;
}
long long zhi(int x) {
long long sum = 1;
for (int i = 0; i < x; i++) {
sum *= 2;
sum = sum % 1000000007;
}
return sum;
}
long long ans(int x) {
long long sum = jie(x);
sum += 1000000007;
sum -= zhi(x - 1);
sum = sum % 1000000007;
return sum;
}
int main() {
cin >> n;
cout << ans(n);
cin >> n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n == 1) {
return false;
}
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
unsigned long long int power(unsigned long long int x, unsigned long long int y,
unsigned long long int p) {
unsigned long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int binarySearch(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long int n, a, b = 1;
cin >> n;
a = power(2, n - 1, 1000000007);
for (int i = n; i > 1; i--) {
b *= i;
b %= 1000000007;
}
unsigned long long int res = (b - a + 1000000007) % 1000000007;
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, oo = 1e9;
long long power(long long x) {
if (x == 0) return 1;
long long n = power(x / 2);
n = (n * n) % 1000000007;
if (x % 2) n *= 2;
return n % 1000000007;
}
void solve() {
long long n;
cin >> n;
long long ans = n;
for (int i = 1; i < n; i++) {
ans *= i;
ans %= 1000000007;
}
cout << (ans - power(n - 1) + 1000000007) % 1000000007 << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long res = 1;
long long mod = 1e9 + 7;
for (int i = 1; i <= n; ++i) {
res *= i;
if (res > mod) res %= mod;
}
long long k2 = 1;
for (int j = 1; j <= n - 1; ++j) {
k2 *= 2;
if (k2 > mod) k2 %= mod;
}
res -= k2;
while (res < 0) {
res += mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
long long fact[1000006], fact_inv[1000006];
long long ncr(long long n, long long r) {
if (n == r || r == 0) return 1;
if (r > n) return 0;
return (((fact[n] * fact_inv[n - r]) % 1000000007) * fact_inv[r]) %
1000000007;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
fact[0] = 1;
for (long long i = 1; i < 1000006; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
fact_inv[i] = power(fact[i], 1000000007 - 2);
}
long long n;
cin >> n;
long long ans = fact[n];
for (long long i = 0; i < n; i++) {
ans = (ans - ncr(n - 1, i) + 1000000007) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
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;
}
long long powb(long long a, long long b) {
long long res = 1;
a;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
long long ans = 1, del = 1;
for (int i = 1; i <= n; i++) {
(ans *= i) %= mod;
if (i < n) del = del * 2 % mod;
}
cout << ((ans - del) % mod + mod) % mod << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nex[2000000], hea[2000000], wen[2000000], val[2000000], aid[2000000],
root2, root1, len, maxx;
struct segment_tree {
int a[2000000][2], lazy[2000000], fa[1000000], dep[1000000], in[1000000],
out[1000000], m;
void pushdown(int k) {
if (!lazy[k]) return;
swap(a[k << 1][0], a[k << 1][1]);
swap(a[(k << 1) | 1][0], a[(k << 1) | 1][1]);
lazy[k << 1] ^= 1;
lazy[(k << 1) | 1] ^= 1;
lazy[k] = 0;
}
void update1(int l, int r, int k, int x, int y, int z) {
if (l == r) {
a[k][z] = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid) update1(l, mid, k << 1, x, y, z);
if (x > mid) update1(mid + 1, r, (k << 1) | 1, x, y, z);
a[k][0] = max(a[k << 1][0], a[(k << 1) | 1][0]);
a[k][1] = max(a[k << 1][1], a[(k << 1) | 1][1]);
}
void update2(int l, int r, int k, int x, int y) {
if (l >= x && r <= y) {
lazy[k] ^= 1;
swap(a[k][0], a[k][1]);
return;
}
pushdown(k);
int mid = (l + r) >> 1;
if (x <= mid) update2(l, mid, k << 1, x, y);
if (y > mid) update2(mid + 1, r, (k << 1) | 1, x, y);
a[k][0] = max(a[k << 1][0], a[(k << 1) | 1][0]);
a[k][1] = max(a[k << 1][1], a[(k << 1) | 1][1]);
}
void build(int x, int y, int z) {
int a = 0;
in[x] = ++m;
dep[x] = dep[y] + 1;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) {
++a;
fa[aid[i]] = wen[i];
build(wen[i], x, z ^ val[i]);
}
update1(1, n, 1, in[x], dep[x], z);
out[x] = m;
}
void revers(int x) { update2(1, n, 1, in[fa[x]], out[fa[x]]); }
} st1, st2;
void add(int x, int y, int z, int p) {
++len;
nex[len] = hea[x];
wen[len] = y;
val[len] = z;
aid[len] = p;
hea[x] = len;
}
void dfs(int x, int y, int z) {
if (z >= maxx) maxx = z, root1 = x;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) dfs(wen[i], x, z + 1);
}
void dfs1(int x, int y, int z) {
if (z >= maxx) maxx = z, root2 = x;
for (int i = hea[x]; i; i = nex[i])
if (wen[i] != y) dfs1(wen[i], x, z + 1);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z, i);
add(y, x, z, i);
}
dfs(1, 0, 0);
dfs1(root1, 0, 0);
st1.build(root1, 0, 0);
st2.build(root2, 0, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
st1.revers(x);
st2.revers(x);
printf(" %d\n", max(st1.a[1][0], st2.a[1][0]) - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, tot, dx, dy, nowmax;
int v[1000005], nxt[1000005], c[1000005], h[500005], x[500005], y[500005],
k[500005];
pair<int, int> max1[500005], max2[500005];
void addedge(int x, int y, int z) {
v[++tot] = y;
c[tot] = z;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
c[tot] = z;
nxt[tot] = h[y];
h[y] = tot;
}
struct seg {
int ncnt;
int dfn[500005], rnk[500005], siz[500005], col[500005], dep[500005],
f[500005], maxa[1100000][2], rev[1100000];
void dfs(int u, int fa) {
dfn[u] = ++ncnt, rnk[ncnt] = u, siz[u] = 1;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dep[v[p]] = dep[u] + 1, col[v[p]] = col[u] ^ c[p], f[v[p]] = u;
dfs(v[p], u);
siz[u] += siz[v[p]];
}
}
void build(int id, int l, int r) {
if (l == r) return (void)(maxa[id][col[rnk[l]]] = dep[rnk[l]]);
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
for (int i = 0; i < 2; i++)
maxa[id][i] = max(maxa[id << 1][i], maxa[id << 1 | 1][i]);
}
void pushdown(int id) {
if (rev[id]) {
rev[id << 1] ^= 1, swap(maxa[id << 1][0], maxa[id << 1][1]);
rev[id << 1 | 1] ^= 1, swap(maxa[id << 1 | 1][0], maxa[id << 1 | 1][1]);
rev[id] = 0;
}
}
void change(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr)
return (void)(rev[id] ^= 1, swap(maxa[id][0], maxa[id][1]));
pushdown(id);
int mid = (l + r) / 2;
if (qr <= mid)
change(id << 1, l, mid, ql, qr);
else if (ql > mid)
change(id << 1 | 1, mid + 1, r, ql, qr);
else
change(id << 1, l, mid, ql, mid),
change(id << 1 | 1, mid + 1, r, mid + 1, qr);
for (int i = 0; i < 2; i++)
maxa[id][i] = max(maxa[id << 1][i], maxa[id << 1 | 1][i]);
}
} t[2];
void dfs1(int u, int fa) {
max1[u].second = max2[u].second = u;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dfs1(v[p], u);
if (max1[v[p]].first + 1 > max1[u].first)
max2[u] = max1[u],
max1[u] = make_pair(max1[v[p]].first + 1, max1[v[p]].second);
else if (max1[v[p]].first + 1 > max2[u].first)
max2[u] = make_pair(max1[v[p]].first + 1, max1[v[p]].second);
}
if (chkmax(nowmax, max1[u].first + max2[u].first))
dx = max1[u].second, dy = max2[u].second;
}
int main() {
n = readint();
for (int i = 1; i < n; i++)
x[i] = readint(), y[i] = readint(), k[i] = readint();
for (int i = 1; i < n; i++) addedge(x[i], y[i], k[i]);
dfs1(1, -1);
t[0].dfs(dx, -1);
t[0].build(1, 1, n);
t[1].dfs(dy, -1);
t[1].build(1, 1, n);
int id;
m = readint();
for (int i = 1; i <= m; i++) {
id = readint();
if (t[0].f[x[id]] == y[id])
t[0].change(1, 1, n, t[0].dfn[x[id]],
t[0].dfn[x[id]] + t[0].siz[x[id]] - 1);
else
t[0].change(1, 1, n, t[0].dfn[y[id]],
t[0].dfn[y[id]] + t[0].siz[y[id]] - 1);
if (t[1].f[x[id]] == y[id])
t[1].change(1, 1, n, t[1].dfn[x[id]],
t[1].dfn[x[id]] + t[1].siz[x[id]] - 1);
else
t[1].change(1, 1, n, t[1].dfn[y[id]],
t[1].dfn[y[id]] + t[1].siz[y[id]] - 1);
printf("%d\n", max(t[0].maxa[1][0], t[1].maxa[1][0]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, fl = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch - '0');
return x * fl;
}
const int NN = 500000 + 17;
void open() {
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
}
void OK() { printf("OK\n"); }
int n, q;
int c[NN];
int ans[NN];
vector<pair<int, int> > e[NN];
pair<int, int> ep[NN];
struct Tree {
int fa[NN], dep[NN], d[NN], ll[NN], rr[NN], rev[NN];
int tim;
struct node {
int w[2];
} t[NN << 2];
int tag[NN << 2];
node merge(node a, node b) {
node c;
c.w[0] = max(a.w[0], b.w[0]);
c.w[1] = max(a.w[1], b.w[1]);
return c;
}
void set_tag(int rt) {
tag[rt] ^= 1;
swap(t[rt].w[0], t[rt].w[1]);
}
void psd(int rt) {
if (tag[rt]) {
set_tag(rt << 1);
set_tag(rt << 1 | 1);
tag[rt] = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].w[d[rev[l]]] = dep[rev[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void flip(int rt, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
set_tag(rt);
return;
}
psd(rt);
int mid = (l + r) >> 1;
if (ll <= mid) flip(rt << 1, l, mid, ll, rr);
if (rr > mid) flip(rt << 1 | 1, mid + 1, r, ll, rr);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void dfs(int x, int ff) {
fa[x] = ff;
dep[x] = dep[ff] + 1;
ll[x] = ++tim;
rev[tim] = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first, z = e[x][i].second;
if (y != ff) {
d[y] = (d[x] + z) & 1;
dfs(y, x);
}
}
rr[x] = tim;
}
void work(int root) {
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int x = ep[c[i]].first, y = ep[c[i]].second;
if (fa[x] == y) swap(x, y);
flip(1, 1, n, ll[y], rr[y]);
ans[i] = max(ans[i], t[1].w[0]);
}
}
} tx, ty;
int mx, pos, px, py;
void dfs(int x, int dep, int ff) {
if (dep > mx) mx = dep, pos = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first;
if (y != ff) dfs(y, dep + 1, x);
}
}
void get_path() {
dfs(1, 0, 0);
px = pos;
mx = -1;
dfs(px, 0, 0);
py = pos;
tx.work(px);
ty.work(py);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read(), z = read();
e[x].push_back(make_pair(y, z));
e[y].push_back(make_pair(x, z));
ep[i] = make_pair(x, y);
}
q = read();
for (int i = 1; i <= q; i++) c[i] = read();
get_path();
for (int i = 1; i <= q; i++) {
ans[i]--;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
struct Edge {
int u, v, w;
} e[N];
vector<int> g[N];
struct SegmentTree {
int tg[N << 2], mx[N << 2][2];
int l[N], r[N], rk[N], fa[N], dep[N], c[N], n;
void build(int k, int l, int r) {
tg[k] = 0;
if (l == r) {
mx[k][c[rk[l]]] = dep[rk[l]];
mx[k][c[rk[l]] ^ 1] = 0;
return;
}
int lk = k << 1, rk = k << 1 | 1, mid = (l + r) >> 1;
build(lk, l, mid);
build(rk, mid + 1, r);
mx[k][0] = max(mx[lk][0], mx[rk][0]);
mx[k][1] = max(mx[lk][1], mx[rk][1]);
}
void update(int a, int b, int k, int l, int r) {
if (a > r || b < l) return;
if (a <= l && r <= b) {
tg[k] ^= 1;
swap(mx[k][0], mx[k][1]);
return;
}
int lk = k << 1, rk = k << 1 | 1, mid = (l + r) >> 1;
if (tg[k]) {
tg[k] = 0;
tg[lk] ^= 1;
tg[rk] ^= 1;
swap(mx[lk][0], mx[lk][1]);
swap(mx[rk][0], mx[rk][1]);
}
update(a, b, lk, l, mid);
update(a, b, rk, mid + 1, r);
mx[k][0] = max(mx[lk][0], mx[rk][0]);
mx[k][1] = max(mx[lk][1], mx[rk][1]);
}
int query(int k) {
int u = e[k].u, v = e[k].v;
if (fa[u] == v) swap(u, v);
update(l[v], r[v], 1, 1, n);
return mx[1][0];
}
void dfs(int u, int f) {
l[u] = ++n;
fa[u] = f;
rk[n] = u;
for (auto i : g[u]) {
int v = e[i].u ^ e[i].v ^ u;
if (v == f) continue;
dep[v] = dep[u] + 1;
c[v] = c[u] ^ e[i].w;
dfs(v, u);
}
r[u] = n;
}
} tx, ty;
int n, m, x, y;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].w);
g[e[i].u].push_back(i);
g[e[i].v].push_back(i);
}
tx.dep[1] = tx.c[1] = tx.n = 0;
tx.dfs(1, 1);
x = 1;
for (int i = 1; i <= n; ++i)
if (tx.dep[i] > tx.dep[x]) x = i;
tx.dep[x] = tx.c[x] = tx.n = 0;
tx.dfs(x, x);
y = 1;
for (int i = 1; i <= n; ++i)
if (tx.dep[i] > tx.dep[y]) y = i;
ty.dep[y] = ty.c[y] = ty.n = 0;
ty.dfs(y, y);
tx.build(1, 1, n);
ty.build(1, 1, n);
scanf("%d", &m);
while (m--) {
int o;
scanf("%d", &o);
printf("%d\n", max(tx.query(o), ty.query(o)));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
int n, wdep[500050], dep[500050], In[500050], Out[500050], p[500050], tot, Q,
a[500050 << 1];
vector<tuple<int, int, int> > G[500050];
struct node {
int l, r;
int A[2], B, AB[2], BA[2], ABA[2];
node() {
A[0] = A[1] = B = AB[0] = AB[1] = BA[0] = BA[1] = ABA[0] = ABA[1] = -inf;
}
bool rev;
void Rev() {
swap(A[0], A[1]);
swap(AB[0], AB[1]);
swap(BA[0], BA[1]);
rev ^= 1;
}
} tree[500050 << 3];
void dfs(int u, int fa) {
a[++tot] = u;
In[u] = tot;
for (auto [v, w, id] : G[u]) {
if (v == fa) continue;
p[id] = v;
dep[v] = dep[u] + 1;
wdep[v] = wdep[u] + w;
dfs(v, u);
a[++tot] = u;
}
Out[u] = tot;
}
inline void pushdown(int i) {
if (tree[i].rev) {
tree[i << 1].Rev();
tree[i << 1 | 1].Rev();
tree[i].rev = 0;
}
}
inline void update(int i) {
tree[i].B = max(tree[i << 1].B, tree[i << 1 | 1].B);
for (int p = 0; p < 2; ++p) {
tree[i].A[p] = max(tree[i << 1].A[p], tree[i << 1 | 1].A[p]);
tree[i].AB[p] = max(max(tree[i << 1].AB[p], tree[i << 1 | 1].AB[p]),
tree[i << 1].A[p] + tree[i << 1 | 1].B);
tree[i].BA[p] = max(max(tree[i << 1].BA[p], tree[i << 1 | 1].BA[p]),
tree[i << 1].B + tree[i << 1 | 1].A[p]);
tree[i].ABA[p] = max(tree[i << 1].ABA[p], tree[i << 1 | 1].ABA[p]);
}
for (int p1 = 0; p1 < 2; ++p1) {
for (int p2 = 0; p2 < 2; ++p2) {
tree[i].ABA[p1 ^ p2] =
max(tree[i].ABA[p1 ^ p2],
max(tree[i << 1].AB[p1] + tree[i << 1 | 1].A[p2],
tree[i << 1].A[p1] + tree[i << 1 | 1].BA[p2]));
}
}
}
void build(int i, int l, int r) {
tree[i].l = l;
tree[i].r = r;
if (l == r) {
int u = a[l];
int p = wdep[u] & 1;
tree[i].A[p] = dep[u];
tree[i].B = -2 * dep[u];
tree[i].AB[p] = tree[i].BA[p] = -dep[u];
return;
}
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
update(i);
}
void Change(int i, int l, int r) {
if (tree[i].l >= l && tree[i].r <= r) {
tree[i].Rev();
return;
}
pushdown(i);
int mid = (tree[i].l + tree[i].r) >> 1;
if (l <= mid) {
Change(i << 1, l, r);
}
if (r > mid) {
Change(i << 1 | 1, l, r);
}
update(i);
}
int main() {
n = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read(), w = read();
G[u].emplace_back(v, w, i);
G[v].emplace_back(u, w, i);
}
dfs(1, 0);
build(1, 1, tot);
Q = read();
while (Q--) {
int u = read();
Change(1, In[p[u]], Out[p[u]]);
printf("%d\n", tree[1].ABA[0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct E {
int to, val;
};
struct Edge {
int x, y;
} e[500005];
vector<E> g[500005];
int n, m;
namespace Solve1 {
struct P {
int mx[2];
int& operator[](int k) { return mx[k]; }
} t[2000005];
P operator+(P a, P b) { return {max(a[0], b[0]), max(a[1], b[1])}; }
int tag[2000005], dfn[500005], sign, size[500005];
void Upd(int p, int l, int r, int x, int z, int w) {
if (l == r) return t[p][z] = w, t[p][z ^ 1] = 0, void();
int mid = (l + r) / 2;
if (x <= mid)
Upd(p * 2, l, mid, x, z, w);
else
Upd(p * 2 + 1, mid + 1, r, x, z, w);
t[p] = t[p * 2] + t[p * 2 + 1];
}
void Tag(int p) { tag[p] ^= 1, swap(t[p][0], t[p][1]); }
void Pushdown(int p) {
if (tag[p]) Tag(p * 2), Tag(p * 2 + 1), tag[p] = 0;
}
void Rev(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return Tag(p), void();
Pushdown(p);
int mid = (l + r) / 2;
if (x <= mid) Rev(p * 2, l, mid, x, y);
if (mid < y) Rev(p * 2 + 1, mid + 1, r, x, y);
t[p] = t[p * 2] + t[p * 2 + 1];
}
void dfs2(int x, int f, int di, int v) {
size[x] = 1, dfn[x] = ++sign, Upd(1, 1, n, dfn[x], v, di);
for (E i : g[x]) {
int y = i.to;
if (y == f) continue;
dfs2(y, x, di + 1, v ^ i.val), size[x] += size[y];
}
}
void Init(int L) { dfs2(L, 0, 0, 0); }
int s(int x) {
if (dfn[e[x].x] < dfn[e[x].y]) swap(e[x].x, e[x].y);
Rev(1, 1, n, dfn[e[x].x], dfn[e[x].x] + size[e[x].x] - 1);
return t[1][0];
}
} // namespace Solve1
namespace Solve2 {
struct P {
int mx[2];
int& operator[](int k) { return mx[k]; }
} t[2000005];
P operator+(P a, P b) { return {max(a[0], b[0]), max(a[1], b[1])}; }
int tag[2000005], dfn[500005], sign, size[500005];
void Upd(int p, int l, int r, int x, int z, int w) {
if (l == r) return t[p][z] = w, t[p][z ^ 1] = 0, void();
int mid = (l + r) / 2;
if (x <= mid)
Upd(p * 2, l, mid, x, z, w);
else
Upd(p * 2 + 1, mid + 1, r, x, z, w);
t[p] = t[p * 2] + t[p * 2 + 1];
}
void Tag(int p) { tag[p] ^= 1, swap(t[p][0], t[p][1]); }
void Pushdown(int p) {
if (tag[p]) Tag(p * 2), Tag(p * 2 + 1), tag[p] = 0;
}
void Rev(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return Tag(p), void();
Pushdown(p);
int mid = (l + r) / 2;
if (x <= mid) Rev(p * 2, l, mid, x, y);
if (mid < y) Rev(p * 2 + 1, mid + 1, r, x, y);
t[p] = t[p * 2] + t[p * 2 + 1];
}
void dfs2(int x, int f, int di, int v) {
size[x] = 1, dfn[x] = ++sign, Upd(1, 1, n, dfn[x], v, di);
for (E i : g[x]) {
int y = i.to;
if (y == f) continue;
dfs2(y, x, di + 1, v ^ i.val), size[x] += size[y];
}
}
void Init(int L) { dfs2(L, 0, 0, 0); }
int s(int x) {
if (dfn[e[x].x] < dfn[e[x].y]) swap(e[x].x, e[x].y);
Rev(1, 1, n, dfn[e[x].x], dfn[e[x].x] + size[e[x].x] - 1);
return t[1][0];
}
} // namespace Solve2
void dfs1(int x, int f, int di, int& var, int& mx) {
if (di > mx) mx = di, var = x;
for (E i : g[x]) {
int y = i.to;
if (y == f) continue;
dfs1(y, x, di + 1, var, mx);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, x, y, z; i < n; i++)
scanf("%d%d%d", &x, &y, &z), g[x].push_back({y, z}), g[y].push_back({x, z}),
e[i] = {x, y};
int L = 0, R = 0, mx = -1;
dfs1(1, 0, 0, L, mx), mx = -1, dfs1(L, 0, 0, R, mx), scanf("%d", &m);
Solve1::Init(L), Solve2::Init(R);
while (m--) {
int x;
scanf("%d", &x), printf("%d\n", max(Solve1::s(x), Solve2::s(x)));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
struct Edge {
int u, v, w;
} a[maxn];
vector<pair<int, int>> E[maxn];
int rt1, rt2, ma;
pair<int, int> ma1[maxn], ma2[maxn];
void DFS(int u, int pre) {
ma1[u] = ma2[u] = {0, u};
for (auto edge : E[u]) {
int v = edge.first;
if (v == pre) continue;
DFS(v, u);
pair<int, int> t = ma1[v];
if (t > ma1[u]) swap(t, ma1[u]);
if (t > ma2[u]) swap(t, ma2[u]);
}
if (ma1[u].first + ma2[u].first > ma) {
ma = ma1[u].first + ma2[u].first;
rt1 = ma1[u].second;
rt2 = ma2[u].second;
}
ma1[u].first++;
ma2[u].first++;
}
struct Tree {
int c[maxn << 2][2];
int lazy[maxn << 2], in[maxn], out[maxn];
int rank[maxn], dep[maxn], col[maxn], tot;
void pushdown(int rt) {
if (!lazy[rt]) return;
swap(c[rt << 1][0], c[rt << 1][1]);
swap(c[rt << 1 | 1][0], c[rt << 1 | 1][1]);
lazy[rt << 1] ^= 1;
lazy[rt << 1 | 1] ^= 1;
lazy[rt] = 0;
}
void pushup(int rt) {
c[rt][0] = max(c[rt << 1][0], c[rt << 1 | 1][0]);
c[rt][1] = max(c[rt << 1][1], c[rt << 1 | 1][1]);
}
void build(int rt, int l, int r) {
c[rt][0] = c[rt][1] = lazy[rt] = 0;
if (l == r) {
c[rt][col[rank[l]]] = dep[rank[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void update(int rt, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
swap(c[rt][0], c[rt][1]);
lazy[rt] ^= 1;
return;
}
pushdown(rt);
int mid = (l + r) >> 1;
if (mid >= qr)
update(rt << 1, l, mid, ql, qr);
else if (mid + 1 <= ql)
update(rt << 1 | 1, mid + 1, r, ql, qr);
else
update(rt << 1, l, mid, ql, mid),
update(rt << 1 | 1, mid + 1, r, mid + 1, qr);
pushup(rt);
}
void dfs(int u, int pre) {
in[u] = ++tot;
rank[tot] = u;
dep[u] = dep[pre] + 1;
for (auto edge : E[u]) {
int v = edge.first, w = edge.second;
if (v == pre) continue;
col[v] = col[u] ^ w;
dfs(v, u);
}
out[u] = tot;
}
} T[2];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y, z;
cin >> x >> y >> z;
a[i] = Edge{x, y, z};
E[x].emplace_back(y, z);
E[y].emplace_back(x, z);
}
DFS(1, 0);
T[0].dfs(rt1, 0);
T[0].build(1, 1, n);
T[1].dfs(rt2, 0);
T[1].build(1, 1, n);
int Q;
cin >> Q;
while (Q--) {
int x;
cin >> x;
int y = a[x].u;
if (T[0].dep[a[x].u] < T[0].dep[a[x].v]) y = a[x].v;
T[0].update(1, 1, n, T[0].in[y], T[0].out[y]);
y = a[x].u;
if (T[1].dep[a[x].u] < T[1].dep[a[x].v]) y = a[x].v;
T[1].update(1, 1, n, T[1].in[y], T[1].out[y]);
int ans = max(T[0].c[1][0], T[1].c[1][0]) - 1;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
char ibuf[1 << 20], obuf[1 << 20];
const char *sp, *ep;
char *op = obuf;
int read() {
static int c, x;
while (
(c = (sp == ep && (ep = (sp = ibuf) + fread(ibuf, 1, sizeof ibuf, stdin)),
*sp++)) < 48) {
}
x = c & 15;
while (
(c = (sp == ep && (ep = (sp = ibuf) + fread(ibuf, 1, sizeof ibuf, stdin)),
*sp++)) >= 48)
x = x * 10 + (c & 15);
return x;
}
void write(const int &x) {
if (x >= 10) write(x / 10);
(op == obuf + sizeof obuf && (fwrite(obuf, 1, op - obuf, stdout), op = obuf),
*op++ = ((x % 10) | 48));
}
typedef int arr[500010];
struct edge {
int next, to;
bool v;
} e[500010 << 1];
int n, rt;
arr head, dep;
inline void add(const int &x, const int &y, const bool &z) {
static int ei = 1;
e[++ei].next = head[x];
e[ei].to = y;
e[ei].v = z;
head[x] = ei;
}
void dfs(const int f, const int &fa) {
if (dep[f] > dep[rt]) rt = f;
for (int i = head[f]; i; i = e[i].next) {
const int t = e[i].to;
if (t != fa) {
dep[t] = dep[f] + 1;
dfs(t, f);
}
}
}
struct solver {
int cnt;
arr dep, dfn, out, seg;
bool sum[500010];
int p0[500010 << 2], p1[500010 << 2];
bool tag[500010 << 2];
void dfs(const int &f, const int &fa) {
seg[++cnt] = f;
dfn[f] = cnt;
for (int i = head[f]; i; i = e[i].next) {
const int t = e[i].to;
if (t != fa) {
dep[t] = dep[f] + 1;
sum[t] = sum[f] ^ e[i].v;
dfs(t, f);
}
}
out[f] = cnt;
}
inline void mark(const int &o) {
tag[o] = !tag[o];
std::swap(p0[o], p1[o]);
}
inline void pushup(const int &o) {
p0[o] = std::max(p0[o << 1], p0[o << 1 | 1]);
p1[o] = std::max(p1[o << 1], p1[o << 1 | 1]);
}
void build(const int &o, const int &l, const int &r) {
if (l == r) {
const int x = seg[l];
if (sum[x]) {
p1[o] = dep[x];
} else {
p0[o] = dep[x];
}
return;
}
const int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
pushup(o);
}
void modify(const int &o, const int &l, const int &r, const int &L,
const int &R) {
if (L <= l && r <= R) {
mark(o);
return;
}
const int mid = (l + r) >> 1;
if (tag[o]) {
mark(o << 1);
mark(o << 1 | 1);
tag[o] = false;
}
if (L <= mid) modify(o << 1, l, mid, L, R);
if (mid < R) modify(o << 1 | 1, mid + 1, r, L, R);
pushup(o);
}
inline void modify(const int &id) {
int x = e[id << 1].to, y = e[id << 1 | 1].to;
if (dep[x] < dep[y]) x = y;
modify(1, 1, n, dfn[x], out[x]);
}
} S1, S2;
int main() {
n = read();
for (int i = n; --i;) {
const int x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
S1.dfs(rt, 0);
dep[rt] = 0;
dfs(rt, 0);
S2.dfs(rt, 0);
S1.build(1, 1, n);
S2.build(1, 1, n);
for (int q = read(); q--;) {
const int x = read();
S1.modify(x);
S2.modify(x);
printf("%d\n", std::max(S1.p0[1], S2.p0[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode> {
splay_tree_vchs vnode;
using splay_tree<pnode>::ch;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode>() { root = NULL; }
void update() {}
void push() {}
void rotate() {
swap(vnode, this->p->vnode);
splay_tree<pnode>::rotate();
}
void splay() {
auto v = &vnode;
bool r = !v->key;
splay_tree<pnode>::splay();
if (r && v->key) {
if (this->p->root->key == NULL) this->p->root = v;
if (v->p) v->p->ch[v->p->ch[1] == &v->key->vnode] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
v->key = static_cast<pnode>(this);
}
}
void reverse() {}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs(v);
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
x->key = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs() : key(NULL){};
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() {}
void reverse() {}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, fl = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch - '0');
return x * fl;
}
const int NN = 500000 + 17;
void open() {
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
}
void OK() { printf("OK\n"); }
int n, q;
int c[NN];
int ans[NN];
vector<pair<int, int> > e[NN];
pair<int, int> ep[NN];
struct Tree {
int fa[NN], dep[NN], d[NN], ll[NN], rr[NN], rev[NN];
int tim;
struct node {
int w[2];
} t[NN << 2];
int tag[NN << 2];
node merge(node a, node b) {
node c;
c.w[0] = max(a.w[0], b.w[0]);
c.w[1] = max(a.w[1], b.w[1]);
return c;
}
void set_tag(int rt) {
tag[rt] ^= 1;
swap(t[rt].w[0], t[rt].w[1]);
}
void psd(int rt) {
if (tag[rt]) {
set_tag(rt << 1);
set_tag(rt << 1 | 1);
tag[rt] = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].w[d[rev[l]]] = dep[rev[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void flip(int rt, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
set_tag(rt);
return;
}
psd(rt);
int mid = (l + r) >> 1;
if (ll <= mid) flip(rt << 1, l, mid, ll, rr);
if (rr > mid) flip(rt << 1 | 1, mid + 1, r, ll, rr);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void dfs(int x, int ff) {
fa[x] = ff;
dep[x] = dep[ff] + 1;
ll[x] = ++tim;
rev[tim] = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first, z = e[x][i].second;
if (y != ff) {
d[y] = (d[x] + z) & 1;
dfs(y, x);
}
}
rr[x] = tim;
}
void work(int root) {
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int x = ep[c[i]].first, y = ep[c[i]].second;
if (fa[x] == y) swap(x, y);
flip(1, 1, n, ll[y], rr[y]);
ans[i] = max(ans[i], t[1].w[0]);
}
}
} tx, ty;
int mx, pos, px, py;
void dfs(int x, int dep, int ff) {
if (dep > mx) mx = dep, pos = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first;
if (y != ff) dfs(y, dep + 1, x);
}
}
void get_path() {
dfs(1, 0, 0);
px = pos;
mx = -1;
dfs(px, 0, 0);
py = pos;
tx.work(px);
ty.work(py);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read(), z = read();
e[x].push_back(make_pair(y, z));
e[y].push_back(make_pair(x, z));
ep[i] = make_pair(x, y);
}
q = read();
for (int i = 1; i <= q; i++) c[i] = read();
get_path();
for (int i = 1; i <= q; i++) {
ans[i]--;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int INFi = 2e9;
const int maxN = 5e5 + 1;
const int md1 = 998244353;
const int md = 1e9 + 7;
double getTime() { return clock() / (double)CLOCKS_PER_SEC; }
struct segment_tree {
struct Node {
int mx1 = 0, mx0 = 0;
int upd = 0;
void combine(const Node &a, const Node &b) {
mx1 = max(a.mx1, b.mx1);
mx0 = max(a.mx0, b.mx0);
if (upd) swap(mx1, mx0);
}
void init(pair<int, int> x) {
mx0 = mx1 = 0;
if (x.second == 1)
mx1 = x.first;
else
mx0 = x.first;
}
};
int n{};
vector<Node> tree{};
void build(int k, vector<pair<int, int>> &a) {
n = k;
tree.resize(n * 4);
make(1, 0, n, a);
}
void make(int v, int l, int r, vector<pair<int, int>> &a) {
if (l + 1 == r) {
tree[v].init(a[l]);
return;
}
make(v << 1, l, (l + r) >> 1, a);
make((v << 1) + 1, (l + r) >> 1, r, a);
tree[v].combine(tree[v << 1], tree[(v << 1) + 1]);
}
void upd(int v, int l, int r, int &lq, int &rq) {
if (l >= rq || r <= lq) return;
if (lq <= l && r <= rq) {
swap(tree[v].mx0, tree[v].mx1);
tree[v].upd ^= 1;
return;
}
upd(v << 1, l, (l + r) >> 1, lq, rq);
upd((v << 1) + 1, (l + r) >> 1, r, lq, rq);
tree[v].combine(tree[v << 1], tree[(v << 1) + 1]);
}
void upd(int lq, int rq) { upd(1, 0, n, lq, rq); }
int get() { return tree[1].mx0; }
};
int n;
vector<pair<int, int>> g[maxN];
pair<int, int> edges[maxN];
struct solver {
segment_tree st;
vector<int> l, r;
vector<pair<int, int>> a;
int root;
void build(int &ro) {
root = ro;
l.resize(n + 1);
r.resize(n + 1);
a.emplace_back(0, 0);
dfs(root, -1);
st.build(n, a);
}
void dfs(int v, int p) {
l[v] = (int)a.size() - 1;
for (auto &[u, t] : g[v]) {
if (u == p) continue;
a.emplace_back(a[l[v]].first + 1, a[l[v]].second ^ t);
dfs(u, v);
}
r[v] = a.size();
}
int get_max() { return st.get(); }
void upd(int u, int v) {
if (l[v] < l[u]) swap(u, v);
st.upd(l[v], r[v]);
}
};
int d = -1;
int a = -1, b = -1;
pair<int, int> find_diametr(int v, int p) {
pair<int, int> mx1 = {0, v}, mx2 = {-1, -1};
for (auto &[u, t] : g[v]) {
if (u == p) continue;
auto kek = find_diametr(u, v);
if (kek > mx1) {
mx2 = mx1;
mx1 = kek;
} else if (kek > mx2) {
mx2 = kek;
}
}
if (d < mx1.first + mx2.first) {
d = mx1.first + mx2.first;
a = mx1.second;
b = mx2.second;
}
mx1.first += 1;
return mx1;
}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v, t;
cin >> u >> v >> t;
g[u].emplace_back(v, t);
g[v].emplace_back(u, t);
edges[i] = {u, v};
}
find_diametr(1, -1);
solver sl1, sl2;
sl1.build(a);
sl2.build(b);
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int id;
cin >> id;
id--;
sl1.upd(edges[id].first, edges[id].second);
sl2.upd(edges[id].first, edges[id].second);
cout << max(sl1.get_max(), sl2.get_max()) << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tests = 1;
for (int _ = 0; _ < tests; ++_) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, INF = 1e9;
int n, q, cnt, dex;
vector<pair<int, int>> adj[N];
struct node {
int ans, mx[2], mn[2], x[2], y[2], lazy, d;
node() {
ans = mx[0] = mn[0] = x[0] = y[0] = lazy = d = 0;
mn[1] = INF;
mx[1] = x[1] = y[1] = -INF;
}
void add(int val = 1) {
mx[0] += val;
mn[0] += val;
x[0] -= val;
y[0] -= val;
d += val;
}
void merge(node a, node b) {
ans = max(a.ans, b.ans);
for (int i = 0; i < 2; i++) {
ans = max({ans, b.x[i] + a.mx[i], a.y[i] + b.mx[i]});
mx[i] = max(a.mx[i], b.mx[i]);
mn[i] = min(a.mn[i], b.mn[i]);
x[i] = max({a.x[i], b.x[i], b.mx[i] - 2 * min(a.mn[0], a.mn[1])});
y[i] = max({a.y[i], b.y[i], a.mx[i] - 2 * min(b.mn[0], b.mn[1])});
}
}
void change() {
swap(mx[0], mx[1]);
swap(mn[0], mn[1]);
swap(x[0], x[1]);
swap(y[0], y[1]);
lazy ^= 1;
}
} seg[N << 3];
struct edge {
int l, r, w, u, v;
} e[N];
void shift1(int id) {
seg[id << 1].add(seg[id].d);
seg[id << 1 | 1].add(seg[id].d);
seg[id].d = 0;
}
void build(int l, int r, int st = 0, int en = 2 * n - 1, int id = 1) {
if (l >= en || st >= r) return;
if (l <= st && en <= r) return seg[id].add();
shift1(id);
int mid = st + en >> 1;
build(l, r, st, mid, id << 1);
build(l, r, mid, en, id << 1 | 1);
seg[id].merge(seg[id << 1], seg[id << 1 | 1]);
}
void dfs(int u = 1, int par = 0) {
for (auto [v, id] : adj[u])
if (v ^ par) {
e[id].l = ++cnt;
dfs(v, u);
build(e[id].l, e[id].r = ++cnt);
}
}
void shift2(int id) {
if (seg[id].lazy) {
seg[id << 1].change();
seg[id << 1 | 1].change();
seg[id].lazy = 0;
}
}
void update(int l, int r, int st = 0, int en = 2 * n - 1, int id = 1) {
if (l >= en || st >= r) return;
if (l <= st && en <= r) return seg[id].change();
shift1(id);
shift2(id);
int mid = st + en >> 1;
update(l, r, st, mid, id << 1);
update(l, r, mid, en, id << 1 | 1);
seg[id].merge(seg[id << 1], seg[id << 1 | 1]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> e[i].u >> e[i].v >> e[i].w;
adj[e[i].u].push_back({e[i].v, i});
adj[e[i].v].push_back({e[i].u, i});
}
dfs();
for (int i = 0; i < n - 1; i++)
if (e[i].w) update(e[i].l, e[i].r);
cin >> q;
while (q--) {
cin >> dex;
dex--;
update(e[dex].l, e[dex].r);
cout << seg[1].ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, q, ans[N];
bool w[N];
int b[N], de[N], de2[N];
int tot, rev[N], pl[N], pr[N];
pair<int, int> edge[N];
vector<pair<int, int> > e[N];
pair<int, int> d;
struct tree {
int a[N << 2][2];
bool tag[N << 2];
void clear() {
memset(a, 0, sizeof(a));
memset(tag, 0, sizeof(tag));
}
void up(int now) {
a[now][0] = max(a[(now << 1)][0], a[(now << 1 | 1)][0]);
a[now][1] = max(a[(now << 1)][1], a[(now << 1 | 1)][1]);
}
void update(int now) {
tag[now] ^= 1;
swap(a[now][0], a[now][1]);
}
void down(int now) {
if (!tag[now]) return;
update((now << 1)), update((now << 1 | 1));
tag[now] = 0;
}
void build(int now, int l, int r) {
if (l == r) return (void)(a[now][0] = de[rev[l]]);
build((now << 1), l, ((l + r) >> 1));
build((now << 1 | 1), ((l + r) >> 1) + 1, r);
up(now);
}
void change(int now, int l, int r, int s, int t) {
if (s <= l && r <= t) return update(now);
down(now);
if (s <= ((l + r) >> 1)) change((now << 1), l, ((l + r) >> 1), s, t);
if (t > ((l + r) >> 1)) change((now << 1 | 1), ((l + r) >> 1) + 1, r, s, t);
up(now);
}
int ask() { return a[1][0]; }
} T;
void dfs(int u, int fa) {
de[u] = de[fa] + 1;
if (de[u] > de[d.first]) d.first = u;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first;
if (v == fa) continue;
dfs(v, u);
}
}
void dfs2(int u, int fa) {
pl[u] = ++tot;
rev[tot] = u;
for (int i = 0; i < e[u].size(); i++) {
int v = e[u][i].first, id = e[u][i].second;
if (v == fa) continue;
de[v] = de[u] + 1;
de2[v] = de2[u] + w[id];
dfs2(v, u);
}
pr[u] = tot;
}
void solve(int rt) {
tot = 0;
memset(de, 0, sizeof(de));
memset(de2, 0, sizeof(de2));
dfs2(rt, 0);
T.clear();
T.build(1, 1, n);
for (int i = 1; i < n; i++) {
if (!w[i]) continue;
int u =
de[edge[i].first] > de[edge[i].second] ? edge[i].first : edge[i].second;
T.change(1, 1, n, pl[u], pr[u]);
}
for (int i = 1; i <= q; i++) {
int u = de[edge[b[i]].first] > de[edge[b[i]].second] ? edge[b[i]].first
: edge[b[i]].second;
T.change(1, 1, n, pl[u], pr[u]);
ans[i] = max(T.ask(), ans[i]);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
edge[i] = make_pair(u, v);
e[u].push_back({v, i});
e[v].push_back({u, i});
cin >> w[i];
}
cin >> q;
for (int i = 1; i <= q; i++) cin >> b[i];
dfs(1, 0);
swap(d.first, d.second);
dfs(d.second, 0);
solve(d.first);
solve(d.second);
for (int i = 1; i <= q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, fl = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch - '0');
return x * fl;
}
const int NN = 500000 + 17;
void open() {
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
}
void OK() { printf("OK\n"); }
int n, q;
int c[NN];
int ans[NN];
vector<pair<int, int> > e[NN];
pair<int, int> ep[NN];
struct Tree {
int fa[NN], dep[NN], d[NN], ll[NN], rr[NN], rev[NN];
int tim;
struct node {
int w[2];
} t[NN << 2];
int tag[NN << 2];
node merge(node a, node b) {
node c;
c.w[0] = max(a.w[0], b.w[0]);
c.w[1] = max(a.w[1], b.w[1]);
return c;
}
void set_tag(int rt) {
tag[rt] ^= 1;
swap(t[rt].w[0], t[rt].w[1]);
}
void psd(int rt) {
if (tag[rt]) {
set_tag(rt << 1);
set_tag(rt << 1 | 1);
tag[rt] = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].w[d[rev[l]]] = dep[rev[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void flip(int rt, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
set_tag(rt);
return;
}
psd(rt);
int mid = (l + r) >> 1;
if (ll <= mid) flip(rt << 1, l, mid, ll, rr);
if (rr > mid) flip(rt << 1 | 1, mid + 1, r, ll, rr);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void dfs(int x, int ff) {
fa[x] = ff;
dep[x] = dep[ff] + 1;
ll[x] = ++tim;
rev[tim] = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first, z = e[x][i].second;
if (y != ff) {
d[y] = (d[x] + z) & 1;
dfs(y, x);
}
}
rr[x] = tim;
}
void work(int root) {
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int x = ep[c[i]].first, y = ep[c[i]].second;
if (fa[x] == y) swap(x, y);
flip(1, 1, n, ll[y], rr[y]);
ans[i] = max(ans[i], t[1].w[0]);
}
}
} tx, ty;
int mx, pos, px, py;
void dfs(int x, int dep, int ff) {
if (dep > mx) mx = dep, pos = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first;
if (y != ff) dfs(y, dep + 1, x);
}
}
void get_path() {
dfs(1, 0, 0);
px = pos;
mx = -1;
dfs(px, 0, 0);
py = pos;
tx.work(px);
ty.work(py);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read(), z = read();
e[x].push_back(make_pair(y, z));
e[y].push_back(make_pair(x, z));
ep[i] = make_pair(x, y);
}
q = read();
for (int i = 1; i <= q; i++) c[i] = read();
get_path();
for (int i = 1; i <= q; i++) {
ans[i]--;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
inline char ch() {
static char s[1 << 16], *S, *T;
return (S == T) && (T = (S = s) + fread(s, 1, 1 << 16, stdin), S == T) ? EOF
: *S++;
}
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c = ch();
for (; !isdigit(c); c = ch())
if (c == '-') f = -1;
for (; isdigit(c); c = ch()) x = x * 10 + c - '0';
x *= f;
}
} // namespace IO
using namespace IO;
const int maxn = 500005;
int n, m, hd[maxn], cnt = 1, tS, tT, tmp;
struct edge {
int ed, nxt, len;
} e[2 * maxn];
inline void star(int u, int v, int l) {
e[++cnt] = (edge){v, hd[u], l};
hd[u] = cnt;
e[++cnt] = (edge){u, hd[v], l};
hd[v] = cnt;
}
void Find_Far(int x, int fa, int dis) {
if (dis > tmp) tT = x, tmp = dis;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
if (y == fa) continue;
Find_Far(y, x, dis + 1);
}
}
const int saxn = 2000005;
struct segment_tree {
int mx[saxn][2], fg[saxn];
inline void pushup(int now) {
mx[now][0] = max(mx[(now << 1)][0], mx[(now << 1 | 1)][0]);
mx[now][1] = max(mx[(now << 1)][1], mx[(now << 1 | 1)][1]);
}
inline void pushdown(int now) {
if (!fg[now]) return;
fg[now] = 0;
fg[(now << 1)] ^= 1;
fg[(now << 1 | 1)] ^= 1;
swap(mx[(now << 1)][0], mx[(now << 1)][1]);
swap(mx[(now << 1 | 1)][0], mx[(now << 1 | 1)][1]);
}
void build(int now, int l, int r, int *valdep, int *valdis, int *valid) {
fg[now] = 0;
if (l == r) {
memset(mx[now], 0, sizeof mx[now]);
mx[now][valdis[valid[l]]] = valdep[valid[l]];
return;
}
build((now << 1), l, ((l + r) >> 1), valdep, valdis, valid);
build((now << 1 | 1), ((l + r) >> 1) + 1, r, valdep, valdis, valid);
pushup(now);
}
void Modify(int now, int l, int r, int L, int R) {
if (r < L || R < l) return;
if (L <= l && r <= R) {
fg[now] ^= 1;
swap(mx[now][0], mx[now][1]);
return;
}
pushdown(now);
Modify((now << 1), l, ((l + r) >> 1), L, R);
Modify((now << 1 | 1), ((l + r) >> 1) + 1, r, L, R);
pushup(now);
}
};
struct Tree_seg {
int tL[maxn], tR[maxn], Rt;
int dep[maxn], ds[maxn], tim, id[maxn];
segment_tree seg;
void Dfs1(int x, int fa) {
tL[x] = ++tim;
id[tim] = x;
for (int i = hd[x]; i; i = e[i].nxt) {
int y = e[i].ed;
if (y == fa) continue;
dep[y] = dep[x] + 1;
ds[y] = ds[x] ^ e[i].len;
Dfs1(y, x);
}
tR[x] = tim;
}
void build() {
dep[Rt] = 0;
ds[Rt] = 0;
tim = 0;
Dfs1(Rt, 0);
seg.build(1, 1, tim, dep, ds, id);
}
int Switch(int x, int y) {
if (tL[x] <= tL[y] && tL[y] <= tR[x]) swap(x, y);
seg.Modify(1, 1, tim, tL[x], tR[x]);
return seg.mx[1][0];
}
} rS, rT;
int main() {
read(n);
for (int i(1); i < n; ++i) {
int u, v, l;
read(u);
read(v);
read(l);
star(u, v, l);
}
Find_Far(1, 0, 0);
tS = tT;
tmp = 0;
Find_Far(tS, 0, 0);
rS.Rt = tS;
rS.build();
rT.Rt = tT;
rT.build();
int m;
read(m);
while (m--) {
int x;
read(x);
x *= 2;
int ans1 = rS.Switch(e[x].ed, e[x ^ 1].ed);
int ans2 = rT.Switch(e[x].ed, e[x ^ 1].ed);
printf("%d\n", max(ans1, ans2));
}
return 0;
}
|
#include <bits/stdc++.h>
const long long MOD = 998244353;
const long long INF = 1e9;
const long long INFLL = 1e18;
using namespace std;
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No\n", "Yes\n"};
string YES[2] = {"NO\n", "YES\n"};
string Possible[2] = {"Impossible\n", "Possible\n"};
string POSSIBLE[2] = {"IMPOSSIBLE\n", "POSSIBLE\n"};
int ok(int x, int n) { return 0 <= x && x < n; }
long long log10(long long x) {
if (x < 10) return 1;
return 1 + log10(x / 10);
}
long long ds(long long x) {
if (x < 10) return x;
return x % 10 + ds(x / 10);
}
double sqr(double x) { return x * x; }
bool inmask(int bit, int mask) { return (mask & (1 << bit)) > 0; }
void Del(vector<int> &v, int pos) {
swap(v[pos], v[v.size() - 1]);
v.pop_back();
}
long long g(vector<long long> &p, int pos) {
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
int g(vector<int> &p, int pos) {
if (ok(pos, p.size())) return p[pos];
if (pos < 0 || p.size() == 0) return 0;
return p.back();
}
long long inq(long long x, long long y) {
if (!y) return 1 % MOD;
long long l = inq(x, y / 2);
if (y % 2) return l * l % MOD * x % MOD;
return l * l % MOD;
}
long long rev(long long x) { return inq(x, MOD - 2); }
int __precomputed_combinatorics = 0;
vector<long long> __fact, __ufact, __rev;
inline void __precompute_combinatorics(int __n) {
if (__precomputed_combinatorics >= __n) return;
__fact.resize(__n);
__ufact.resize(__n);
__rev.resize(__n);
__rev[1] = 1;
for (int i = max(2, __precomputed_combinatorics); i < __n; i++)
__rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = max(1, __precomputed_combinatorics); i < __n; i++)
__fact[i] = __fact[i - 1] * i % MOD,
__ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
__precomputed_combinatorics = __n;
}
long long fact(int x) {
if (__precomputed_combinatorics <= x) __precompute_combinatorics(x + 1);
return __fact[x];
}
long long cnk(int n, int k) {
if (k < 0 || k > n) return 0;
if (__precomputed_combinatorics <= n) __precompute_combinatorics(n + 1);
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
long long inq(long long x, long long y, long long mod) {
if (y == 0) return 1 % mod;
long long l = inq(x, y / 2, mod);
if (y % 2) return l * l % mod * x % mod;
return l * l % mod;
}
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
long long x1, y1;
long long g = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return g;
}
pair<long long, long long> crt(vector<long long> r, vector<long long> m) {
int n = r.size();
for (int i = 0; i < n; i++) r[i] %= m[i];
long long r0 = 0, m0 = 1;
for (int i = 0; i < n; i++) {
long long r1 = r[i], m1 = m[i];
if (m0 < m1) {
swap(m0, m1);
swap(r0, r1);
}
if (m0 % m1 == 0) {
if (r0 % m1 != r1) return {0, 0};
continue;
}
long long x, y;
long long g = gcdex(m0, m1, x, y);
long long u = m1 / g;
if ((r0 - r1) % g != 0) return {0, 0};
long long z = (r1 - r0) / g % u * x % u;
r0 += z * m0;
m0 *= u;
if (r0 < 0) r0 += m0;
}
return {r0, m0};
}
struct dsu {
vector<int> root;
vector<int> sz;
dsu(int _n) {
root.resize(_n);
iota((root).begin(), (root).end(), 0);
sz.resize(_n, 1);
}
dsu() { dsu(0); }
void Reset(int _n) {
root.resize(_n);
sz.resize(_n);
for (int i = 0; i < (int)root.size(); i++) {
root[i] = i;
sz[i] = 1;
}
}
void Reset() { Reset(root.size()); }
int Root(int x) {
if (x == root[x]) return x;
return root[x] = Root(root[x]);
}
void Merge(int v, int u) {
v = Root(v), u = Root(u);
if (v == u) return;
if (sz[v] < sz[u]) {
sz[u] += sz[v];
root[v] = u;
} else {
sz[v] += sz[u];
root[u] = v;
}
}
};
struct dsu_cut {
vector<int> root;
vector<int> sz;
stack<int> cuts;
dsu_cut(int _n) {
root.resize(_n);
iota((root).begin(), (root).end(), 0);
sz.resize(_n, 1);
}
dsu_cut() { dsu_cut(0); }
void Cut() {
if (!cuts.size()) return;
int v = cuts.top();
sz[root[v]] -= sz[v];
root[v] = v;
cuts.pop();
}
void Reset(int _n) {
root.resize(_n);
sz.resize(_n);
for (int i = 0; i < (int)root.size(); i++) {
root[i] = i;
sz[i] = 1;
}
}
void Reset() {
if (cuts.size() < root.size()) {
while (cuts.size()) {
Cut();
}
} else {
Reset(root.size());
}
}
int Root(int x) {
if (x == root[x]) return x;
return Root(root[x]);
}
void Merge(int v, int u) {
v = Root(v), u = Root(u);
if (v == u) return;
if (sz[v] < sz[u]) {
sz[u] += sz[v];
root[v] = u;
cuts.push(v);
} else {
sz[v] += sz[u];
root[u] = v;
cuts.push(u);
}
}
};
void bfs(int v, vector<int> &dist, vector<vector<int>> &graph) {
fill((dist).begin(), (dist).end(), -1);
dist[v] = 0;
vector<int> q = {v};
for (int i = 0; i < (int)q.size(); i++) {
for (auto u : graph[q[i]]) {
if (dist[u] == -1) {
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
vector<int> z_func(string &s) {
vector<int> z(s.size());
z[0] = s.size();
int L = 0, R = 0;
for (int i = 1; i < (int)s.size(); i++) {
z[i] = max(0, min(z[i - L], R - i));
while (i + z[i] < (int)s.size() && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > R) {
R = i + z[i];
L = i;
}
}
return z;
}
vector<int> p_func(string &s) {
vector<int> p(s.size());
for (int i = 1; i < (int)s.size(); i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) j++;
p[i] = j;
}
return p;
}
vector<int> d1_func(string &s) {
vector<int> d1(s.size());
int L = 0, R = -1;
for (int i = 0; i < (int)s.size(); i++) {
int k = 0;
if (i <= R) k = min(R - i + 1, d1[R - i + L]);
while (i + k < (int)s.size() && i - k >= 0 && s[i - k] == s[i + k]) k++;
d1[i] = k--;
if (i + k > R) {
L = i - k;
R = i + k;
}
}
return d1;
}
vector<int> d2_func(string &s) {
vector<int> d2(s.size());
int L = 0, R = -1;
for (int i = 1; i < (int)s.size(); i++) {
int k = 0;
if (i <= R) k = min(R - i + 1, d2[R - i + L + 1]);
while (i + k < (int)s.size() && i - k - 1 >= 0 && s[i - k - 1] == s[i + k])
k++;
d2[i] = k--;
if (i + k > R) {
L = i - k - 1;
R = i + k;
}
}
return d2;
}
template <class T>
void add(int pos, T x, vector<T> &fenw) {
while (pos < (int)fenw.size()) {
fenw[pos] += x;
pos |= (pos + 1);
}
}
template <class T>
T get(int pos, vector<T> &fenw) {
long long res = 0;
while (pos >= 0) {
res += fenw[pos];
pos = (pos & (pos + 1)) - 1;
}
return res;
}
template <class T>
vector<int> different_on_segment_offline(vector<T> a, vector<int> l,
vector<int> r) {
map<T, int> lst;
vector<int> ans(l.size());
vector<vector<int>> ends(a.size());
vector<int> fenw(a.size());
for (int i = 0; i < (int)l.size(); i++) {
ends[r[i]].push_back(i);
}
for (int i = 0; i < (int)a.size(); i++) {
if (lst.find(a[i]) != lst.end()) {
add(lst[a[i]], -1, fenw);
}
lst[a[i]] = i;
add(i, 1, fenw);
for (auto q : ends[i]) {
ans[q] = get(i, fenw) - get(l[q] - 1, fenw);
}
}
return ans;
}
struct dcp_offine {
int n, m;
dsu_cut dcp;
vector<int> ans;
void solve(int l, int r, vector<int> &v, vector<int> &u, vector<int> &t,
vector<int> &L, vector<int> &R) {
if (l >= r) return;
if (l + 1 == r) {
if (t[l] == -1) {
ans[l] = n - dcp.cuts.size();
}
if (t[l] == 1) {
ans[l] = dcp.Root(v[l]) == dcp.Root(u[l]);
}
return;
}
int m = (l + r) / 2;
int ss = dcp.cuts.size();
for (int i = l; i < m; i++) {
if (R[i] >= r) dcp.Merge(v[i], u[i]);
}
solve(m, r, v, u, t, L, R);
while ((int)dcp.cuts.size() > ss) dcp.Cut();
for (int i = r - 1; i >= m; i--) {
if (L[i] < l) dcp.Merge(v[i], u[i]);
}
solve(l, m, v, u, t, L, R);
while ((int)dcp.cuts.size() > ss) dcp.Cut();
}
dcp_offine(int _n, int _m, vector<int> v, vector<int> u, vector<int> t) {
n = _n, m = _m;
dcp.Reset(n);
ans.resize(m, -1);
map<pair<int, int>, int> mm;
vector<int> L(m, INF), R(m, -INF);
for (int i = 0; i < m; i++) {
if (t[i] != 0) continue;
if (v[i] > u[i]) swap(v[i], u[i]);
if (mm.find({v[i], u[i]}) == mm.end()) {
mm[{v[i], u[i]}] = i;
} else {
int t = mm[{v[i], u[i]}];
R[t] = i;
L[i] = t;
mm.erase({v[i], u[i]});
}
}
while (mm.size()) {
t.push_back(0);
ans.push_back(-1);
L.push_back(INF);
R.push_back(-INF);
auto it = mm.begin();
pair<int, int> s = (*it).first;
int t = (*it).second;
R[t] = m;
L[m] = t;
v.push_back(s.first);
u.push_back(s.second);
mm.erase(mm.begin());
m++;
}
solve(0, m, v, u, t, L, R);
}
};
template <class T>
struct sparse_min {
vector<vector<T>> sp;
vector<int> H;
T get(int l, int r) {
int h = H[r - l + 1];
return min(sp[h][l], sp[h][r - (1 << h) + 1]);
}
sparse_min(vector<T> a) {
int n = a.size();
H = vector<int>(n + 1);
for (int i = 3; i < n + 1; i++) {
H[i] = H[i - 1] + (((i - 1) & (i - 2)) == 0);
}
int s = 0;
while ((1 << s) < n) s++;
sp = vector<vector<T>>(s, vector<T>(n));
for (int i = 0; i < n; i++) {
sp[0][i] = a[i];
}
for (int j = 1; j < s; j++) {
for (int i = 0; i + (1 << j) - 1 < n; i++) {
sp[j][i] = get(i, i + (1 << j) - 1);
}
}
}
};
template <class T>
struct sparse_max {
vector<vector<T>> sp;
vector<int> H;
T get(int l, int r) {
int h = H[r - l + 1];
return max(sp[h][l], sp[h][r - (1 << h) + 1]);
}
sparse_max(vector<T> a) {
int n = a.size();
H = vector<int>(n + 1);
for (int i = 3; i < n + 1; i++) {
H[i] = H[i - 1] + (((i - 1) & (i - 2)) == 0);
}
int s = 0;
while ((1 << s) < n) s++;
sp = vector<vector<T>>(s, vector<T>(n));
for (int i = 0; i < n; i++) {
sp[0][i] = a[i];
}
for (int j = 1; j < s; j++) {
for (int i = 0; i + (1 << j) - 1 < n; i++) {
sp[j][i] = get(i, i + (1 << j) - 1);
}
}
}
};
struct graph_scc {
int n;
vector<vector<int>> graph;
vector<vector<int>> inv_graph;
vector<int> fr, to;
vector<int> fn;
vector<int> vis;
vector<int> component;
int col;
void inv_dfs(int v) {
vis[v] = 1;
for (auto id : inv_graph[v]) {
int u = fr[id];
if (!vis[u]) {
inv_dfs(u);
}
}
fn.push_back(v);
}
void dfs(int v) {
component[v] = col;
for (auto id : graph[v]) {
int u = to[id];
if (component[u] == -1) {
dfs(u);
}
}
}
graph_scc(int _n) {
n = _n;
graph = vector<vector<int>>(n);
inv_graph = vector<vector<int>>(n);
}
void add_edge(int v, int u) {
graph[v].push_back(fr.size());
inv_graph[u].push_back(fr.size());
fr.push_back(v);
to.push_back(u);
}
vector<vector<int>> scc() {
vis = vector<int>(n);
component = vector<int>(n, -1);
fn = {};
col = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
inv_dfs(i);
}
}
reverse(fn.begin(), fn.end());
for (auto i : fn) {
if (component[i] == -1) {
dfs(i);
col++;
}
}
vector<vector<int>> res(col);
for (int i = 0; i < n; i++) {
res[component[i]].push_back(i);
}
return res;
}
};
struct graph_bridges {
int n;
vector<vector<int>> graph;
vector<int> v;
vector<int> u;
vector<int> isbridge;
vector<int> in, out, up;
vector<int> color;
vector<int> par;
int T;
void dfs(int V, int P, int edge_in) {
par[V] = P;
in[V] = up[V] = T++;
for (auto id : graph[V]) {
int t = v[id] + u[id] - V;
if (in[t] == -1) {
dfs(t, V, id);
up[V] = min(up[V], up[t]);
} else if (id != edge_in) {
up[V] = min(up[V], in[t]);
}
}
out[V] = T++;
}
void dfs_dlc(int V, int P) {
color[V] = T;
for (auto id : graph[V]) {
int t = v[id] + u[id] - V;
if (!isbridge[id] && color[t] == -1) {
dfs_dlc(t, V);
}
}
}
graph_bridges(int _n) {
n = _n;
graph = vector<vector<int>>(n);
}
void add_edge(int V, int U) {
graph[V].push_back(v.size());
graph[U].push_back(v.size());
v.push_back(V);
u.push_back(U);
}
void mark_bridges() {
in = vector<int>(n, -1);
out = vector<int>(n, -1);
up = vector<int>(n, -1);
par = vector<int>(n, -1);
isbridge = vector<int>(v.size(), 0);
T = 0;
for (int i = 0; i < n; i++) {
if (in[i] == -1) {
dfs(i, -1, -1);
}
}
int m = v.size();
for (int i = 0; i < m; i++) {
if (par[u[i]] == v[i] && up[u[i]] == in[u[i]]) {
isbridge[i] = 1;
}
if (par[v[i]] == u[i] && up[v[i]] == in[v[i]]) {
isbridge[i] = 1;
}
}
}
vector<vector<int>> dlc() {
mark_bridges();
color = vector<int>(n, -1);
T = 0;
for (int i = 0; i < n; i++) {
if (color[i] == -1) {
dfs_dlc(i, -1);
T++;
}
}
vector<vector<int>> res(T);
for (int i = 0; i < n; i++) {
res[color[i]].push_back(i);
}
return res;
}
};
struct graph_AP {
int n;
vector<vector<int>> graph;
vector<int> v;
vector<int> u;
vector<int> isAP;
vector<int> in, out, up;
vector<int> par;
vector<int> color;
vector<int> vis;
int T, rd;
int maxColor;
void dfs(int V, int P) {
par[V] = P;
in[V] = up[V] = T++;
for (auto id : graph[V]) {
int t = v[id] + u[id] - V;
if (in[t] == -1) {
if (P == -1) rd++;
dfs(t, V);
up[V] = min(up[V], up[t]);
} else if (t != P) {
up[V] = min(up[V], in[t]);
}
}
out[V] = T++;
}
void dfs_blocks(int V, int P, int c) {
vis[V] = 1;
for (auto id : graph[V]) {
int t = v[id] + u[id] - V;
if (t == P) {
continue;
}
if (!vis[t]) {
if (up[t] >= in[V]) {
maxColor++;
color[id] = maxColor - 1;
dfs_blocks(t, V, maxColor - 1);
} else {
color[id] = c;
dfs_blocks(t, V, c);
}
} else {
if (in[t] < in[V]) {
color[id] = c;
}
}
}
}
graph_AP(int _n) {
n = _n;
graph = vector<vector<int>>(n);
}
void add_edge(int V, int U) {
graph[V].push_back(v.size());
graph[U].push_back(v.size());
v.push_back(V);
u.push_back(U);
}
void mark_AP() {
in = vector<int>(n, -1);
out = vector<int>(n, -1);
up = vector<int>(n, -1);
par = vector<int>(n, -1);
isAP = vector<int>(n, 0);
T = 0;
for (int i = 0; i < n; i++) {
if (in[i] == -1) {
rd = 0;
dfs(i, -1);
if (rd > 1)
isAP[i] = 1;
else
isAP[i] = -1;
}
}
for (int i = 0; i < n; i++) {
if (isAP[i] == 0) {
for (auto id : graph[i]) {
int t = v[id] + u[id] - i;
if (par[t] == i && in[i] <= up[t]) isAP[i] = 1;
}
} else {
if (isAP[i] == -1) {
isAP[i] = 0;
}
}
}
}
vector<vector<int>> blocks() {
mark_AP();
color = vector<int>(v.size(), -1);
vis = vector<int>(n, 0);
maxColor = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs_blocks(i, -1, maxColor);
maxColor++;
}
}
vector<vector<int>> res = vector<vector<int>>(maxColor);
for (int i = 0; i < (int)v.size(); i++) {
res[color[i]].push_back(i);
}
vector<vector<int>> res2;
for (int i = 0; i < (int)res.size(); i++) {
if (res[i].size()) {
res2.push_back(res[i]);
}
}
return res2;
}
};
struct Tree {
struct Node {
int mx0, mx1;
int push;
};
vector<Node> tree;
vector<int> a;
int sz;
void Build(int L, int R, int V) {
if (L + 1 == R) {
tree[V].mx0 = a[L];
return;
}
int M = (L + R) / 2;
Build(L, M, 2 * V + 1);
Build(M, R, 2 * V + 2);
tree[V].mx0 = max(tree[2 * V + 1].mx0, tree[2 * V + 2].mx0);
tree[V].mx1 = max(tree[2 * V + 1].mx1, tree[2 * V + 2].mx1);
}
void Push(int V) {
if (tree[V].push) {
tree[2 * V + 1].push ^= 1;
swap(tree[2 * V + 1].mx0, tree[2 * V + 1].mx1);
tree[2 * V + 2].push ^= 1;
swap(tree[2 * V + 2].mx0, tree[2 * V + 2].mx1);
tree[V].push = 0;
}
}
Tree(vector<int> _a) {
a = _a;
sz = a.size();
tree.resize(4 * sz);
Build(0, sz, 0);
}
int Get() { return tree[0].mx0; }
void Invert(int l, int r, int L, int R, int V) {
if (r <= L || R <= l) return;
if (l <= L && R <= r) {
tree[V].push ^= 1;
swap(tree[V].mx0, tree[V].mx1);
return;
}
int M = (L + R) / 2;
Push(V);
Invert(l, r, L, M, 2 * V + 1);
Invert(l, r, M, R, 2 * V + 2);
tree[V].mx0 = max(tree[2 * V + 1].mx0, tree[2 * V + 2].mx0);
tree[V].mx1 = max(tree[2 * V + 1].mx1, tree[2 * V + 2].mx1);
}
void Invert(int l, int r) { Invert(l, r + 1, 0, sz, 0); }
};
void bfs(int v, vector<int> &dist, vector<vector<pair<int, int>>> &g) {
vector<int> q = {v};
fill((dist).begin(), (dist).end(), -1);
dist[v] = 0;
for (int i = 0; i < q.size(); i++) {
int v = q[i];
for (auto e : g[v]) {
int u = e.first;
if (dist[u] == -1) {
dist[u] = dist[v] + 1;
q.push_back(u);
}
}
}
}
void bfs01(int v, vector<int> &dist, vector<vector<pair<int, int>>> &g) {
vector<int> q = {v};
fill((dist).begin(), (dist).end(), -1);
dist[v] = 0;
for (int i = 0; i < q.size(); i++) {
int v = q[i];
for (auto e : g[v]) {
int u = e.first;
if (dist[u] == -1) {
dist[u] = dist[v] ^ e.second;
q.push_back(u);
}
}
}
}
void dfs(int v, int p, vector<vector<pair<int, int>>> &g, vector<int> &L,
vector<int> &R, vector<int> &C, vector<int> &D, int &T, int c, int d) {
C[v] = c;
D[T] = d;
L[v] = R[v] = T++;
for (auto e : g[v])
if (e.first != p) {
int u = e.first;
dfs(u, v, g, L, R, C, D, T, c ^ e.second, d + 1);
R[v] = R[u];
}
}
signed main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<pair<int, int>>> g(n);
vector<pair<int, int>> s;
for (int(i) = 0; (i) != (n - 1); (i)++) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
g[a].push_back({b, c});
g[b].push_back({a, c});
s.push_back({a, b});
}
vector<int> d2(n), d0(n), d1(n);
bfs(0, d2, g);
int x = 0, y = 0;
for (int(i) = 0; (i) != (n); (i)++)
if (d2[i] > d2[x]) x = i;
bfs(x, d0, g);
for (int(i) = 0; (i) != (n); (i)++)
if (d0[i] > d0[y]) y = i;
bfs(y, d1, g);
vector<int> L0(n), R0(n), C0(n), D0(n);
vector<int> L1(n), R1(n), C1(n), D1(n);
int t = 0;
dfs(x, x, g, L0, R0, C0, D0, t, 0, 0);
t = 0;
dfs(y, y, g, L1, R1, C1, D1, t, 0, 0);
Tree T0(D0), T1(D1);
for (int(i) = 0; (i) != (n); (i)++) {
if (C0[i]) {
T0.Invert(L0[i], R0[i]);
for (auto e : g[i]) {
int u = e.first;
if (d0[u] == d0[i] + 1) T0.Invert(L0[u], R0[u]);
}
}
if (C1[i]) {
T1.Invert(L1[i], R1[i]);
for (auto e : g[i]) {
int u = e.first;
if (d1[u] == d1[i] + 1) T1.Invert(L1[u], R1[u]);
}
}
}
int q;
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int f = s[id].first, t = s[id].second;
{
if (d0[f] + 1 == d0[t])
T0.Invert(L0[t], R0[t]);
else
T0.Invert(L0[f], R0[f]);
}
{
if (d1[f] + 1 == d1[t])
T1.Invert(L1[t], R1[t]);
else
T1.Invert(L1[f], R1[f]);
}
cout << max(T0.Get(), T1.Get()) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int t, v, next;
Edge() {}
Edge(int a, int b, int c) : t(a), v(b), next(c) {}
};
Edge e[1000005];
int head[500005], bel[500005];
pair<int, int> a[500005];
namespace Tree {
int dfn[500005], dfn1[500005], ed1[500005], dep[500005];
int minn[1000005][20], dfs_cnt, sz;
bool f[500005];
void dfs(int x, int fa) {
dfn[x] = ++dfs_cnt;
minn[dfs_cnt][0] = x;
dfn1[x] = ++sz;
a[sz] = pair<int, int>(x, f[x]);
for (int i = head[x]; i; i = e[i].next)
if (e[i].t != fa) {
int u = e[i].t;
bel[(i + 1) >> 1] = u;
f[u] = f[x] ^ e[i].v;
dep[u] = dep[x] + 1;
dfs(u, x);
minn[++dfs_cnt][0] = x;
}
ed1[x] = sz;
}
int cmp(int x, int y) { return (dep[x] < dep[y]) ? x : y; }
int bit[1000005];
void build(int n) {
dfs(1, 0);
bit[0] = -1;
for (int i = 1; i <= dfs_cnt; i++) bit[i] = bit[i >> 1] + 1;
for (int i = 1; i < 20; i++)
for (int j = 1; j <= dfs_cnt - (1 << i) + 1; j++)
minn[j][i] = cmp(minn[j][i - 1], minn[j + (1 << (i - 1))][i - 1]);
}
int lca(int x, int y) {
if (dfn[x] > dfn[y]) swap(x, y);
int k = bit[dfn[y] - dfn[x] + 1];
return cmp(minn[dfn[x]][k], minn[dfn[y] - (1 << k) + 1][k]);
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
} // namespace Tree
struct Data {
int x0, y0, x1, y1, d0, d1;
Data() {}
Data(int a, int b, int c, int d, int e, int f)
: x0(a), y0(b), x1(c), y1(d), d0(e), d1(f) {}
};
Data merge(Data x, Data y) {
Data t;
int v;
if (x.d0 > y.d0) {
t.x0 = x.x0;
t.y0 = x.y0;
t.d0 = x.d0;
} else {
t.x0 = y.x0;
t.y0 = y.y0;
t.d0 = y.d0;
}
if (x.x0 != -1 && y.x0 != -1 && (v = Tree::dis(x.x0, y.x0)) > t.d0) {
t.x0 = x.x0;
t.y0 = y.x0;
t.d0 = v;
}
if (x.y0 != -1 && y.x0 != -1 && (v = Tree::dis(x.y0, y.x0)) > t.d0) {
t.x0 = x.y0;
t.y0 = y.x0;
t.d0 = v;
}
if (x.x0 != -1 && y.y0 != -1 && (v = Tree::dis(x.x0, y.y0)) > t.d0) {
t.x0 = x.x0;
t.y0 = y.y0;
t.d0 = v;
}
if (x.y0 != -1 && y.y0 != -1 && (v = Tree::dis(x.y0, y.y0)) > t.d0) {
t.x0 = x.y0;
t.y0 = y.y0;
t.d0 = v;
}
if (x.d1 > y.d1) {
t.x1 = x.x1;
t.y1 = x.y1;
t.d1 = x.d1;
} else {
t.x1 = y.x1;
t.y1 = y.y1;
t.d1 = y.d1;
}
if (x.x1 != -1 && y.x1 != -1 && (v = Tree::dis(x.x1, y.x1)) > t.d1) {
t.x1 = x.x1;
t.y1 = y.x1;
t.d1 = v;
}
if (x.y1 != -1 && y.x1 != -1 && (v = Tree::dis(x.y1, y.x1)) > t.d1) {
t.x1 = x.y1;
t.y1 = y.x1;
t.d1 = v;
}
if (x.x1 != -1 && y.y1 != -1 && (v = Tree::dis(x.x1, y.y1)) > t.d1) {
t.x1 = x.x1;
t.y1 = y.y1;
t.d1 = v;
}
if (x.y1 != -1 && y.y1 != -1 && (v = Tree::dis(x.y1, y.y1)) > t.d1) {
t.x1 = x.y1;
t.y1 = y.y1;
t.d1 = v;
}
return t;
}
namespace SGT {
Data maxn[2000000];
bool rev[2000000];
inline void pushdown(int o) {
if (rev[o]) {
rev[o * 2] ^= 1;
rev[o * 2 + 1] ^= 1;
swap(maxn[o * 2].x0, maxn[o * 2].x1);
swap(maxn[o * 2].y0, maxn[o * 2].y1);
swap(maxn[o * 2].d0, maxn[o * 2].d1);
swap(maxn[o * 2 + 1].x0, maxn[o * 2 + 1].x1);
swap(maxn[o * 2 + 1].y0, maxn[o * 2 + 1].y1);
swap(maxn[o * 2 + 1].d0, maxn[o * 2 + 1].d1);
rev[o] = 0;
}
}
void build(int l, int r, int o) {
if (l == r) {
if (a[l].second == 0)
maxn[o] = Data(a[l].first, a[l].first, -1, -1, 0, -1);
else
maxn[o] = Data(-1, -1, a[l].first, a[l].first, -1, 0);
} else {
int m = ((l + r) >> 1);
build(l, m, o * 2);
build(m + 1, r, o * 2 + 1);
maxn[o] = merge(maxn[o * 2], maxn[o * 2 + 1]);
}
}
void update(int l, int r, int o, int lx, int rx) {
if (l >= lx && r <= rx) {
rev[o] ^= 1;
swap(maxn[o].x0, maxn[o].x1);
swap(maxn[o].y0, maxn[o].y1);
swap(maxn[o].d0, maxn[o].d1);
} else {
pushdown(o);
int m = ((l + r) >> 1);
if (m >= lx) update(l, m, o * 2, lx, rx);
if (m < rx) update(m + 1, r, o * 2 + 1, lx, rx);
maxn[o] = merge(maxn[o * 2], maxn[o * 2 + 1]);
}
}
int query() { return max(maxn[1].d0, maxn[1].d1); }
} // namespace SGT
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
e[2 * i - 1] = Edge(y, z, head[x]);
head[x] = 2 * i - 1;
e[2 * i] = Edge(x, z, head[y]);
head[y] = 2 * i;
}
Tree::build(n);
SGT::build(1, n, 1);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
SGT::update(1, n, 1, Tree::dfn1[bel[x]], Tree::ed1[bel[x]]);
printf("%d\n", SGT::query());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
pair<int, int> edges[maxn];
vector<pair<int, int>> g[maxn];
int n, m;
int opt[maxn];
int dep[maxn];
int dfs(int o, int p) {
dep[o] = dep[p] + 1;
int res = o;
for (auto u : g[o])
if (u.first != p) {
int tmp = dfs(u.first, o);
if (dep[res] < dep[tmp]) res = tmp;
}
return res;
}
int dfn[maxn], efn[maxn], rdfn[maxn], col[maxn], tot;
void dfs1(int o, int p, int s) {
dfn[o] = ++tot;
rdfn[tot] = o;
col[o] = s;
for (auto u : g[o])
if (u.first != p) {
dfs1(u.first, o, s ^ u.second);
}
efn[o] = tot;
}
int seg[maxn << 2][2];
int flip[maxn << 2];
int get_val(int v, int d) { return seg[v][d ^ flip[v]]; }
void pushdown(int v) {
if (flip[v]) {
swap(seg[v][0], seg[v][1]);
flip[v << 1] ^= 1;
flip[v << 1 | 1] ^= 1;
flip[v] = 0;
}
}
void pushup(int v) {
seg[v][0] = max(get_val(v << 1, 0), get_val(v << 1 | 1, 0));
seg[v][1] = max(get_val(v << 1, 1), get_val(v << 1 | 1, 1));
}
void build(int l, int r, int v) {
seg[v][0] = seg[v][1] = 0;
flip[v] = 0;
if (l == r) {
seg[v][col[rdfn[l]]] = dep[rdfn[l]];
return;
}
int mid = (l + r) >> 1;
build(l, mid, v << 1);
build(mid + 1, r, v << 1 | 1);
pushup(v);
}
void update(int l, int r, int v, int ql, int qr) {
if (ql <= l && r <= qr) {
flip[v] ^= 1;
return;
}
pushdown(v);
int mid = (l + r) >> 1;
if (ql <= mid) update(l, mid, v << 1, ql, qr);
if (qr > mid) update(mid + 1, r, v << 1 | 1, ql, qr);
pushup(v);
}
void solve(int root, int* ans) {
tot = 0;
dfs(root, 0);
dfs1(root, 0, 0);
build(1, n, 1);
for (int i = 1; i <= m; ++i) {
int x = opt[i];
int l = max(dfn[edges[x].first], dfn[edges[x].second]);
int r = min(efn[edges[x].first], efn[edges[x].second]);
update(1, n, 1, l, r);
ans[i] = get_val(1, 0);
}
}
int ans1[maxn], ans2[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = make_pair(a, b);
g[a].push_back({b, c});
g[b].push_back({a, c});
}
int root1 = dfs(1, 0);
int root2 = dfs(root1, 0);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d", &opt[i]);
solve(root1, ans1);
solve(root2, ans2);
for (int i = 1; i <= m; ++i) printf("%d\n", max(ans1[i], ans2[i]) - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int x = 0, fl = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch - '0');
return x * fl;
}
const int NN = 500000 + 17;
void open() {
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
}
void OK() { printf("OK\n"); }
int n, q;
int c[NN];
int ans[NN];
vector<pair<int, int> > e[NN];
pair<int, int> ep[NN];
struct Tree {
int fa[NN], dep[NN], d[NN], ll[NN], rr[NN], rev[NN];
int tim;
struct node {
int w[2];
} t[NN << 2];
int tag[NN << 2];
node merge(node a, node b) {
node c;
c.w[0] = max(a.w[0], b.w[0]);
c.w[1] = max(a.w[1], b.w[1]);
return c;
}
void set_tag(int rt) {
tag[rt] ^= 1;
swap(t[rt].w[0], t[rt].w[1]);
}
void psd(int rt) {
if (tag[rt]) {
set_tag(rt << 1);
set_tag(rt << 1 | 1);
tag[rt] = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].w[d[rev[l]]] = dep[rev[l]];
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void flip(int rt, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
set_tag(rt);
return;
}
psd(rt);
int mid = (l + r) >> 1;
if (ll <= mid) flip(rt << 1, l, mid, ll, rr);
if (rr > mid) flip(rt << 1 | 1, mid + 1, r, ll, rr);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
}
void dfs(int x, int ff) {
fa[x] = ff;
dep[x] = dep[ff] + 1;
ll[x] = ++tim;
rev[tim] = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first, z = e[x][i].second;
if (y != ff) {
d[y] = (d[x] + z) & 1;
dfs(y, x);
}
}
rr[x] = tim;
}
void work(int root) {
dfs(root, 0);
build(1, 1, n);
for (int i = 1; i <= q; i++) {
int x = ep[c[i]].first, y = ep[c[i]].second;
if (fa[x] == y) swap(x, y);
flip(1, 1, n, ll[y], rr[y]);
ans[i] = max(ans[i], t[1].w[0]);
}
}
} tx, ty;
int mx, pos, px, py;
void dfs(int x, int dep, int ff) {
if (dep > mx) mx = dep, pos = x;
for (int i = 0, top = e[x].size(); i < top; i++) {
int y = e[x][i].first;
if (y != ff) dfs(y, dep + 1, x);
}
}
void get_path() {
dfs(1, 0, 0);
px = pos;
mx = -1;
dfs(px, 0, 0);
py = pos;
tx.work(px);
ty.work(py);
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read(), z = read();
e[x].push_back(make_pair(y, z));
e[y].push_back(make_pair(x, z));
ep[i] = make_pair(x, y);
}
q = read();
for (int i = 1; i <= q; i++) c[i] = read();
get_path();
for (int i = 1; i <= q; i++) {
ans[i]--;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
using namespace std;
template <typename T>
void uin(T &a, T b) {
if (b < a) {
a = b;
}
}
template <typename T>
void uax(T &a, T b) {
if (b > a) {
a = b;
}
}
const int N = 500 * 1000 + 228;
int left1[N], right1[N];
int left2[N], right2[N];
int h1[N], h2[N];
int parity1[N], parity2[N];
int inv1[N], inv2[N];
struct ST {
struct node {
int mx0;
int mx1;
int mod;
int l, r;
node() {
mx0 = mx1 = 0;
l = r = mod = 0;
}
};
vector<node> d;
bool kekos;
void recalc(int v) {
pair<int, int> l_mx = gets(v << 1);
pair<int, int> r_mx = gets(v << 1 | 1);
d[v].mx0 = max(l_mx.first, r_mx.first);
d[v].mx1 = max(l_mx.second, r_mx.second);
};
void build(int l, int r, int v = 1) {
d[v].l = l;
d[v].r = r;
if (l == r) {
int i = l;
if (kekos == 0) {
if (parity1[inv1[l]] == 0) {
d[v].mx0 = h1[inv1[l]];
} else {
d[v].mx1 = h1[inv1[l]];
}
} else {
if (parity2[inv2[l]] == 0) {
d[v].mx0 = h2[inv2[l]];
} else {
d[v].mx1 = h2[inv2[l]];
}
}
} else {
int m = (l + r) >> 1;
build(l, m, v << 1);
build(m + 1, r, v << 1 | 1);
recalc(v);
}
}
ST() { d.clear(); }
ST(int _n, bool kekoz) {
kekos = kekoz;
int ss = 1;
while (ss < _n) ss <<= 1;
ss <<= 1;
d.resize(ss + 1, node());
build(1, _n);
}
pair<int, int> gets(int v) {
if (d[v].mod == 0) {
return {d[v].mx0, d[v].mx1};
}
return {d[v].mx1, d[v].mx0};
}
void push(int v) {
d[v << 1].mod ^= d[v].mod;
d[v << 1 | 1].mod ^= d[v].mod;
d[v].mod = 0;
recalc(v);
}
void inverse(int l, int r, int v = 1) {
if (l > r || d[v].l > r || d[v].r < l) return;
if (l <= d[v].l && d[v].r <= r) {
d[v].mod ^= 1;
} else {
push(v);
inverse(l, r, v << 1);
inverse(l, r, v << 1 | 1);
recalc(v);
}
}
int get0(int l, int r, int v = 1) { return gets(1).first; }
int get1(int l, int r, int v = 1) { return gets(1).second; }
};
int n, m;
vector<pair<int, int> > g[N];
int id[N];
int ans[N];
int dist[N];
void dfs(int v, int par = -1) {
if (par == -1)
dist[v] = 0;
else
dist[v] = dist[par] + 1;
for (pair<int, int> go : g[v]) {
int to = go.first;
int w = go.second;
if (to != par) {
dfs(to, v);
}
}
}
int A = 0, B = 0;
int timer = 0;
void dfs1(int v, int parity = 0, int par = -1) {
left1[v] = ++timer;
if (par == -1)
h1[v] = 0;
else
h1[v] = h1[par] + 1;
parity1[v] = parity;
for (pair<int, int> go : g[v]) {
int to = go.first;
int w = go.second;
if (to != par) {
dfs1(to, parity ^ w, v);
}
}
right1[v] = timer;
}
void dfs2(int v, int parity = 0, int par = -1) {
left2[v] = ++timer;
if (par == -1)
h2[v] = 0;
else
h2[v] = h2[par] + 1;
parity2[v] = parity;
for (pair<int, int> go : g[v]) {
int to = go.first;
int w = go.second;
if (to != par) {
dfs2(to, parity ^ w, v);
}
}
right2[v] = timer;
}
vector<pair<int, int> > edges;
void proceed() {
dfs(1);
A = 0;
for (int i = 1; i <= n; ++i) {
if (dist[i] > dist[A]) A = i;
}
dfs(A);
B = 0;
for (int i = 1; i <= n; ++i) {
if (dist[i] > dist[B]) B = i;
}
dfs1(A);
timer = 0;
dfs2(B);
for (int v = 1; v <= n; ++v) {
inv1[left1[v]] = v;
inv2[left2[v]] = v;
}
ST st1 = ST(n, 0);
ST st2 = ST(n, 1);
for (int i = 0; i < m; ++i) {
pair<int, int> e = edges[id[i] - 1];
int u = e.first, v = e.second;
if (h1[u] > h1[v]) swap(u, v);
st1.inverse(left1[v], right1[v]);
if (h2[u] > h2[v]) swap(u, v);
st2.inverse(left2[v], right2[v]);
ans[i] = max(st1.get0(1, n), st2.get0(1, n));
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v, t;
cin >> u >> v >> t;
g[u].emplace_back(v, t);
g[v].emplace_back(u, t);
edges.emplace_back(u, v);
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> id[i];
}
proceed();
for (int i = 0; i < m; ++i) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000001][2], ls[500001], A[500001], n, i, j, k, l, len, x, y, Q, mx, mx2,
s1, s2, ans;
void swap(int &x, int &y) {
int z = x;
x = y;
y = z;
}
struct tree {
int tr[2000001][2], bg[500001], ed[500001], fa[500001], tot;
bool Tr[2000001];
void down(int t, int len) {
if (Tr[t]) {
if (len > 1) Tr[t * 2] ^= 1, Tr[t * 2 + 1] ^= 1;
swap(tr[t][0], tr[t][1]);
Tr[t] = 0;
}
}
void up(int t) {
tr[t][0] =
(tr[t * 2][0] > tr[t * 2 + 1][0] ? tr[t * 2][0] : tr[t * 2 + 1][0]);
tr[t][1] =
(tr[t * 2][1] > tr[t * 2 + 1][1] ? tr[t * 2][1] : tr[t * 2 + 1][1]);
}
void change1(int t, int l, int r, int x, int s) {
int mid = (l + r) / 2;
if (l == r) {
tr[t][0] = s;
return;
}
if (x <= mid)
change1(t * 2, l, mid, x, s);
else
change1(t * 2 + 1, mid + 1, r, x, s);
up(t);
}
void change2(int t, int l, int r, int x, int y) {
int mid = (l + r) / 2;
down(t, r - l + 1);
if (x <= l && r <= y) {
Tr[t] = 1;
down(t, r - l + 1);
return;
}
down(t * 2, mid - l + 1), down(t * 2 + 1, r - mid);
if (x <= mid) change2(t * 2, l, mid, x, y);
if (mid < y) change2(t * 2 + 1, mid + 1, r, x, y);
up(t);
}
void dfs(int Fa, int t, int len) {
int i;
bg[t] = ++tot, change1(1, 1, n, tot, len), fa[t] = Fa;
for (i = ls[t]; i; i = a[i][1])
if (a[i][0] != Fa) dfs(t, a[i][0], len + 1);
ed[t] = tot;
}
} t1, t2;
void New(int x, int y) {
++len;
a[len][0] = y;
a[len][1] = ls[x];
ls[x] = len;
}
void dfs(int Fa, int t, int len) {
int i;
if (len > mx) mx = len, mx2 = t;
for (i = ls[t]; i; i = a[i][1])
if (a[i][0] != Fa) dfs(t, a[i][0], len + 1);
}
void Change(int t) {
int x = a[t * 2 - 1][0], y = a[t * 2][0];
if (t1.fa[y] == x) swap(x, y);
t1.change2(1, 1, n, t1.bg[x], t1.ed[x]);
if (t2.fa[y] == x) swap(x, y);
t2.change2(1, 1, n, t2.bg[x], t2.ed[x]);
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n - 1; i++)
scanf("%d%d%d", &x, &y, &A[i]), New(x, y), New(y, x);
mx = -1;
dfs(0, 1, 0);
s1 = mx2, mx = -1;
dfs(0, s1, 0);
s2 = mx2;
t1.dfs(0, s1, 0), t2.dfs(0, s2, 0);
for (i = 1; i <= n - 1; i++)
if (A[i]) Change(i);
scanf("%d", &Q);
for (; Q; --Q) {
scanf("%d", &i), Change(i);
ans = (t1.tr[1][0] > t2.tr[1][0] ? t1.tr[1][0] : t2.tr[1][0]);
printf("%d\n", ans);
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500005];
struct EDGE {
int to;
EDGE *las;
int id;
};
EDGE e[500005 * 2];
int ne;
EDGE *last[500005];
void link(int u, int v, int id) {
e[ne] = {v, last[u], id};
last[u] = e + ne++;
}
struct Graph {
int rt;
int dep[500005], val[500005], in[500005], out[500005], re[500005], cnt;
int rel[500005];
int mx[500005 * 4][2], tag[500005 * 4];
void predfs(int x, int fa) {
in[x] = ++cnt;
re[cnt] = x;
for (EDGE *ei = last[x]; ei; ei = ei->las)
if (ei->to != fa) {
rel[ei->id] = ei->to;
dep[ei->to] = dep[x] + 1;
val[ei->to] = val[x] ^ a[ei->id];
predfs(ei->to, x);
}
out[x] = cnt;
}
void pd(int k) {
if (tag[k]) {
swap(mx[k << 1][0], mx[k << 1][1]);
swap(mx[k << 1 | 1][0], mx[k << 1 | 1][1]);
tag[k << 1] ^= 1, tag[k << 1 | 1] ^= 1;
tag[k] = 0;
}
}
void upd(int k) {
mx[k][0] = max(mx[k << 1][0], mx[k << 1 | 1][0]);
mx[k][1] = max(mx[k << 1][1], mx[k << 1 | 1][1]);
}
void build(int k, int l, int r) {
if (l == r) {
mx[k][val[re[l]] & 1] = dep[re[l]];
mx[k][val[re[l]] & 1 ^ 1] = -1;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
upd(k);
}
void modify(int k, int l, int r, int st, int en) {
if (st <= l && r <= en) {
swap(mx[k][0], mx[k][1]);
tag[k] ^= 1;
return;
}
pd(k);
int mid = l + r >> 1;
if (st <= mid) modify(k << 1, l, mid, st, en);
if (mid < en) modify(k << 1 | 1, mid + 1, r, st, en);
upd(k);
}
int query() { return mx[1][0]; }
void init() {
predfs(rt, 0);
build(1, 1, n);
}
} S, T;
queue<int> q;
void find() {
static int dis[500005];
q.push(1);
dis[1] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (EDGE *ei = last[x]; ei; ei = ei->las)
if (!dis[ei->to]) dis[ei->to] = dis[x] + 1, q.push(ei->to);
}
S.rt = 1;
for (int i = 2; i <= n; ++i)
if (dis[i] > dis[S.rt]) S.rt = i;
memset(dis, 0, sizeof dis);
q.push(S.rt);
dis[S.rt] = 1;
while (!q.empty()) {
int x = q.front();
q.pop();
for (EDGE *ei = last[x]; ei; ei = ei->las)
if (!dis[ei->to]) dis[ei->to] = dis[x] + 1, q.push(ei->to);
}
T.rt = 1;
for (int i = 2; i <= n; ++i)
if (dis[i] > dis[T.rt]) T.rt = i;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d%d", &u, &v, &a[i]);
link(u, v, i);
link(v, u, i);
}
find();
S.init();
T.init();
int Q;
scanf("%d", &Q);
while (Q--) {
int x;
scanf("%d", &x);
S.modify(1, 1, n, S.in[S.rel[x]], S.out[S.rel[x]]);
T.modify(1, 1, n, T.in[T.rel[x]], T.out[T.rel[x]]);
printf("%d\n", max(S.query(), T.query()));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
node* tmp = v;
while (!tmp->is_root()) tmp = tmp->p;
swap(v->parent, tmp->parent);
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
virtual void update() {}
virtual void push() {}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
update();
}
};
template <typename pnode>
struct splay_tree_lct : splay_tree<pnode> {
using splay_tree<pnode>::ch;
bool rev;
splay_tree_lct() : splay_tree<pnode>() { rev = 0; }
virtual void update() override {}
virtual void push() override {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
virtual void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() override {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() override {}
static void push_back(splay_tree_vchs*& u, const pnode& key) {
if (!u) {
u = new splay_tree_vchs(key);
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = new splay_tree_vchs(key);
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
}
static void erase(splay_tree_vchs*& u, splay_tree_vchs* v) {
v->splay();
if (!v->ch[0]) {
u = v->ch[1];
} else if (!v->ch[1]) {
u = v->ch[0];
} else {
u = v->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = v->ch[1];
v->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
delete v;
}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
splay_tree_vchs<node*>*root, *parent;
node() : splay_tree_lct() {
root = parent = NULL;
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() override {
splay_tree::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void update_vsub(node* v, bool add) {
if (add) {
splay_tree_vchs<node*>::push_back(root, v);
v->parent = root;
} else {
splay_tree_vchs<node*>::erase(root, v->parent);
v->parent = NULL;
}
}
void push() override { splay_tree_lct::push(); }
void reverse() override {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int mod = 998244353;
void reduce(int &a) { a += a >> 31 & mod; }
int Mod(int x) { return x >= mod ? x - mod : x; }
long long read() {
long long x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ 48);
return x * f;
}
void print(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const int N = 500010, M = N;
int n, m, q[N], c[N], u[N], v[N], w[N], ans[N];
;
struct edge {
int nxt, to, w;
} e[M << 1];
int head[N], ecnt = 1;
void add(int u, int v, int w = 0) {
e[++ecnt] = {head[u], v, w}, head[u] = ecnt;
}
void add_edge(int u, int v, int w = 0) { add(u, v, w), add(v, u, w * 1); };
int res, dep[N], dfn[N], fa[N], id[N], cnt, siz[N];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
if (dep[u] > dep[res]) res = u;
for (int i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].to) != fa) dfs(v, u);
}
void DFS(int u, int f) {
id[dfn[u] = ++cnt] = u, siz[u] = 1;
for (int i = head[u], v; i; i = e[i].nxt)
if ((v = e[i].to) != f)
fa[v] = u, dep[v] = dep[u] + 1, c[e[i].w] = v, DFS(v, u),
siz[u] += siz[v];
}
struct tree {
int l, r, mx0, mx1, rev;
} t[N << 2];
void push(int now) { t[now].rev ^= 1, swap(t[now].mx0, t[now].mx1); }
void pushdown(int now) {
if (t[now].rev) push(now << 1), push(now << 1 | 1), t[now].rev = 0;
}
void pushup(int now) {
t[now].mx0 = max(t[now << 1].mx0, t[now << 1 | 1].mx0);
t[now].mx1 = max(t[now << 1].mx1, t[now << 1 | 1].mx1);
}
void build(int now, int l, int r) {
t[now].l = l, t[now].r = r, t[now].rev = 0;
if (l == r) {
t[now].mx0 = dep[id[l]];
t[now].mx1 = 0;
return;
}
int mid = l + r >> 1;
build(now << 1, l, mid), build(now << 1 | 1, mid + 1, r);
pushup(now);
}
void update(int now, int l, int r) {
if (t[now].l == l && t[now].r == r) {
push(now);
return;
}
int mid = t[now << 1].r;
pushdown(now);
if (r <= mid)
update(now << 1, l, r);
else if (l > mid)
update(now << 1 | 1, l, r);
else
update(now << 1, l, mid), update(now << 1 | 1, mid + 1, r);
pushup(now);
}
void solve(int root) {
for (int i = 0; i <= n; i++) dep[i] = 0;
cnt = 0;
DFS(root, 0);
build(1, 1, n);
for (int i = 1; i < n; i++)
if (w[i]) update(1, dfn[c[i]], dfn[c[i]] + siz[c[i]] - 1);
for (int i = 1; i <= m; i++) {
int u = c[q[i]];
update(1, dfn[u], dfn[u] + siz[u] - 1);
ans[i] = max(ans[i], t[1].mx0);
}
}
int main() {
n = read();
for (int i = 1; i < n; i++)
add_edge(u[i] = read(), v[i] = read(), i), w[i] = read();
m = read();
for (int i = 1; i <= m; i++) q[i] = read();
dfs(1, 0), solve(res);
dfs(res, 0), solve(res);
for (int i = 1; i <= m; i++) ::print(ans[i]), putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
struct SegTree {
pair<int, int> tr[4 * N];
bool lz[4 * N];
pair<int, int> combine(pair<int, int> left, pair<int, int> right) {
return make_pair(max(left.first, right.first),
max(left.second, right.second));
}
void propagate(int u, int st, int en) {
if (!lz[u]) return;
swap(tr[u].first, tr[u].second);
if (st != en) {
lz[2 * u] ^= 1;
lz[2 * u + 1] ^= 1;
}
lz[u] = 0;
}
void build(int u, int st, int en, int *aa, int *tp) {
if (st == en) {
if (tp[st])
tr[u] = {0, aa[st]};
else
tr[u] = {aa[st], 0};
lz[u] = 0;
} else {
int mid = (st + en) / 2;
build(2 * u, st, mid, aa, tp);
build(2 * u + 1, mid + 1, en, aa, tp);
tr[u] = combine(tr[2 * u], tr[2 * u + 1]);
lz[u] = 0;
}
}
void update(int u, int st, int en, int l, int r) {
propagate(u, st, en);
if (r < st || en < l)
return;
else if (l <= st && en <= r) {
lz[u] ^= 1;
propagate(u, st, en);
} else {
int mid = (st + en) / 2;
update(2 * u, st, mid, l, r);
update(2 * u + 1, mid + 1, en, l, r);
tr[u] = combine(tr[2 * u], tr[2 * u + 1]);
}
}
int query(int u, int st, int en, int l, int r) {
propagate(u, st, en);
if (r < st || en < l)
return 0;
else if (l <= st && en <= r)
return tr[u].first;
else {
int mid = (st + en) / 2;
return max(query(2 * u, st, mid, l, r),
query(2 * u + 1, mid + 1, en, l, r));
}
}
};
struct Edge {
int u, v, w;
int other(int x) { return u ^ x ^ v; }
};
vector<Edge> edges;
vector<int> adj[N];
bool done[N];
int farthest(int s) {
memset(done, 0, sizeof done);
queue<int> q;
q.push(s);
done[s] = 1;
int ans = s;
while (q.size()) {
int u = q.front();
ans = u;
q.pop();
for (int e : adj[u]) {
int v = edges[e].other(u);
if (!done[v]) {
q.push(v);
done[v] = 1;
}
}
}
return ans;
}
bool col[2][N];
int dis[2][N];
int st[2][N], en[2][N], par[2][N];
int aa[2][N], cc[2][N];
SegTree tree[2];
void dfs(int id, int u, int pe, int &iid) {
st[id][u] = ++iid;
aa[id][iid] = dis[id][u];
cc[id][iid] = col[id][u];
for (int e : adj[u]) {
if (e == pe) continue;
int v = edges[e].other(u);
bool w = edges[e].w;
dis[id][v] = 1 + dis[id][u];
col[id][v] = col[id][u] ^ w;
par[id][v] = u;
dfs(id, v, e, iid);
}
en[id][u] = iid;
}
int n;
void make(int u, int id) {
int iid = 0;
dfs(id, u, -1, iid);
assert(iid == n);
tree[id].build(1, 1, n, aa[id], cc[id]);
}
void flip(int id, int e) {
int u = edges[e].u;
int v = edges[e].v;
if (par[id][u] != v) swap(u, v);
assert(par[id][u] == v);
tree[id].update(1, 1, n, st[id][u], en[id][u]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int u, v, w;
cin >> u >> v >> w;
adj[u].push_back(i);
adj[v].push_back(i);
edges.push_back({u, v, w});
}
int A = farthest(1);
int B = farthest(A);
make(A, 0);
make(B, 1);
int m;
cin >> m;
while (m--) {
int id;
cin >> id;
id--;
flip(0, id);
flip(1, id);
cout << max(tree[0].query(1, 1, n, 1, n), tree[1].query(1, 1, n, 1, n))
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct ED {
int s, e, t;
} E[515151];
vector<int> edge[515151][2];
int mx, mxw;
int st[515151], en[515151], nn, depth[515151], flag[515151];
void dfs(int w, int bef, int dep, int fl) {
if (mx < dep) mx = dep, mxw = w;
depth[w] = dep;
flag[w] = fl;
st[w] = ++nn;
for (int nxt : edge[w][0])
if (bef != nxt) dfs(nxt, w, dep + 1, fl);
for (int nxt : edge[w][1])
if (bef != nxt) dfs(nxt, w, dep + 1, !fl);
en[w] = nn;
}
struct TR {
int flip, mx[2];
} tree[1616161];
void spread(int w) {
int c1 = w * 2, c2 = w * 2 + 1;
if (!tree[w].flip) return;
tree[c1].flip ^= 1;
swap(tree[c1].mx[0], tree[c1].mx[1]);
tree[c2].flip ^= 1;
swap(tree[c2].mx[0], tree[c2].mx[1]);
tree[w].flip = 0;
}
void update(int w) {
int c1 = w * 2, c2 = w * 2 + 1;
tree[w].mx[0] = max(tree[c1].mx[0], tree[c2].mx[0]);
tree[w].mx[1] = max(tree[c1].mx[1], tree[c2].mx[1]);
}
void insert_g(int w, int s, int e, int p, int val, int flag) {
if (s == e) {
tree[w].mx[flag] = val;
return;
}
int m = (s + e) / 2;
if (p <= m)
insert_g(w * 2, s, m, p, val, flag);
else
insert_g(w * 2 + 1, m + 1, e, p, val, flag);
update(w);
}
void flip(int w, int s, int e, int l, int r) {
if (s != e) spread(w);
if (s == l && e == r) {
tree[w].flip = 1;
swap(tree[w].mx[0], tree[w].mx[1]);
return;
}
int m = (s + e) / 2;
if (l <= m) flip(w * 2, s, m, l, min(m, r));
if (m < r) flip(w * 2 + 1, m + 1, e, max(m + 1, l), r);
update(w);
}
int ans[2][515151];
int edge_idx_a[515151];
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = 1; i <= n - 1; i++) {
int s, e, t;
scanf("%d%d%d", &s, &e, &t);
E[i] = {s, e, t};
edge[s][t].push_back(e);
edge[e][t].push_back(s);
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &edge_idx_a[i]);
mx = mxw = 0;
nn = 0;
dfs(1, -1, 0, 0);
int root[2] = {
mxw,
};
nn = 0;
dfs(root[0], -1, 0, 0);
root[1] = mxw;
for (int tt = 0; tt < 2; tt++) {
nn = 0;
dfs(root[tt], -1, 0, 0);
int tn;
for (tn = 1; tn < n; tn *= 2)
;
for (i = 1; i <= n; i++) insert_g(1, 1, tn, st[i], depth[i], flag[i]);
for (i = 0; i < m; i++) {
int edge_idx = edge_idx_a[i];
int s = E[edge_idx].s, e = E[edge_idx].e, t = E[edge_idx].t;
if (depth[s] > depth[e])
flip(1, 1, tn, st[s], en[s]);
else
flip(1, 1, tn, st[e], en[e]);
ans[tt][i] = tree[1].mx[0];
}
for (i = 0; i <= tn * 2; i++) tree[i] = {0, {0, 0}};
}
for (i = 0; i < m; i++) {
printf("%d\n", max(ans[0][i], ans[1][i]));
}
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>
using namespace std;
template <class node>
struct link_cut_tree {
bool connected(node* u, node* v) { return lca(u, v) != NULL; }
int depth(node* u) {
access(u);
return get_sz(u->ch[0]);
}
node* get_root(node* u) {
access(u);
while (u->ch[0]) u = u->ch[0], u->push();
return access(u), u;
}
node* ancestor(node* u, int k) {
k = depth(u) - k;
assert(k >= 0);
for (;; u->push()) {
int sz = get_sz(u->ch[0]);
if (sz == k) return access(u), u;
if (sz < k)
k -= sz + 1, u = u->ch[1];
else
u = u->ch[0];
}
assert(0);
}
node* lca(node* u, node* v) {
if (u == v) return u;
access(u);
access(v);
if (!u->p) return NULL;
u->splay();
return u->p ?: u;
}
void link(node* u, node* v) {
make_root(v);
access(u);
set_link(v, u, 0);
v->update();
}
void cut(node* u) {
access(u);
u->ch[0]->p = NULL;
u->ch[0] = NULL;
u->update();
}
void cut(node* u, node* v) { cut(depth(u) > depth(v) ? u : v); }
void make_root(node* u) {
access(u);
u->reverse();
access(u);
assert(!u->ch[0] && !u->ch[1]);
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
const pnode& self = static_cast<pnode>(this);
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), self->push();
dir() == p->dir() ? p->rotate() : self->rotate();
self->rotate();
}
if (!is_root()) p->push(), self->push(), self->rotate();
self->push();
self->update();
}
};
template <typename pnode, class splay_tree_vchs>
struct splay_tree_lct : splay_tree<pnode> {
splay_tree_vchs vnode;
using splay_tree<pnode>::ch;
bool rev;
splay_tree_vchs* root;
splay_tree_lct() : splay_tree<pnode>() {
root = NULL;
rev = 0;
}
void update() {}
void push() {
if (rev) {
if (ch[0]) ch[0]->reverse();
if (ch[1]) ch[1]->reverse();
rev = 0;
}
}
void rotate() {
swap(vnode, this->p->vnode);
splay_tree<pnode>::rotate();
}
void splay() {
auto v = &vnode;
bool r = !v->key;
splay_tree<pnode>::splay();
if (r && v->key) {
if (v->p) v->p->ch[v->p->ch[1] == &v->key->vnode] = v;
if (v->ch[0]) v->ch[0]->p = v;
if (v->ch[1]) v->ch[1]->p = v;
v->key = static_cast<pnode>(this);
}
}
void reverse() {
rev ^= 1;
swap(ch[0], ch[1]);
}
void update_vsub(pnode v, bool add) {
auto& u = root;
if (add) {
v->vnode = splay_tree_vchs(v);
if (!u) {
u = &v->vnode;
return;
}
while (u->ch[1]) u = u->ch[1];
u->ch[1] = &v->vnode;
u->ch[1]->p = u;
u = u->ch[1];
u->splay();
} else {
auto x = &v->vnode;
x->splay();
if (!x->ch[0]) {
u = x->ch[1];
} else if (!x->ch[1]) {
u = x->ch[0];
} else {
u = x->ch[0];
u->p = NULL;
while (u->ch[1]) u = u->ch[1];
u->ch[1] = x->ch[1];
x->ch[1]->p = u;
u->splay();
}
if (u) u->p = NULL;
x->key = NULL;
}
}
};
const int inf = -1e8;
template <typename pnode>
struct splay_tree_vchs : splay_tree<splay_tree_vchs<pnode>*> {
using splay_tree<splay_tree_vchs<pnode>*>::ch;
pnode key;
int x;
array<int, 4> y;
splay_tree_vchs(){};
splay_tree_vchs(const pnode& key)
: splay_tree<splay_tree_vchs<pnode>*>(), key(key) {
build();
}
void build() {
x = key->x;
y[0] = key->pp[0];
y[1] = 0;
y[2] = key->pp[1];
y[3] = inf;
}
void update() {
build();
for (int c = 0; c < 2; ++c)
if (ch[c]) {
x = max(x, ch[c]->x);
for (int i = 0; i < 4; i += 2) {
if (ch[c]->y[i] > y[i]) {
y[i + 1] = y[i];
y[i] = ch[c]->y[i];
if (ch[c]->y[i + 1] > y[i + 1]) y[i + 1] = ch[c]->y[i + 1];
} else if (ch[c]->y[i] > y[i + 1])
y[i + 1] = ch[c]->y[i];
}
}
}
void push() {}
};
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree_lct<node*, splay_tree_vchs<node*>> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
node() : splay_tree_lct() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
void update() {
splay_tree_lct::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (root) {
x = max(x, root->x);
v1[0] = root->y[0];
v1[1] = root->y[2];
v2[0] = root->y[1];
v2[1] = root->y[3];
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void push() { splay_tree_lct::push(); }
void reverse() {
splay_tree_lct::reverse();
swap(pp[0], pp[2]);
swap(pp[1], pp[3]);
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int maxn = 5e5 + 100, inf = 0x7fffffff;
struct IO {
private:
static constexpr int ibufsiz = 1 << 20;
char ibuf[ibufsiz + 1], *inow = ibuf, *ied = ibuf;
static constexpr int obufsiz = 1 << 20;
char obuf[obufsiz + 1], *onow = obuf;
const char *oed = obuf + obufsiz;
public:
char getchar() {
if (inow == ied) {
ied = ibuf + sizeof(char) * fread(ibuf, sizeof(char), ibufsiz, stdin);
*ied = '\0';
inow = ibuf;
}
return *inow++;
}
template <typename T>
void read(T &x) {
static bool flg;
flg = 0;
x = 0;
char c = getchar();
while (!isdigit(c)) flg = c == '-' ? 1 : flg, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
if (flg) x = -x;
}
template <typename T, typename... Y>
void read(T &x, Y &...X) {
read(x);
read(X...);
}
int readi() {
static int res;
read(res);
return res;
}
long long readll() {
static long long res;
read(res);
return res;
}
void flush() {
fwrite(obuf, sizeof(char), onow - obuf, stdout);
fflush(stdout);
onow = obuf;
}
void putchar(const char c) {
*onow++ = c;
if (onow == oed) {
fwrite(obuf, sizeof(char), obufsiz, stdout);
onow = obuf;
}
}
template <typename T>
void write(T x, const char split = '\0') {
static unsigned char buf[32];
if (x < 0) putchar('-'), x = -x;
int p = 0;
do {
buf[++p] = x % 10;
x /= 10;
} while (x);
for (int i = p; i >= 1; i--) putchar(buf[i] + '0');
if (split != '\0') putchar(split);
}
void puts(char const *str, const char split = '\n') {
while (*str) putchar(*(str++));
putchar(split);
}
void lf() { putchar('\n'); }
~IO() { fwrite(obuf, sizeof(char), onow - obuf, stdout); }
} io;
int n;
vector<pair<int, int>> edges;
struct seg {
static constexpr int maxn = ::maxn << 2;
int mx[maxn][2], rev[maxn];
void pushup(const int x) {
mx[x][0] = max(mx[(x << 1)][0], mx[(x << 1 | 1)][0]);
mx[x][1] = max(mx[(x << 1)][1], mx[(x << 1 | 1)][1]);
}
void pushdown(const int x) {
if (!rev[x]) return;
rev[(x << 1)] ^= 1, rev[(x << 1 | 1)] ^= 1;
swap(mx[(x << 1)][0], mx[(x << 1)][1]);
swap(mx[(x << 1 | 1)][0], mx[(x << 1 | 1)][1]);
rev[x] ^= 1;
}
void build(const int col[], const int val[], const int rnk[], const int l = 1,
const int r = n, const int x = 1) {
if (l == r) {
mx[x][col[rnk[l]]] = val[rnk[l]];
return;
}
const int mid = (l + r) >> 1;
build(col, val, rnk, l, mid, (x << 1));
build(col, val, rnk, mid + 1, r, (x << 1 | 1));
pushup(x);
}
void modify(const int a, const int b, const int l = 1, const int r = n,
const int x = 1) {
if (a <= l && b >= r) {
rev[x] ^= 1;
swap(mx[x][0], mx[x][1]);
return;
}
pushdown(x);
const int mid = (l + r) >> 1;
if (a <= mid) modify(a, b, l, mid, (x << 1));
if (b >= mid + 1) modify(a, b, mid + 1, r, (x << 1 | 1));
pushup(x);
}
} sa, sb;
namespace treea {
int siz[maxn], dfn[maxn], rnk[maxn], dep[maxn], col[maxn];
}
namespace treeb {
int siz[maxn], dfn[maxn], rnk[maxn], dep[maxn], col[maxn];
}
namespace graph {
vector<pair<int, int>> G[maxn];
void addedge(const int u, const int v, const int d) { G[u].emplace_back(v, d); }
int dis[maxn];
void dfs(const int u, const int faz = -1) {
for (auto [v, d] : G[u]) {
if (v == faz) continue;
dis[v] = dis[u] + 1;
dfs(v, u);
}
}
int dfs_tot;
void dfs2(int siz[], int dfn[], int rnk[], int dep[], int col[], const int u,
const int faz = -1) {
dfs_tot++;
siz[u] = 1;
dfn[u] = dfs_tot;
rnk[dfs_tot] = u;
for (auto [v, d] : G[u]) {
if (v == faz) continue;
dep[v] = dep[u] + 1;
col[v] = col[u] ^ d;
dfs2(siz, dfn, rnk, dep, col, v, u);
siz[u] += siz[v];
}
}
} // namespace graph
void init() {
graph::dfs(1);
const int dia_a =
max_element(graph::dis + 1, graph::dis + 1 + n) - graph::dis;
graph::dis[dia_a] = 0;
graph::dfs(dia_a);
const int dia_b =
max_element(graph::dis + 1, graph::dis + 1 + n) - graph::dis;
graph::dfs2(treea::siz, treea::dfn, treea::rnk, treea::dep, treea::col,
dia_a);
graph::dfs_tot = 0;
graph::dfs2(treeb::siz, treeb::dfn, treeb::rnk, treeb::dep, treeb::col,
dia_b);
sa.build(treea::col, treea::dep, treea::rnk);
sb.build(treeb::col, treeb::dep, treeb::rnk);
}
int main() {
io.read(n);
for (int u, v, d, i = 1; i < n; i++)
io.read(u, v, d), graph::addedge(u, v, d), graph::addedge(v, u, d),
edges.emplace_back(u, v);
init();
int q = io.readi();
while (q--) {
const int x = io.readi();
const auto [u, v] = edges[x - 1];
if (treea::dep[u] > treea::dep[v])
sa.modify(treea::dfn[u], treea::dfn[u] + treea::siz[u] - 1);
else
sa.modify(treea::dfn[v], treea::dfn[v] + treea::siz[v] - 1);
if (treeb::dep[u] > treeb::dep[v])
sb.modify(treeb::dfn[u], treeb::dfn[u] + treeb::siz[u] - 1);
else
sb.modify(treeb::dfn[v], treeb::dfn[v] + treeb::siz[v] - 1);
io.write(max(sa.mx[1][0], sb.mx[1][0]), '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5e5 + 5;
using namespace std;
int rd() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x * f;
}
int n, m, head[maxn], tot, rt, rt1, dep[maxn];
struct node {
int v, nxt, w, id;
} e[maxn << 1];
void add(int u, int v, int w, int id) {
e[++tot] = node{v, head[u], w, id};
head[u] = tot;
}
struct Segmemt_tree {
int mx_0[maxn << 2], mx_1[maxn << 2], in[maxn], out[maxn], cnt,
rev[maxn << 2], to[maxn];
void pushup(int p) {
mx_0[p] = max(mx_0[(p << 1)], mx_0[(p << 1 | 1)]);
mx_1[p] = max(mx_1[(p << 1)], mx_1[(p << 1 | 1)]);
}
void update(int p) {
swap(mx_0[p], mx_1[p]);
rev[p] ^= 1;
}
void pushdown(int p) {
if (!rev[p]) return;
update((p << 1));
update((p << 1 | 1));
rev[p] ^= 1;
}
void modify(int p, int l, int r, int x, int v, int v1) {
if (l == r) {
mx_0[p] = max(mx_0[p], v);
mx_1[p] = max(mx_1[p], v1);
return;
}
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
modify((p << 1), l, mid, x, v, v1);
else
modify((p << 1 | 1), mid + 1, r, x, v, v1);
pushup(p);
}
int query_0(int p, int l, int r, int x) {
if (l == r) return mx_0[p];
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
return query_0((p << 1), l, mid, x);
else
return query_0((p << 1 | 1), mid + 1, r, x);
pushup(p);
}
int query_1(int p, int l, int r, int x) {
if (l == r) return mx_1[p];
int mid = (l + r) >> 1;
pushdown(p);
if (x <= mid)
return query_1((p << 1), l, mid, x);
else
return query_1((p << 1 | 1), mid + 1, r, x);
pushup(p);
}
void cover(int p, int l, int r, int sl, int sr) {
if (sl <= l && r <= sr) {
swap(mx_0[p], mx_1[p]);
rev[p] ^= 1;
return;
}
int mid = (l + r) >> 1;
pushdown(p);
if (sl <= mid) cover((p << 1), l, mid, sl, sr);
if (mid < sr) cover((p << 1 | 1), mid + 1, r, sl, sr);
pushup(p);
}
void Dfs(int u, int y, int val, int dep) {
in[u] = ++cnt;
if (val)
modify(1, 1, n, in[u], 0, dep);
else
modify(1, 1, n, in[u], dep, 0);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == y) continue;
to[e[i].id] = v;
Dfs(v, u, val ^ e[i].w, dep + 1);
}
out[u] = cnt;
}
void Cover(int id) { cover(1, 1, n, in[to[id]], out[to[id]]); }
} T[2];
void dfs(int u, int y, int &root) {
dep[u] = dep[y] + 1;
if (dep[u] > dep[root]) root = u;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == y) continue;
dfs(v, u, root);
}
}
int main() {
n = rd();
for (int i = 1, u, v, w; i < n; i++) {
u = rd();
v = rd();
w = rd();
add(u, v, w, i);
add(v, u, w, i);
}
dfs(1, 0, rt);
dfs(rt, 0, rt1);
T[0].Dfs(rt, 0, 0, 0);
T[1].Dfs(rt1, 0, 0, 0);
m = rd();
for (int id; m; m--) {
id = rd();
T[0].Cover(id);
T[1].Cover(id);
printf("%d\n", max(T[0].mx_0[1], T[1].mx_0[1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const int MAXINT = 1073741823;
vector<pair<int, bool>> neighbors[MAXN];
bitset<MAXN> visited;
pair<int, int> edges[MAXN];
int timer;
int starting_time[2][MAXN], finishing_time[2][MAXN], parity_of[2][MAXN],
height[2][MAXN];
pair<int, int> find_farthest(int v, int level) {
visited[v] = true;
pair<int, int> result = make_pair(v, level), temporary;
for (pair<int, bool> i : neighbors[v])
if (!visited[i.first]) {
temporary = find_farthest(i.first, level + 1);
if (temporary.second > result.second) result = temporary;
}
return result;
}
void dfs(int v, int level, bool which, bool parity) {
visited[v] = true;
starting_time[which][v] = timer++;
parity_of[which][starting_time[which][v]] = parity;
height[which][starting_time[which][v]] = level;
for (pair<int, bool> i : neighbors[v])
if (!visited[i.first]) dfs(i.first, level + 1, which, parity ^ i.second);
finishing_time[which][v] = timer;
return;
}
struct node {
int maximum_odd, maximum_even;
bool lazy = false;
} segment[2][MAXN * 4];
void apply_lazy(bool which, int current) {
if (segment[which][current].lazy) {
swap(segment[which][current * 2 + 1].maximum_even,
segment[which][current * 2 + 1].maximum_odd);
segment[which][current * 2 + 1].lazy ^= 1;
swap(segment[which][current * 2 + 2].maximum_even,
segment[which][current * 2 + 2].maximum_odd);
segment[which][current * 2 + 2].lazy ^= 1;
segment[which][current].lazy = false;
}
return;
}
void update(int from, int to, int current, bool which, int beginning,
int ending) {
if (from > ending || to < beginning)
return;
else if (beginning <= from && to <= ending) {
swap(segment[which][current].maximum_even,
segment[which][current].maximum_odd);
segment[which][current].lazy ^= 1;
return;
}
int mid = (from + to) / 2;
apply_lazy(which, current);
update(from, mid, current * 2 + 1, which, beginning, ending);
update(mid + 1, to, current * 2 + 2, which, beginning, ending);
segment[which][current].maximum_even =
max(segment[which][current * 2 + 1].maximum_even,
segment[which][current * 2 + 2].maximum_even);
segment[which][current].maximum_odd =
max(segment[which][current * 2 + 1].maximum_odd,
segment[which][current * 2 + 2].maximum_odd);
return;
}
void construct(int from, int to, int current, bool which) {
if (from == to) {
if (parity_of[which][from] == 0) {
segment[which][current].maximum_even = height[which][from];
segment[which][current].maximum_odd = 0;
} else {
segment[which][current].maximum_odd = height[which][from];
segment[which][current].maximum_even = 0;
}
return;
}
int mid = (from + to) / 2;
construct(from, mid, current * 2 + 1, which);
construct(mid + 1, to, current * 2 + 2, which);
segment[which][current].maximum_even =
max(segment[which][current * 2 + 1].maximum_even,
segment[which][current * 2 + 2].maximum_even);
segment[which][current].maximum_odd =
max(segment[which][current * 2 + 1].maximum_odd,
segment[which][current * 2 + 2].maximum_odd);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, t, u, v, index, select_1, select_2;
bool w;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> edges[i].first >> edges[i].second >> w;
edges[i].first--;
edges[i].second--;
neighbors[edges[i].first].emplace_back(edges[i].second, w);
neighbors[edges[i].second].emplace_back(edges[i].first, w);
}
select_1 = find_farthest(0, 0).first;
visited.reset();
select_2 = find_farthest(select_1, 0).first;
visited.reset();
dfs(select_1, 0, 0, 0);
timer = 0;
visited.reset();
dfs(select_2, 0, 1, 0);
construct(0, n - 1, 0, 0);
construct(0, n - 1, 0, 1);
cin >> t;
for (int q = 0; q < t; q++) {
cin >> index;
index--;
tie(u, v) = edges[index];
if (height[0][starting_time[0][u]] < height[0][starting_time[0][v]])
swap(u, v);
update(0, n - 1, 0, 0, starting_time[0][u], finishing_time[0][u] - 1);
if (height[1][starting_time[1][u]] < height[1][starting_time[1][v]])
swap(u, v);
update(0, n - 1, 0, 1, starting_time[1][u], finishing_time[1][u] - 1);
cout << max(segment[0][0].maximum_even, segment[1][0].maximum_even) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 10;
int n, m;
vector<pair<int, int> > g[N];
pair<int, int> b[N][2];
int len[N], deep[N], l[N], r[N], cnt, sig[N], l2id[N];
int ans[N];
int edge[N][2], q[N];
struct node {
int v[2];
bool tag;
void clear() {
v[0] = v[1] = 0;
tag = 0;
}
} f[N * 4];
void dfs(int x, int fa) {
for (auto u : g[x])
if (u.first != fa) {
dfs(u.first, x);
if (b[u.first][0].second + 1 >= b[x][0].second) {
b[x][1] = b[x][0];
b[x][0] = {u.first, b[u.first][0].second + 1};
} else {
if (b[u.first][0].second + 1 > b[x][1].second) {
b[x][1] = {u.first, b[u.first][0].second + 1};
}
}
}
}
void dfs(int x, int up, int fa) {
len[x] = max(b[x][0].second, up);
for (auto u : g[x])
if (u.first != fa) {
int up1 = up;
if (u.first != b[x][0].first)
up1 = max(up1, b[x][0].second);
else
up1 = max(up1, b[x][1].second);
dfs(u.first, up1 + 1, x);
}
}
void dfs1(int x, int fa) {
l2id[l[x] = ++cnt] = x;
deep[x]++;
for (auto u : g[x])
if (u.first != fa) {
sig[u.first] = (sig[x] ^ u.second);
deep[u.first] = deep[x];
dfs1(u.first, x);
}
r[x] = cnt;
}
void down(int l, int r, int s) {
if (f[s].tag) {
swap(f[s].v[0], f[s].v[1]);
if (l != r) f[s + s].tag ^= f[s].tag, f[s + s + 1].tag ^= f[s].tag;
f[s].tag = 0;
}
}
void merge(int s) {
f[s].v[0] = max(f[s + s + 1].v[0], f[s + s].v[0]);
f[s].v[1] = max(f[s + s + 1].v[1], f[s + s].v[1]);
}
void build(int l, int r, int s) {
f[s].clear();
if (l == r) {
f[s].v[sig[l2id[l]]] = deep[l2id[l]];
return;
}
build(l, (l + r) / 2, s + s);
build((l + r) / 2 + 1, r, s + s + 1);
merge(s);
}
void change(int l, int r, int s, int ll, int rr) {
down(l, r, s);
if (r < ll || rr < l) return;
if (ll <= l && r <= rr) {
f[s].tag = 1;
down(l, r, s);
return;
}
change(l, (l + r) / 2, s + s, ll, rr);
change((l + r) / 2 + 1, r, s + s + 1, ll, rr);
merge(s);
}
void work(int root) {
cnt = 0;
deep[root] = -1;
sig[root] = 0;
dfs1(root, 0);
build(1, n, 1);
for (int i = 1; i <= m; i++) {
int x;
if (deep[edge[q[i]][0]] > deep[edge[q[i]][1]])
x = edge[q[i]][0];
else
x = edge[q[i]][1];
change(1, n, 1, l[x], r[x]);
ans[i] = max(ans[i], f[1].v[0]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].push_back({y, z});
g[y].push_back({x, z});
edge[i][0] = x, edge[i][1] = y;
}
dfs(1, 0);
dfs(1, 0, 0);
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = max(len[i], mx);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &q[i]);
}
for (int i = 1; i <= n; i++)
if (len[i] == mx) {
work(i);
deep[i] = -1;
dfs1(i, 0);
for (int j = 1; j <= n; j++)
if (deep[j] == mx) {
work(j);
break;
}
break;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#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;
const int maxn = 5e5 + 5, maxm = 1e6 + 5;
int mx[maxn << 2][2][2], fz[maxn << 2][2];
int color[maxn][2], cen[maxn][2], dis[maxn], DFS[maxn][2], EFS[maxn][2], t[2];
inline void push_up(int rt) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
mx[rt][i][j] = max(mx[rt << 1][i][j], mx[rt << 1 | 1][i][j]);
}
inline void push_down(int rt, int l, int r) {
if (fz[rt][1]) {
swap(mx[rt << 1][1][0], mx[rt << 1][1][1]);
swap(mx[rt << 1 | 1][1][0], mx[rt << 1 | 1][1][1]);
fz[rt << 1][1] ^= 1, fz[rt << 1 | 1][1] ^= 1;
fz[rt][1] = 0;
}
if (fz[rt][0]) {
swap(mx[rt << 1][0][0], mx[rt << 1][0][1]);
swap(mx[rt << 1 | 1][0][0], mx[rt << 1 | 1][0][1]);
fz[rt << 1][0] ^= 1, fz[rt << 1 | 1][0] ^= 1;
fz[rt][0] = 0;
}
}
void build(int rt, int l, int r) {
if (l == r) {
mx[rt][1][color[l][1]] = cen[l][1];
mx[rt][0][color[l][0]] = cen[l][0];
return;
}
int m = (l + r) >> 1;
build(rt << 1, l, m);
build(rt << 1 | 1, m + 1, r);
push_up(rt);
}
void update(int rt, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) {
swap(mx[rt][v][0], mx[rt][v][1]);
fz[rt][v] ^= 1;
return;
}
push_down(rt, l, r);
int m = (l + r) >> 1;
if (L <= m) update(rt << 1, l, m, L, R, v);
if (m < R) update(rt << 1 | 1, m + 1, r, L, R, v);
push_up(rt);
}
int query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return max(mx[rt][1][0], mx[rt][0][0]);
push_down(rt, l, r);
int m = (l + r) >> 1;
if (L <= m)
;
if (m < R)
;
return 0;
}
int head[maxn], nume;
struct edge {
int v, w, c, next;
} e[maxm];
inline void init_edge() {
memset(head, -1, sizeof head);
nume = 0;
}
inline void add_edge(int u, int v, int w = 0, int c = 0) {
e[nume].v = v;
e[nume].w = w;
e[nume].c = c;
e[nume].next = head[u];
head[u] = nume++;
}
int a = 1, b = 1;
void dfs(int u, int f) {
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
if (v != f) {
dis[v] = dis[u] + 1;
dfs(v, u);
}
}
}
void ddfs(int u, int f, int cl) {
DFS[u][cl] = ++t[cl];
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v, w = e[i].w;
if (v != f) {
cen[t[cl] + 1][cl] = cen[DFS[u][cl]][cl] + 1;
color[t[cl] + 1][cl] = color[DFS[u][cl]][cl] ^ w;
ddfs(v, u, cl);
}
}
EFS[u][cl] = t[cl];
}
int n, u[maxn], v[maxn], w[maxn];
int m, x;
int main() {
init_edge();
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &u[i], &v[i], &w[i]);
add_edge(u[i], v[i], w[i]);
add_edge(v[i], u[i], w[i]);
}
dis[1] = 0;
dfs(1, 0);
for (int i = 1; i <= n; i++) {
if (dis[i] > dis[a]) a = i;
}
dis[a] = 0;
dfs(a, 0);
for (int i = 1; i <= n; i++) {
if (dis[i] > dis[b]) b = i;
}
ddfs(a, 0, 0);
ddfs(b, 0, 1);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d", &x);
for (int i = 0; i <= 1; i++) {
if (DFS[u[x]][i] < DFS[v[x]][i])
update(1, 1, n, DFS[v[x]][i], EFS[v[x]][i], i);
else
update(1, 1, n, DFS[u[x]][i], EFS[u[x]][i], i);
}
printf("%d\n", max(mx[1][0][0], mx[1][1][0]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') y = -y;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * y;
}
namespace qiqi {
const int N = 5e5 + 5;
int n, Q, ecnt, head[N], pos[N], cnt, dfn[N], inv[N], siz[N], num, in[N],
lg[N * 2], st[N * 2][20], tag[N * 4], val[N];
struct Edge {
int v, w, nxt;
} e[N * 2];
inline void add(int u, int v, int w) {
e[++ecnt] = (Edge){v, w, head[u]};
head[u] = ecnt;
}
inline int dis(int x, int y) {
if (!x || !y) return -1e9;
x = in[x];
y = in[y];
if (x > y) swap(x, y);
int z = lg[y - x + 1];
return st[x][0] + st[y][0] - 2 * min(st[x][z], st[y - (1 << z) + 1][z]);
}
struct Val {
int p[2], k;
inline Val(int x = 0, int y = 0) { k = dis(p[0] = x, p[1] = y); }
inline bool operator<(const Val &rhs) const { return k < rhs.k; }
inline Val operator+(const Val &rhs) const {
Val res = max(*this, rhs);
for (int i = (0); i <= (1); ++i)
for (int j = (0); j <= (1); ++j) res = max(res, Val(p[i], rhs.p[j]));
return res;
}
} mx[N * 4][2];
inline int ls(int x) { return x << 1; }
inline int rs(int x) { return x << 1 | 1; }
inline void push_up(int x) {
for (int i = (0); i <= (1); ++i) mx[x][i] = mx[ls(x)][i] + mx[rs(x)][i];
}
inline void f(int x) {
swap(mx[x][0], mx[x][1]);
tag[x] ^= 1;
}
inline void push_down(int x) {
if (tag[x]) {
f(ls(x));
f(rs(x));
tag[x] = 0;
}
}
void build(int x, int l, int r) {
if (l == r) {
mx[x][val[inv[l]]] = Val(inv[l], inv[l]);
return;
}
int mid = l + ((r - l) >> 1);
build(ls(x), l, mid);
build(rs(x), mid + 1, r);
push_up(x);
}
void upd(int x, int l, int r, int pl, int pr) {
if (pl <= l && r <= pr) return f(x);
push_down(x);
int mid = l + ((r - l) >> 1);
if (pl <= mid) upd(ls(x), l, mid, pl, pr);
if (pr > mid) upd(rs(x), mid + 1, r, pl, pr);
push_up(x);
}
void dfs(int u, int f, int d, int k) {
siz[u] = 1;
val[u] = k;
st[in[u] = ++num][0] = d;
inv[dfn[u] = ++cnt] = u;
for (int i = head[u], v = e[i].v; i; v = e[i = e[i].nxt].v)
if (v != f) {
dfs(v, u, d + 1, k ^ e[i].w);
pos[(i + 1) / 2] = v;
st[++num][0] = d;
siz[u] += siz[v];
}
}
void main() {
n = read();
for (int i = (2); i <= (n); ++i) {
int x = read(), y = read(), z = read();
add(x, y, z);
add(y, x, z);
}
dfs(1, 0, 1, 0);
lg[0] = -1;
for (int i = (1); i <= (num); ++i) lg[i] = lg[i >> 1] + 1;
for (int j = (1); j <= (19); ++j)
for (int i = (1); i <= (num - (1 << (j - 1))); ++i)
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
build(1, 1, n);
Q = read();
while (Q--) {
int x = pos[read()];
upd(1, 1, n, dfn[x], dfn[x] + siz[x] - 1);
printf("%d\n", max(mx[1][0], mx[1][1]).k);
}
}
} // namespace qiqi
int main() {
qiqi::main();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int read(void) {
int x = 0;
register char ch = getchar();
while (ch < 48) ch = getchar();
while (ch > 47) x = x * 10 + ch - 48, ch = getchar();
return x;
}
constexpr int Maxn = 5e5 + 5;
constexpr int LOG = 20;
int n, q;
struct Edge {
int to, w, nxt, id;
} e[Maxn << 1];
int head[Maxn], tot_edge;
void add_edge(int u, int v, int w) {
e[++tot_edge] = (Edge){v, w, head[u]};
head[u] = tot_edge;
}
int dfn[Maxn], ed[Maxn], dfn_time, dfn_id[Maxn];
int sz[Maxn], dep[Maxn];
int xord[Maxn], e_son[Maxn];
int fad[Maxn << 1], fa_time, fdfn[Maxn];
int ST[Maxn << 1][LOG + 1], lg[Maxn << 1];
void dfs(int u, int fa, int depth) {
sz[u] = 1;
dep[u] = depth;
dfn[u] = ++dfn_time;
dfn_id[dfn_time] = u;
fdfn[u] = ++fa_time;
fad[fa_time] = u;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to, w = e[i].w;
if (v == fa) continue;
xord[v] = xord[u] ^ w;
dfs(v, u, depth + 1);
sz[u] += sz[v];
e_son[(i + 1) >> 1] = v;
fad[++fa_time] = u;
}
ed[u] = dfn[u] + sz[u] - 1;
}
inline int min_dep(int x, int y) { return (dep[x] < dep[y]) ? x : y; }
int get_lca(int x, int y) {
if (x == y) return x;
int l = fdfn[x], r = fdfn[y];
if (l > r) swap(l, r);
int k = lg[r - l + 1];
return min_dep(ST[l][k], ST[r - (1 << k) + 1][k]);
}
int get_dist(int x, int y) { return dep[x] + dep[y] - 2 * dep[get_lca(x, y)]; }
struct diam {
int x, y, d;
diam() : x(0), y(0), d(0) {}
diam(int x, int y) : x(x), y(y) { d = (x == y) ? 0 : get_dist(x, y); }
diam(int x, int y, int d) : x(x), y(y), d(d) {}
diam(const diam &da) : x(da.x), y(da.y), d(da.d) {}
friend bool operator<(const diam &x, const diam &y) { return x.d < y.d; }
friend diam operator+(const diam &x, const diam &y) {
if (!x.x) return y;
if (!y.x) return x;
diam res = max(x, y);
res = max(res, max(diam(x.x, y.x), diam(x.x, y.y)));
res = max(res, max(diam(x.y, y.x), diam(x.y, y.y)));
return res;
}
};
diam tr[Maxn << 2][2];
bool rev[Maxn << 2];
void pushup(int p) {
tr[p][0] = tr[(p << 1)][0] + tr[((p << 1) | 1)][0];
tr[p][1] = tr[(p << 1)][1] + tr[((p << 1) | 1)][1];
}
void build(int p, int l, int r) {
rev[p] = false;
if (l == r) {
int x = dfn_id[l];
int y = xord[x];
tr[p][y] = diam(x, x);
tr[p][y ^ 1] = diam();
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid);
build(((p << 1) | 1), mid + 1, r);
pushup(p);
}
void apply(int p) {
swap(tr[p][0], tr[p][1]);
rev[p] ^= 1;
}
void pushdown(int p, int l, int r) {
if (rev[p]) {
if (l != r) {
apply((p << 1));
apply(((p << 1) | 1));
}
rev[p] = false;
}
}
void modify(int p, int l, int r, int L, int R) {
if (L > r || l > R) return;
if (L <= l && r <= R) return apply(p);
pushdown(p, l, r);
int mid = (l + r) >> 1;
modify((p << 1), l, mid, L, R);
modify(((p << 1) | 1), mid + 1, r, L, R);
pushup(p);
}
int main() {
n = read();
for (int i = 1; i < n; ++i) {
int u, v, w;
u = read(), v = read(), w = read();
add_edge(u, v, w);
add_edge(v, u, w);
}
xord[1] = 0;
dfn_time = fa_time = 0;
dfs(1, 0, 1);
int szf = fa_time;
lg[0] = -1;
for (int i = 1; i <= szf; ++i) {
ST[i][0] = fad[i];
lg[i] = lg[i >> 1] + 1;
}
for (int j = 1; j <= LOG; ++j) {
for (int i = 1; i + (1 << j) - 1 <= szf; ++i) {
ST[i][j] = min_dep(ST[i][j - 1], ST[i + (1 << (j - 1))][j - 1]);
}
}
build(1, 1, n);
q = read();
while (q--) {
int x = read();
int u = e_son[x];
modify(1, 1, n, dfn[u], ed[u]);
printf("%d\n", max(tr[1][0], tr[1][1]).d);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _buf[100000], *_p1 = _buf, *_p2 = _buf;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return (f == 1) ? x : -x;
}
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
const int maxn = 5e5 + 5;
int n, p[maxn], sz, maxpos, maxdis, fa[maxn], Q;
struct node {
int u, v, w;
};
vector<node> edg;
struct edge {
int v, w, nxt;
edge(int vv = 0, int ww = 0, int nn = 0) { v = vv, w = ww, nxt = nn; }
} e[maxn << 1];
inline void add(int u, int v, int w) {
e[++sz] = edge(v, w, p[u]);
p[u] = sz;
}
struct segmentree {
static const int maxn = 2e6 + 5;
int rt;
int dep[maxn], tot, dfn[maxn], siz[maxn], len[maxn], rk[maxn];
bool tag[maxn];
int maxv[maxn][2];
inline void pushup(int u) {
for (int i = 0; i <= 1; ++i) {
if (maxv[u << 1][i] > maxv[u << 1 | 1][i])
maxv[u][i] = maxv[u << 1][i];
else
maxv[u][i] = maxv[u << 1 | 1][i];
}
}
inline void pushdown(int u) {
if (tag[u]) {
swap(maxv[u << 1][0], maxv[u << 1][1]);
swap(maxv[u << 1 | 1][0], maxv[u << 1 | 1][1]);
tag[u << 1] ^= 1, tag[u << 1 | 1] ^= 1, tag[u] = 0;
}
}
inline void dfs(int u, int fa) {
dfn[u] = ++tot;
siz[u] = 1;
rk[tot] = u;
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
if (e[i].w == 1)
len[v] = len[u] ^ 1;
else
len[v] = len[u];
dep[v] = dep[u] + 1;
dfs(v, u);
siz[u] += siz[v];
}
}
inline void build(int u, int l, int r) {
if (l == r) {
maxv[u][len[rk[l]]] = dep[rk[l]];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
inline int query(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) return maxv[u][0];
int mid = (l + r) >> 1, ret = 0;
pushdown(u);
if (x <= mid) ret = query(u << 1, l, mid, x, y);
if (y > mid) ret = max(ret, query(u << 1 | 1, mid + 1, r, x, y));
}
inline void update(int u, int l, int r, int x, int y) {
if (x <= l && y >= r) {
tag[u] ^= 1;
swap(maxv[u][0], maxv[u][1]);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (x <= mid) update(u << 1, l, mid, x, y);
if (y > mid) update(u << 1 | 1, mid + 1, r, x, y);
pushup(u);
}
inline void change(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
update(1, 1, n, dfn[v], dfn[v] + siz[v] - 1);
}
} tree1, tree2;
inline void dfs2(int u, int f, int dis) {
if (dis > maxdis) {
maxpos = u, maxdis = dis;
}
for (int i = p[u]; i != -1; i = e[i].nxt) {
int v = e[i].v;
if (v == f) continue;
dfs2(v, u, dis + 1);
}
}
inline void init() {
dfs2(1, 0, 0);
tree1.rt = maxpos;
maxdis = 0;
dfs2(maxpos, 0, 0);
tree2.rt = maxpos;
tree1.dfs(tree1.rt, 0);
tree2.dfs(tree2.rt, 0);
tree1.build(1, 1, n);
tree2.build(1, 1, n);
}
inline void input() {
memset(p, -1, sizeof(p));
n = gi();
node x;
edg.push_back(x);
for (int i = 1; i <= n - 1; ++i) {
x.u = gi(), x.v = gi(), x.w = gi();
edg.push_back(x);
add(x.u, x.v, x.w);
add(x.v, x.u, x.w);
}
}
inline void solve() {
Q = gi();
while (Q--) {
int x = gi();
int u = edg[x].u, v = edg[x].v;
tree1.change(u, v);
tree2.change(u, v);
printf("%d\n", max(tree1.query(1, 1, n, 1, n), tree2.query(1, 1, n, 1, n)));
}
}
int main() {
input();
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long INF64 = 1e18;
const double INF = 2e9 + 63;
const long long mod = 1e9 + 7;
const int maxn = 3e3 + 79;
const long long sigma = 27;
const double pi = acos(-1);
struct VertVal {
long long lowest0;
long long lowest1;
};
template <typename T, typename PushT>
struct RMQ {
vector<T> mas;
T neutral;
int size;
std::function<T(const T&, const T&)> op;
vector<PushT> masPush;
PushT neutralPush;
std::function<pair<PushT, PushT>(const PushT&)> opPush;
std::function<void(PushT&, T&)> opApply;
std::function<PushT(const PushT&, const PushT&)> opPendingCompose;
RMQ(int size, std::function<T(const T&, const T&)> op, T neutral,
std::function<pair<PushT, PushT>(const PushT&)> opPush, PushT neutralPush,
std::function<void(PushT&, T&)> opApply,
std::function<PushT(const PushT&, const PushT&)> opPendingCompose) {
this->neutral = neutral;
this->size = size;
this->op = op;
mas.assign(4 * size, neutral);
this->opPush = opPush;
this->opApply = opApply;
this->opPendingCompose = opPendingCompose;
this->neutralPush = neutralPush;
masPush.assign(4 * size, neutralPush);
}
void setVal(int pos, T val) { setValImpl(pos, val, 0, size - 1, 1); }
void setValImpl(int pos, T val, int l, int r, int v) {
if (l == r && r == pos) {
mas[v] = val;
return;
}
if (l > pos || r < pos) return;
int m = (l + r) / 2;
setValImpl(pos, val, l, m, 2 * v);
setValImpl(pos, val, m + 1, r, 2 * v + 1);
mas[v] = op(mas[2 * v], mas[2 * v + 1]);
}
void modify(int l, int r, PushT d) { modifyImpl(l, r, d, 0, size - 1, 1); }
void push(int v, bool isLeaf) {
if (!isLeaf) {
auto p = opPush(masPush[v]);
masPush[2 * v] = opPendingCompose(masPush[2 * v], p.first);
masPush[2 * v + 1] = opPendingCompose(masPush[2 * v + 1], p.second);
}
opApply(masPush[v], mas[v]);
}
void modifyImpl(int rq_l, int rq_r, long long d, int l, int r, int v) {
push(v, l == r);
if (rq_l > r || l > rq_r) return;
if (rq_l <= l && r <= rq_r) {
masPush[v] = opPendingCompose(masPush[v], d);
push(v, l == r);
return;
}
int m = (l + r) / 2;
modifyImpl(rq_l, rq_r, d, l, m, 2 * v);
modifyImpl(rq_l, rq_r, d, m + 1, r, 2 * v + 1);
mas[v] = op(mas[2 * v], mas[2 * v + 1]);
}
T query(int l, int r) { return queryImpl(l, r, 0, size - 1, 1); }
T queryImpl(int rq_l, int rq_r, int l, int r, int v) {
push(v, l == r);
if (rq_l > r || l > rq_r) return neutral;
if (rq_l <= l && r <= rq_r) {
return mas[v];
}
int m = (l + r) / 2;
T ans1 = queryImpl(rq_l, rq_r, l, m, 2 * v);
T ans2 = queryImpl(rq_l, rq_r, m + 1, r, 2 * v + 1);
return op(ans1, ans2);
}
};
struct Edge {
int to;
int getTo() const { return to; }
long long getW() const { return 1; }
};
struct WEdge {
int to;
long long w;
int getTo() const { return to; }
long long getW() const { return w; }
};
struct None {};
template <typename EdgeType, typename VertType = None>
struct Graph {
vector<VertType> v;
vector<vector<EdgeType>> g;
Graph(int n) : g(n), v(n){};
void addEdge(int from, int to, EdgeType info) {
info.to = to;
g[from].push_back(info);
info.to = from;
g[to].push_back(info);
}
void addOEdge(int from, int to, EdgeType info) {
info.to = to;
g[from].push_back(info);
}
};
struct PFInfo {
int par;
long long dist;
friend bool operator<(const PFInfo& a, const PFInfo& b) {
return a.dist < b.dist;
}
};
template <typename EdgeType, typename VertType>
vector<PFInfo> bfs(const Graph<EdgeType, VertType>& g, int start) {
vector<PFInfo> res(g.g.size(), {-1, INF64});
queue<int> s;
res[start].par = -2;
res[start].dist = 0;
s.push(start);
while (!s.empty()) {
int v = s.front();
s.pop();
for (auto& it : g.g[v]) {
int to = it.getTo();
if (res[to].dist == INF64) {
res[to].par = v;
res[to].dist = res[v].dist + it.getW();
s.push(to);
}
}
}
return res;
}
vector<int> restorePath(const vector<PFInfo>& pfInfo, int to) {
vector<int> res;
while (true) {
res.push_back(to);
if (pfInfo[to].par == -1) {
return {};
}
if (pfInfo[to].par == -2) {
return res;
}
to = pfInfo[to].par;
}
}
struct MyEdge : Edge {
int roadType;
MyEdge(int roadType) : roadType(roadType){};
};
int cnt = 0;
void dfs(Graph<MyEdge>& g, vector<pair<int, int>>& segs, vector<int>& oddness,
vector<int>& depths, int v = 0, int curCnt = 0, int depth = 0,
int p = -1) {
oddness[cnt] = curCnt;
depths[cnt] = depth;
int start = cnt++;
for (auto& it : g.g[v]) {
int to = it.getTo();
if (to == p) continue;
dfs(g, segs, oddness, depths, to, curCnt ^ it.roadType, depth + 1, v);
}
segs[v] = {start, cnt - 1};
}
void solve() {
int n;
cin >> n;
Graph<MyEdge> g(n);
vector<pair<int, int>> edges;
for (int i = 0; i < n - 1; i++) {
int u, v, t;
cin >> u >> v >> t;
u--;
v--;
g.addEdge(u, v, {t});
edges.push_back({u, v});
}
auto dists = bfs(g, 0);
int end1 = max_element(dists.begin(), dists.end()) - dists.begin();
auto dists1 = bfs(g, end1);
int end2 = max_element(dists1.begin(), dists1.end()) - dists1.begin();
auto dists2 = bfs(g, end2);
vector<pair<int, int>> seqFrom1(n), seqFrom2(n);
vector<int> oddnessFrom1(n), oddnessFrom2(n);
vector<int> depths1(n), depths2(n);
cnt = 0;
dfs(g, seqFrom1, oddnessFrom1, depths1, end1);
assert(cnt == n);
RMQ<VertVal, int> rmq1(
n,
[](const VertVal& a, const VertVal& b) {
return VertVal{max(a.lowest0, b.lowest0), max(a.lowest1, b.lowest1)};
},
VertVal{-1, -1},
[](const int& par) { return pair<bool, bool>(par, par); }, false,
[](int& a, VertVal& b) {
if (a) swap(b.lowest0, b.lowest1);
a = false;
},
[](const int& a, const int& b) { return a ^ b; });
for (int i = 0; i < n; i++) {
if (oddnessFrom1[i]) {
rmq1.setVal(i, {-1, depths1[i]});
} else {
rmq1.setVal(i, {depths1[i], -1});
}
}
cnt = 0;
dfs(g, seqFrom2, oddnessFrom2, depths2, end2);
assert(cnt == n);
RMQ<VertVal, int> rmq2(
n,
[](const VertVal& a, const VertVal& b) {
return VertVal{max(a.lowest0, b.lowest0), max(a.lowest1, b.lowest1)};
},
VertVal{-1, -1},
[](const int& par) { return pair<bool, bool>(par, par); }, false,
[](int& a, VertVal& b) {
if (a) swap(b.lowest0, b.lowest1);
a = false;
},
[](const int& a, const int& b) { return a ^ b; });
auto tmp = rmq1.query(0, 1);
for (int i = 0; i < n; i++) {
if (oddnessFrom2[i]) {
rmq2.setVal(i, {-1, depths2[i]});
} else {
rmq2.setVal(i, {depths2[i], -1});
}
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int id;
cin >> id;
id--;
auto p = edges[id];
int u = p.first;
int v = p.second;
int root = -1;
if (dists1[u].par == v) {
root = u;
} else if (dists1[v].par == u) {
root = v;
} else
assert(false);
auto seg = seqFrom1[root];
rmq1.modify(seg.first, seg.second, true);
root = -1;
if (dists2[u].par == v) {
root = u;
} else if (dists2[v].par == u) {
root = v;
} else
assert(false);
seg = seqFrom2[root];
rmq2.modify(seg.first, seg.second, true);
auto res1 = rmq1.query(0, n - 1);
auto res2 = rmq2.query(0, n - 1);
long long res = max(res1.lowest0, res2.lowest0);
cout << res << "\n";
}
}
int main(int argc, char** argv) {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cout << setprecision(2) << fixed;
int t;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &first, T second) {
first < second ? first = second : T();
}
template <typename T>
void chkmin(T &first, T second) {
first > second ? first = second : T();
}
template <typename T>
void readint(T &first) {
first = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) first = first * 10 + (c - '0');
first *= f;
}
const int MOD = 998244353;
inline int dmy(int first) { return first >= MOD ? first - MOD : first; }
inline void inc(int &first, int second) { first = dmy(first + second); }
int qmi(int first, int second) {
int ans = 1;
for (; second; second >>= 1, first = 1ll * first * first % MOD)
if (second & 1) ans = 1ll * ans * first % MOD;
return ans;
}
const int MAXN = 500005, MAXK = 19;
int n, _u[MAXN], _v[MAXN];
vector<pair<int, int> > G[MAXN];
int dfn[MAXN], size[MAXN], d0[MAXN], d1[MAXN], col[MAXN], ded[MAXN], dfn_cnt;
void dfs(int u, int pa, int *dep) {
size[u] = 1;
dfn[u] = ++dfn_cnt;
ded[dfn_cnt] = u;
for (auto p : G[u]) {
int v = p.first, c = p.second;
if (v == pa) continue;
dep[v] = dep[u] + 1;
col[v] = col[u] ^ c;
dfs(v, u, dep);
size[u] += size[v];
}
}
int co[MAXN << 2], mu[MAXN << 2][2][2], tag[MAXN << 2];
void maintain(int id) {
swap(mu[id][0][0], mu[id][1][0]);
swap(mu[id][0][1], mu[id][1][1]);
co[id] ^= 1;
tag[id] ^= 1;
}
void update(int id) {
for (int t = 0; t <= 1; ++t)
mu[id][0][t] = max(mu[id << 1][0][t], mu[id << 1 | 1][0][t]),
mu[id][1][t] = max(mu[id << 1][1][t], mu[id << 1 | 1][1][t]);
}
void pushdown(int id) {
if (!tag[id]) return;
maintain(id << 1), maintain(id << 1 | 1);
tag[id] = 0;
}
void build(int id, int l, int r) {
tag[id] = 0;
if (l == r) {
co[id] = col[ded[l]];
mu[id][co[id]][0] = d0[ded[l]];
mu[id][co[id]][1] = d1[ded[l]];
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
update(id);
}
void modify(int id, int l, int r, int ql, int qr) {
if (l == ql && r == qr) {
maintain(id);
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid)
modify(id << 1, l, mid, ql, qr);
else if (ql > mid)
modify(id << 1 | 1, mid + 1, r, ql, qr);
else
modify(id << 1, l, mid, ql, mid),
modify(id << 1 | 1, mid + 1, r, mid + 1, qr);
update(id);
}
int query(int id, int l, int r, int ql, int qr, int t, int s) {
if (l == ql && r == qr) return mu[id][t][s];
pushdown(id);
int mid = (l + r) >> 1;
if (qr <= mid) return query(id << 1, l, mid, ql, qr, t, s);
if (ql > mid) return query(id << 1 | 1, mid + 1, r, ql, qr, t, s);
return max(query(id << 1, l, mid, ql, mid, t, s),
query(id << 1 | 1, mid + 1, r, mid + 1, qr, t, s));
}
int qcol(int id, int l, int r, int first) {
if (l == r) return co[id];
pushdown(id);
int mid = (l + r) >> 1;
if (first <= mid) return qcol(id << 1, l, mid, first);
return qcol(id << 1 | 1, mid + 1, r, first);
}
int main() {
int Q;
readint(n);
for (int i = 1; i < n; ++i) {
int c;
readint(_u[i]), readint(_v[i]), readint(c);
G[_u[i]].push_back(make_pair(_v[i], c));
G[_v[i]].push_back(make_pair(_u[i], c));
}
dfs(1, -1, d1);
int u = 1;
for (int i = 2; i <= n; ++i)
if (d1[i] > d1[u]) u = i;
dfn_cnt = 0;
dfs(u, -1, d0);
int v = 1;
for (int i = 2; i <= n; ++i)
if (d0[i] > d0[v]) v = i;
d1[v] = 0;
dfn_cnt = 0;
dfs(v, -1, d1);
d1[0] = d0[0] = -1;
for (int i = 1; i < n; ++i)
if (d1[_u[i]] > d1[_v[i]]) swap(_u[i], _v[i]);
memset(mu, -1, sizeof(mu));
build(1, 1, n);
readint(Q);
while (Q--) {
int first;
readint(first);
first = _v[first];
modify(1, 1, n, dfn[first], dfn[first] + size[first] - 1);
int cu = qcol(1, 1, n, dfn[u]), cv = qcol(1, 1, n, dfn[v]);
if (cu == cv)
printf("%d\n", d0[v]);
else
printf("%d\n", max(mu[1][cu][0], mu[1][cv][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const long long int mod = 1e9 + 7;
const int inf = 1e9;
const int lg = 19;
int mn[4 * N], mx[2][4 * N], mx1[2][4 * N], mx2[2][4 * N], mx3[2][4 * N];
int n, q, ti = 0, par[N], H[N], h[N], st[N], fi[N];
bool k[N], lazy[4 * N];
vector<pair<int, int>> e;
vector<pair<int, bool>> adj[N];
void upd(int ind) {
swap(mx[0][ind], mx[1][ind]);
swap(mx1[0][ind], mx1[1][ind]);
swap(mx2[0][ind], mx2[1][ind]);
swap(mx3[0][ind], mx3[1][ind]);
lazy[ind] ^= 1;
return;
}
void merge(int i) {
int lc = i * 2, rc = i * 2 + 1;
mn[i] = min(mn[lc], mn[rc]);
mx[0][i] = max(mx[0][lc], mx[0][rc]);
mx1[0][i] = max(mx1[0][lc], mx1[0][rc]);
mx1[0][i] = max(mx1[0][i], mx[0][lc] - 2 * mn[rc]);
mx2[0][i] = max(mx2[0][lc], mx2[0][rc]);
mx2[0][i] = max(mx2[0][i], mx[0][rc] - 2 * mn[lc]);
mx3[0][i] = max(mx3[0][lc], mx3[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][lc] + mx2[0][rc]);
mx3[0][i] = max(mx3[0][i], mx[0][rc] + mx1[0][lc]);
mx[1][i] = max(mx[1][lc], mx[1][rc]);
mx1[1][i] = max(mx1[1][lc], mx1[1][rc]);
mx1[1][i] = max(mx1[1][i], mx[1][lc] - 2 * mn[rc]);
mx2[1][i] = max(mx2[1][lc], mx2[1][rc]);
mx2[1][i] = max(mx2[1][i], mx[1][rc] - 2 * mn[lc]);
mx3[1][i] = max(mx3[1][lc], mx3[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][lc] + mx2[1][rc]);
mx3[1][i] = max(mx3[1][i], mx[1][rc] + mx1[1][lc]);
return;
}
void add(int l, int r, int b = 0, int e = ti, int ind = 1) {
if (e <= l || b >= r) return;
if (l <= b && e <= r) {
upd(ind);
return;
}
if (lazy[ind]) {
upd(ind * 2);
upd(ind * 2 + 1);
lazy[ind] = false;
}
int mid = (b + e) / 2;
add(l, r, b, mid, ind * 2);
add(l, r, mid, e, ind * 2 + 1);
merge(ind);
return;
}
void build(int b = 0, int e = ti, int ind = 1) {
if (b + 1 == e) {
int x = k[b];
mx1[x][ind] = mx2[x][ind] = -h[b];
mx[x][ind] = mn[ind] = h[b];
x = !k[b];
mx[x][ind] = mx1[x][ind] = mx2[x][ind] = mx3[x][ind] = -inf;
return;
}
int mid = (b + e) / 2;
build(b, mid, ind * 2);
build(mid, e, ind * 2 + 1);
merge(ind);
}
void dfs(int u, int hh, bool b) {
h[ti] = hh;
k[ti] = b;
st[u] = ti;
ti++;
for (auto x : adj[u]) {
if (x.first != par[u]) {
par[x.first] = u;
dfs(x.first, hh + 1, b ^ x.second);
h[ti] = hh;
k[ti] = b;
ti++;
}
}
fi[u] = ti;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
bool w;
cin >> x >> y >> w;
x--;
y--;
adj[x].push_back({y, w});
adj[y].push_back({x, w});
e.push_back({x, y});
}
dfs(0, 0, 0);
build();
cin >> q;
while (q--) {
int id;
cin >> id;
id--;
int x = e[id].first;
int y = e[id].second;
if (x == par[y]) swap(x, y);
add(st[x], fi[x]);
cout << max(mx3[0][1], mx3[1][1]) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
int N, tin[maxn], tout[maxn], depth[maxn];
vector<pair<int, int> > adj[maxn];
int change[maxn];
int U[maxn], V[maxn];
int res[maxn];
int Q;
array<int, 2> tr[4 * maxn];
int lazy[4 * maxn];
int nTime = 0;
int pos[maxn];
int stone[maxn];
void prep(int u, int p = -1) {
tin[u] = ++nTime;
pos[nTime] = u;
for (auto& v : adj[u]) {
if (v.first != p) {
stone[v.first] = stone[u] + v.second;
depth[v.first] = depth[u] + 1;
prep(v.first, u);
}
}
tout[u] = nTime;
}
void apply(int id, int l, int r) {
if (!lazy[id]) return;
swap(tr[id][0], tr[id][1]);
if (l != r) {
lazy[id << 1] ^= lazy[id];
lazy[id << 1 | 1] ^= lazy[id];
}
lazy[id] = 0;
}
void add(int id) {
for (int i = 0; i < 2; ++i)
tr[id][i] = max(tr[id << 1][i], tr[id << 1 | 1][i]);
}
void build(int id, int l, int r) {
lazy[id] = 0;
if (l == r) {
tr[id][0] = tr[id][1] = 0;
tr[id][stone[pos[l]] % 2] = depth[pos[l]];
return;
}
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
add(id);
}
void flip(int L, int R, int id = 1, int l = 1, int r = N) {
apply(id, l, r);
if (R < l || r < L) return;
if (L <= l && r <= R) {
lazy[id] ^= 1;
apply(id, l, r);
return;
}
int mid = (l + r) / 2;
flip(L, R, id << 1, l, mid);
flip(L, R, id << 1 | 1, mid + 1, r);
add(id);
}
void solve(int root) {
nTime = 0;
stone[root] = depth[root] = 0;
prep(root);
build(1, 1, N);
for (int i = 1; i <= Q; ++i) {
int id = change[i];
int u = U[id], v = V[id];
if (depth[u] < depth[v]) swap(u, v);
flip(tin[u], tout[u]);
apply(1, 1, N);
res[i] = max(res[i], tr[1][0]);
}
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 1; i < N; ++i) {
int u, v, c;
cin >> u >> v >> c;
adj[u].emplace_back(v, c);
adj[v].emplace_back(u, c);
U[i] = u;
V[i] = v;
}
cin >> Q;
for (int i = 1; i <= Q; ++i) {
cin >> change[i];
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto& v : adj[u]) {
if (v.first != p) {
depth[v.first] = depth[u] + 1;
dfs(v.first, u);
}
}
};
int r1, r2;
auto Diamater = [&](void) {
depth[1] = 0;
dfs(1, -1);
r1 = -1;
for (int i = 1; i <= N; ++i) {
if (r1 == -1 || depth[i] > depth[r1]) r1 = i;
}
depth[r1] = 0;
dfs(r1, -1);
r2 = -1;
for (int i = 1; i <= N; ++i) {
if (r2 == -1 || depth[i] > depth[r2]) {
r2 = i;
}
}
};
Diamater();
solve(r1);
solve(r2);
for (int i = 1; i <= Q; ++i) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ty[500010];
int head[500010], v[500010 << 1], w[500010 << 1], nxt[500010 << 1], tot = 0;
inline void add_edge(int s, int e, int t) {
tot++;
v[tot] = e;
w[tot] = t;
nxt[tot] = head[s];
head[s] = tot;
tot++;
v[tot] = s;
w[tot] = t;
nxt[tot] = head[e];
head[e] = tot;
}
int S, T;
int fuck[500010];
void search(int u, int f, int &node) {
if (fuck[u] > fuck[node]) node = u;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
fuck[v[i]] = fuck[u] + 1;
search(v[i], u, node);
}
}
struct Tree {
int depth[500010], dis[500010], seq[500010], in[500010], dfk = 0;
int L[500010], R[500010];
void dfs(int u, int f) {
dfk++;
in[u] = dfk;
seq[dfk] = u;
for (int i = head[u]; i; i = nxt[i])
if (v[i] ^ f) {
dis[v[i]] = dis[u] + 1;
depth[v[i]] = depth[u] ^ ty[w[i]];
dfs(v[i], u);
L[w[i]] = in[v[i]];
R[w[i]] = dfk;
}
}
int dist[500010 << 2][2], tag[500010 << 2];
void make_tag(int k) {
tag[k] ^= 1;
swap(dist[k][0], dist[k][1]);
}
void push_up(int k) {
for (int i = 0; i < 2; ++i)
dist[k][i] = max(dist[k << 1][i], dist[k << 1 | 1][i]);
}
void push_down(int k) {
if (tag[k]) {
make_tag(k << 1);
make_tag(k << 1 | 1);
tag[k] = 0;
}
}
void Build_Tree(int k, int l, int r) {
if (l == r) {
int u = seq[l];
dist[k][depth[u]] = dis[u];
dist[k][depth[u] ^ 1] = -1;
return;
}
int mid = (l + r) >> 1;
Build_Tree(k << 1, l, mid);
Build_Tree(k << 1 | 1, mid + 1, r);
push_up(k);
}
void Modify(int k, int l, int r, int L, int R) {
if (l == L && r == R) {
make_tag(k);
return;
}
push_down(k);
int mid = (l + r) >> 1;
if (R <= mid)
Modify(k << 1, l, mid, L, R);
else if (mid < L)
Modify(k << 1 | 1, mid + 1, r, L, R);
else {
Modify(k << 1, l, mid, L, mid);
Modify(k << 1 | 1, mid + 1, r, mid + 1, R);
}
push_up(k);
}
void mo(int ed) { Modify(1, 1, n, L[ed], R[ed]); }
int query() { return dist[1][0]; }
} T1, T2;
inline void rd(int &x) {
x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
}
char st[10];
int tp;
void print(int x) {
if (!x)
putchar('0');
else {
while (x) {
st[++tp] = x % 10 + '0';
x /= 10;
}
while (tp) putchar(st[tp--]);
}
}
int main() {
rd(n);
int s, e, t;
for (int i = 1; i < n; ++i) {
rd(s);
rd(e);
rd(t);
ty[i] = t;
add_edge(s, e, i);
}
rd(m);
S = 1;
search(1, 0, S);
T = S;
fuck[T] = 0;
search(S, 0, T);
T1.dfs(S, 0);
T1.Build_Tree(1, 1, n);
T2.dfs(T, 0);
T2.Build_Tree(1, 1, n);
int ed;
while (m--) {
rd(ed);
T1.mo(ed);
T2.mo(ed);
int res = max(T1.query(), T2.query());
print(res);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 10;
const long long inf = 1ll << 60;
const long long mod = 1e9 + 7;
void GG() {
cout << "0\n";
exit(0);
}
long long mpow(long long a, long long n, long long mo = mod) {
long long re = 1;
while (n > 0) {
if (n & 1) re = re * a % mo;
a = a * a % mo;
n >>= 1;
}
return re;
}
long long inv(long long b, long long mo = mod) {
if (b == 1) return b;
return (mo - mo / b) * inv(mo % b, mo) % mo;
}
const int maxn = 5e5 + 5;
vector<pair<int, int> > g[maxn];
int A[maxn], B[maxn], C[maxn];
pair<int, int> bst = {-1, -1};
int n;
void far(int v, int p, int d = 0) {
bst = max(bst, {d, v});
for (pair<int, int> u : g[v]) {
if (u.first != p) {
far(u.first, v, d + 1);
}
}
}
int bot[maxn];
int L[maxn], R[maxn];
bool tg[maxn * 4];
int second[maxn * 4][2];
int mydep[maxn];
int IT = 0;
void push(int o, int l, int r) {
if (tg[o]) {
swap(second[o][0], second[o][1]);
if (l != r) {
tg[o * 2] ^= 1;
tg[o * 2 + 1] ^= 1;
}
tg[o] = 0;
}
}
void FLIP(int L, int R, int o = 1, int l = 0, int r = maxn - 1) {
push(o, l, r);
if (l > R || r < L) return;
if (l >= L && r <= R) {
tg[o] ^= 1;
push(o, l, r);
return;
}
int mid = (l + r) / 2;
FLIP(L, R, o * 2, l, mid);
FLIP(L, R, o * 2 + 1, mid + 1, r);
second[o][0] = max(second[o * 2][0], second[o * 2 + 1][0]);
second[o][1] = max(second[o * 2][1], second[o * 2 + 1][1]);
}
void build(int o, int l, int r) {
if (l == r) {
if (l < n) {
second[o][0] = mydep[l];
}
return;
}
int mid = (l + r) / 2;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
second[o][0] = max(second[o * 2][0], second[o * 2 + 1][0]);
}
void initdfs(int v, int p, int d = 0) {
mydep[IT] = d;
L[v] = R[v] = IT++;
for (pair<int, int> u : g[v]) {
if (u.first != p) {
initdfs(u.first, v, d + 1);
bot[u.second] = u.first;
R[v] = R[u.first];
}
}
}
vector<int> que;
int ANS[maxn];
void go(int rt) {
memset(second, 0, sizeof second);
memset(tg, 0, sizeof tg);
IT = 0;
initdfs(rt, -1);
build(1, 0, maxn - 1);
for (int i = 0; i < n - 1; ++i) {
if (C[i]) {
FLIP(L[bot[i]], R[bot[i]]);
}
}
for (int i = 0; i < (int)que.size(); ++i) {
int x = que[i];
FLIP(L[bot[x]], R[bot[x]]);
;
ANS[i] = max(ANS[i], second[1][0]);
;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
tie(A[i], B[i], C[i]) = tie(a, b, c);
g[a].push_back({b, i});
g[b].push_back({a, i});
}
far(0, -1, 0);
int S1 = bst.second;
bst = {-1, -1};
far(S1, -1, 0);
int S2 = bst.second;
;
int q;
cin >> q;
while (q--) {
int x;
cin >> x;
que.push_back(x - 1);
}
go(S2);
go(S1);
for (int i = 0; i < (int)que.size(); ++i) {
cout << ANS[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, id, w, nxt;
} e[1000010];
int head[500010], tot;
inline void addedge(int u, int v, int w, int id) {
e[++tot] = edge{v, id, w, head[u]};
head[u] = tot;
}
int st[1000010][20], dfn[500010], dep[500010], dfn2[500010], dep2[500010];
int top[500010], id[500010], sze[500010];
int dfsnow1 = 0, dfsnow2 = 0;
void dfs(int u, int fa) {
st[dfn[u] = ++dfsnow1][0] = dep[u] = dep[fa] + 1;
sze[u] = 1;
id[dfn2[u] = ++dfsnow2] = u;
for (int i = head[u]; i; i = e[i].nxt) {
if (e[i].v == fa) continue;
top[e[i].id] = e[i].v;
dep2[e[i].v] = dep2[u] ^ e[i].w;
dfs(e[i].v, u);
sze[u] += sze[e[i].v];
st[++dfsnow1][0] = dep[u];
}
}
int lg2[1000010];
inline void init() {
lg2[0] = -1;
for (int i = 1; i <= dfsnow1; i++) lg2[i] = lg2[i >> 1] + 1;
for (int i = dfsnow1; i > 0; i--) {
for (int j = 1; i + (1 << j) - 1 <= dfsnow1; j++)
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
inline int dis(int u, int v) {
int ans = dep[u] + dep[v];
u = dfn[u], v = dfn[v];
if (u > v) swap(u, v);
int k = lg2[v - u + 1];
return ans - 2 * min(st[u][k], st[v - (1 << k) + 1][k]);
}
struct node {
int a, b, dis;
node() { a = b = dis = 0; }
node(int a, int b, int dis) : a(a), b(b), dis(dis) {}
};
inline node operator+(const node &a, const node &b) {
if (a.a == 0 || b.a == 0) return node(a.a + b.a, a.b + b.b, a.dis + b.dis);
int dis00 = dis(a.a, b.a), dis01 = dis(a.a, b.b), dis10 = dis(a.b, b.a),
dis11 = dis(a.b, b.b);
int newdis =
max(max(max(max(max(dis00, dis01), dis10), dis11), a.dis), b.dis);
if (newdis == a.dis) return a;
if (newdis == b.dis) return b;
if (newdis == dis00) return node(a.a, b.a, newdis);
if (newdis == dis01) return node(a.a, b.b, newdis);
if (newdis == dis10) return node(a.b, b.a, newdis);
if (newdis == dis11) return node(a.b, b.b, newdis);
}
node t1[2000010], t2[2000010];
int tag[2000010];
inline void down(int x) {
if (tag[x]) {
tag[x] = 0;
swap(t1[x << 1], t2[x << 1]);
swap(t1[x << 1 | 1], t2[x << 1 | 1]);
tag[x << 1] ^= 1;
tag[x << 1 | 1] ^= 1;
}
}
inline void up(int x) {
t1[x] = t1[x << 1] + t1[x << 1 | 1];
t2[x] = t2[x << 1] + t2[x << 1 | 1];
}
void modify(int x, int l, int r, int L, int R) {
if (l > R || L > r) return;
if (L <= l && r <= R) {
tag[x] ^= 1;
swap(t1[x], t2[x]);
return;
}
down(x);
int mid = l + r >> 1;
modify(x << 1, l, mid, L, R);
modify(x << 1 | 1, mid + 1, r, L, R);
up(x);
}
void build(int x, int l, int r) {
if (l == r) {
if (dep2[id[l]])
t1[x] = node(id[l], id[l], 0), t2[x] = node(0, 0, 0);
else
t2[x] = node(id[l], id[l], 0), t1[x] = node(0, 0, 0);
return;
}
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
up(x);
}
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
addedge(u, v, w, i);
addedge(v, u, w, i);
}
dfs(1, 0);
init();
build(1, 1, n);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
modify(1, 1, n, dfn2[top[x]], dfn2[top[x]] + sze[top[x]] - 1);
printf("%d\n", max(t1[1].dis, t2[1].dis));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
template <class T>
bool sort2(T &a, T &b) {
return a > b ? swap(a, b), 1 : 0;
}
struct __INIT__ {
__INIT__() {
fill((unsigned char *)&inf, (unsigned char *)&inf + sizeof(inf), 0x3f);
}
} __INIT___;
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 first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
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 (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int n;
int u[500005], v[500005], uv[500005];
bitset<500005> c;
vector<int> to[500005];
bitset<500005> w, ww;
int dep[500005];
int mn[21][1000005], t;
int st[1000005];
int dfn[500005], low[500005], d;
int id[500005];
void dfs(int first, int f) {
mn[0][st[first] = ++t] = dep[first];
ww[dfn[first] = ++d] = w[first];
id[d] = first;
for (auto i : to[first])
if (i != f) {
if (v[i] == first) swap(u[i], v[i]);
w[uv[i] ^ first] = w[first] ^ c[i];
dep[uv[i] ^ first] = dep[first] + 1;
mn[0][++t] = dep[first];
dfs(uv[i] ^ first, i);
}
low[first] = d;
}
int lg[1000005];
void init() {
for (int i = 2; i <= t; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; (1 << i) <= t; ++i)
for (int j = 1; j + (1 << i) - 1 <= t; ++j)
mn[i][j] = mmin(mn[i - 1][j], mn[i - 1][j + (1 << (i - 1))]);
}
int query(int l, int r) {
if (l > r) swap(l, r);
int h = lg[r - l + 1];
return mmin(mn[h][l], mn[h][r - (1 << h) + 1]);
}
int dist(int first, int second) {
return dep[first] + dep[second] - (query(st[first], st[second]) << 1);
}
struct xmx {
int s, u, v;
xmx() {}
xmx(int s, int u, int v) : s(s), u(u), v(v) {}
xmx(int u, int v) : u(u), v(v) { s = dist(u, v); }
xmx(int u) : s(0), u(u), v(u) {}
void merge(int first) {
if (!~first) return;
if (!~u) {
u = v = first;
s = 0;
return;
}
int xu = u, xv = v;
if (chkmax(s, dist(first, xu))) {
u = xu;
v = first;
}
if (chkmax(s, dist(first, xv))) {
u = first;
v = xv;
}
}
void merge(xmx b) {
if (b.u) merge(b.u);
if (b.v != b.u) merge(b.v);
}
};
xmx operator+(const xmx &a, const xmx &b) {
xmx c = a;
c.merge(b);
return c;
}
struct smt {
int ls, rs, rev;
xmx mx0, mx1;
smt *l, *r;
smt() {}
smt(int, int);
void putrev() {
rev ^= 1;
swap(mx0, mx1);
}
void reverse(int la, int ra) {
if (la <= ls && rs <= ra) {
putrev();
return;
}
if (rev) {
l->putrev();
r->putrev();
rev = 0;
}
if (la <= l->rs) l->reverse(la, ra);
if (r->ls <= ra) r->reverse(la, ra);
mx0 = l->mx0 + r->mx0;
mx1 = l->mx1 + r->mx1;
}
};
smt *rt, node[1000005], *at = node;
smt *newsmt(int la, int ra) {
smt *rt = ++at;
*rt = smt(la, ra);
return rt;
}
smt::smt(int la, int ra) {
ls = la;
rs = ra;
rev = 0;
if (ls == rs) {
if (ww[ls])
mx1 = id[ls], mx0 = -1;
else
mx0 = id[ls], mx1 = -1;
l = r = 0;
return;
}
int mid = (ls + rs) >> 1;
l = newsmt(ls, mid);
r = newsmt(mid + 1, rs);
mx0 = l->mx0 + r->mx0;
mx1 = l->mx1 + r->mx1;
}
signed main() {
int q;
read(n);
int w = 0;
for (int i = 1; i < n; ++i) {
read(u[i], v[i], w);
c[i] = w;
uv[i] = u[i] ^ v[i];
to[u[i]].emplace_back(i);
to[v[i]].emplace_back(i);
}
dfs(1, 0);
init();
read(q);
rt = newsmt(1, n);
for (; q; --q) {
int first;
read(first);
rt->reverse(dfn[v[first]], low[v[first]]);
write(mmax(rt->mx0.s, rt->mx1.s), '\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 55;
struct edge {
int to, col, id;
};
vector<edge> g[N];
int V = -1, d[N], n, ans[N], x[N];
void dfsdv(int v = 1, int p = -1) {
if (V == -1 || d[v] > d[V]) V = v;
for (edge i : g[v])
if (i.to != p) {
d[i.to] = d[v] + 1;
dfsdv(i.to, v);
}
}
int tin[N], tout[N], timer, c[N], who[N], val[N];
pair<int, int> what[N];
void dfs(int v, int p = -1) {
tin[v] = timer++;
for (edge i : g[v])
if (i.to != p) {
d[i.to] = d[v] + 1;
who[i.id] = i.to;
c[i.to] = (c[v] ^ i.col);
dfs(i.to, v);
}
tout[v] = timer;
}
int q[N << 2];
pair<int, int> w[N << 2][2];
void build(int l = 0, int r = n, int v = 1) {
q[v] = 0;
w[v][0] = w[v][1] = {0, 0};
if (r - l == 1) {
w[v][val[l]] = what[l];
return;
}
int m = (l + r) >> 1;
build(l, m, v << 1);
build(m, r, v << 1 | 1);
w[v][0] = max(w[v << 1][0], w[v << 1 | 1][0]);
w[v][1] = max(w[v << 1][1], w[v << 1 | 1][1]);
}
void push(int v, int l, int r) {
if (q[v]) {
swap(w[v][0], w[v][1]);
q[v] = 0;
if (r - l == 1) return;
q[v << 1] ^= 1;
q[v << 1 | 1] ^= 1;
}
}
void upd(int L, int R, int l = 0, int r = n, int v = 1) {
push(v, l, r);
if (l >= R || L >= r) return;
if (L <= l && r <= R) {
q[v] ^= 1;
push(v, l, r);
return;
}
int m = (l + r) >> 1;
upd(L, R, l, m, v << 1);
upd(L, R, m, r, v << 1 | 1);
w[v][0] = max(w[v << 1][0], w[v << 1 | 1][0]);
w[v][1] = max(w[v << 1][1], w[v << 1 | 1][1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; ++i) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back({b, c, i});
g[b].push_back({a, c, i});
}
d[1] = 1;
dfsdv(1);
cerr << V << " V\n";
d[V] = 1;
dfs(V);
for (int i = 1; i <= n; ++i) {
val[tin[i]] = c[i];
what[tin[i]] = {d[i], i};
}
build();
int q;
cin >> q;
for (int i = 1; i <= q; ++i) {
cin >> x[i];
int v = who[x[i]];
upd(tin[v], tout[v]);
push(1, 0, n);
ans[i] = w[1][0].first;
}
timer = 0;
d[V] = 1;
dfsdv(V);
cerr << V << " V\n";
c[V] = 0;
d[V] = 1;
dfs(V);
for (int i = 1; i <= n; ++i) {
val[tin[i]] = c[i];
what[tin[i]] = {d[i], i};
}
build();
for (int i = 1; i <= q; ++i) {
int v = who[x[i]];
upd(tin[v], tout[v]);
push(1, 0, n);
cout << max(ans[i], w[1][0].first) - 1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class node>
struct link_cut_tree {
void link(node* u, node* v) {
access(v);
access(u);
set_link(v, u, 0);
v->update();
}
void access(node* u) {
for (node *v = u, *pre = NULL; v; v = v->p) {
v->splay();
if (pre) v->update_vsub(pre, false);
if (v->ch[1]) v->update_vsub(v->ch[1], true);
v->ch[1] = pre;
v->update();
pre = v;
}
u->splay();
assert(!u->ch[1]);
}
node* operator[](int i) { return &data[i]; }
int operator[](node* i) { return i - &data[0]; }
vector<node> data;
link_cut_tree(int n) : data(n) {}
};
template <typename pnode>
struct splay_tree {
pnode ch[2], p;
splay_tree() { ch[0] = ch[1] = p = NULL; }
virtual void update() {}
virtual void push() {}
int dir() {
if (!p) return -2;
if (p->ch[0] == this) return 0;
if (p->ch[1] == this) return 1;
return -1;
}
bool is_root() { return dir() < 0; }
friend void set_link(pnode u, pnode v, int d) {
if (v) v->p = u;
if (d >= 0) u->ch[d] = v;
}
void rotate() {
assert(!is_root());
int x = dir();
pnode g = p;
set_link(g->p, static_cast<pnode>(this), g->dir());
set_link(g, ch[x ^ 1], x);
set_link(static_cast<pnode>(this), g, x ^ 1);
g->update();
}
void splay() {
while (!is_root() && !p->is_root()) {
p->p->push(), p->push(), push();
dir() == p->dir() ? p->rotate() : rotate();
rotate();
}
if (!is_root()) p->push(), push(), rotate();
push();
update();
}
};
const int inf = -1e8;
const array<int, 4> ainf = {0, inf, 0, inf};
struct node : splay_tree<node*> {
bool val, len, sval;
int slen;
int x;
array<int, 4> pp;
priority_queue<int> vx, dvx;
array<priority_queue<int>, 2> vp, dvp;
node() : splay_tree() {
val = len = sval = 0;
slen = x = 0;
pp = ainf;
}
template <typename T>
void fix(priority_queue<T>& p, priority_queue<T>& d) {
while (!d.empty() && p.top() == d.top()) p.pop(), d.pop();
}
void update() override {
splay_tree::update();
x = 0;
sval = val;
slen = len;
array<int, 4> up = ainf, dw = ainf;
array<int, 2> v1 = {0, inf}, v2 = v1;
bool upsval = val;
int upslen = len;
bool dwsval = val;
int dwslen = len;
if (ch[0]) {
x = max(x, ch[0]->x);
up = ch[0]->pp;
sval ^= ch[0]->sval;
slen += ch[0]->slen;
upsval ^= ch[0]->sval;
upslen += ch[0]->slen;
}
if (ch[1]) {
x = max(x, ch[1]->x);
dw = ch[1]->pp;
sval ^= ch[1]->sval;
slen += ch[1]->slen;
dwsval ^= ch[1]->sval;
dwslen += ch[1]->slen;
}
if (!vx.empty()) {
x = max(x, vx.top());
}
if (!vp[0].empty()) {
v1[0] = vp[0].top();
v1[1] = vp[1].top();
if (!val) {
vp[0].pop();
vp[1].pop();
fix(vp[0], dvp[0]);
fix(vp[1], dvp[1]);
if (!vp[0].empty()) {
v2[0] = vp[0].top();
v2[1] = vp[1].top();
}
vp[0].push(v1[0]);
vp[1].push(v1[1]);
}
}
pp[0] = up[0], pp[1] = up[1];
pp[2] = dw[2], pp[3] = dw[3];
for (int i = 0; i < 2; ++i) {
x = max(x, len + max({up[2 + i] + dw[i ^ val], up[2 + i] + v1[i ^ val],
dw[i] + v1[i ^ val], v1[i] + v2[i ^ val]}));
pp[i ^ upsval] = max(pp[i ^ upsval], upslen + max(dw[i], v1[i]));
pp[2 + (i ^ dwsval)] =
max(pp[2 + (i ^ dwsval)], dwslen + max(up[2 + i], v1[i]));
}
}
void update_vsub(node* v, bool add) {
if (add) {
vx.push(v->x);
vp[0].push(v->pp[0]);
vp[1].push(v->pp[1]);
} else {
dvx.push(v->x);
dvp[0].push(v->pp[0]);
dvp[1].push(v->pp[1]);
fix(vx, dvx);
fix(vp[0], dvp[0]);
fix(vp[1], dvp[1]);
}
}
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
link_cut_tree<node> lct(2 * n);
vector<vector<tuple<int, bool, int>>> adj(n);
for (int i = 1, u, v, w; i < n; ++i) {
cin >> u >> v >> w;
--u, --v;
adj[u].push_back({v, w, i});
adj[v].push_back({u, w, i});
}
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [v, w, i] : adj[u])
if (v != p) {
dfs(v, u);
lct[n + i]->val = w;
lct[n + i]->len = true;
lct[n + i]->update();
lct.link(lct[u], lct[n + i]);
lct.link(lct[n + i], lct[v]);
}
};
dfs(0, -1);
int q;
cin >> q;
for (int i = 0, u; i < q; ++i) {
cin >> u;
lct.access(lct[n + u]);
lct[n + u]->val ^= 1;
lct[n + u]->update();
cout << lct[n + u]->x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, m;
vector<pair<int, int>> g[N];
int eu[N], ev[N], et[N];
int in[N], out[N], rin[N], dfst;
int start[N], tour[2 * N], id[2 * N], dfs_time;
int dn[2 * N][20];
int fn(int i, int j) {
if (j == 0) return tour[i];
if (~dn[i][j]) return dn[i][j];
return dn[i][j] = min(fn(i, j - 1), fn(i + (1 << (j - 1)), j - 1));
}
int lg(int x) { return 31 - __builtin_clz(x); }
int getmn(int l, int r) {
int lz = lg(r - l + 1);
return min(fn(l, lz), fn(r - (1 << lz) + 1, lz));
}
int LCA(int u, int v) {
if (start[u] > start[v]) swap(u, v);
return id[getmn(start[u], start[v])];
}
int val[N], lvl[N];
void dfs(int u, int p) {
start[u] = dfs_time;
id[dfs_time] = u;
tour[dfs_time++] = start[u];
in[u] = ++dfst;
rin[in[u]] = u;
for (auto [v, w] : g[u])
if (v != p) {
val[v] = val[u] ^ w;
lvl[v] = lvl[u] + 1;
dfs(v, u);
id[dfs_time] = u;
tour[dfs_time++] = start[u];
}
out[u] = dfst;
}
struct Diam {
int a = -1, b = -1;
int len = 0;
Diam(int l = -1, int r = -1) : a(l), b(r) {
if (a != -1 and b != -1) {
len = lvl[a] + lvl[b] - 2 * lvl[LCA(a, b)];
} else if (a == -1 and b == -1) {
len = -1;
}
}
Diam operator+(const Diam &o) const {
Diam ans = max(*this, o);
if (a != -1 and o.a != -1) ans = max(ans, Diam(a, o.a));
if (a != -1 and o.b != -1) ans = max(ans, Diam(a, o.b));
if (b != -1 and o.a != -1) ans = max(ans, Diam(b, o.a));
if (b != -1 and o.b != -1) ans = max(ans, Diam(b, o.b));
return ans;
}
bool operator<(const Diam &o) const { return len < o.len; }
void print() const { printf("a = %d; b = %d; len = %d\n", a, b, len); }
};
Diam st[4 * N][2];
int lz[4 * N];
void prop(int p, int L, int R) {
if (lz[p]) {
swap(st[p][0], st[p][1]);
if (L < R) {
lz[2 * p] ^= 1;
lz[2 * p + 1] ^= 1;
}
lz[p] = 0;
}
}
void upd(int p, int L, int R, int i, int j) {
prop(p, L, R);
if (i > R or j < L) return;
if (L >= i and R <= j) {
lz[p] = 1;
prop(p, L, R);
return;
}
int mid = (L + R) / 2;
upd(2 * p, L, mid, i, j);
upd(2 * p + 1, mid + 1, R, i, j);
st[p][0] = st[2 * p][0] + st[2 * p + 1][0];
st[p][1] = st[2 * p][1] + st[2 * p + 1][1];
}
void build(int p, int L, int R) {
if (L == R) {
int u = rin[L];
st[p][val[u]] = Diam(u);
return;
}
int mid = (L + R) / 2;
build(2 * p, L, mid);
build(2 * p + 1, mid + 1, R);
st[p][0] = st[2 * p][0] + st[2 * p + 1][0];
st[p][1] = st[2 * p][1] + st[2 * p + 1][1];
}
void print(int p, int L, int R) {
printf("p = %d; L = %d; R = %d\n", p, L, R);
st[p][0].print(), st[p][1].print();
printf("\n");
if (L == R) {
return;
}
int mid = (L + R) / 2;
print(2 * p, L, mid);
print(2 * p + 1, mid + 1, R);
}
int main() {
memset(dn, -1, sizeof dn);
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", eu + i, ev + i, et + i);
g[eu[i]].emplace_back(ev[i], et[i]);
g[ev[i]].emplace_back(eu[i], et[i]);
}
dfs(1, 1);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
int i;
scanf("%d", &i);
int u = lvl[eu[i]] < lvl[ev[i]] ? ev[i] : eu[i];
upd(1, 1, n, in[u], out[u]);
printf("%d\n", max(st[1][0].len, st[1][1].len));
}
}
|
#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>
const int maxn = 500005, maxm = maxn << 1;
int n, m, e, maxdis, pos, rt0, rt1;
int start[maxn], to[maxm], then[maxm], worth[maxm], dfn[2][maxn], size[2][maxn],
dep[2][maxn], dis[maxn], cnt[2], val[2][maxn], id[maxm], g[2][maxn],
dfnp[2][maxn];
inline int max(int a, int b) { return a > b ? a : b; }
inline void swp(int &a, int &b) { a += b, b = a - b, a -= b; }
struct SegTree {
int maxx[2][maxn << 2], lazy[maxn << 2], lc[maxn << 2], rc[maxn << 2];
inline void pushup(int now) {
maxx[0][now] = max(maxx[0][lc[now]], maxx[0][rc[now]]);
maxx[1][now] = max(maxx[1][lc[now]], maxx[1][rc[now]]);
}
inline void getlazy(int now) {
swp(maxx[0][now], maxx[1][now]), lazy[now] ^= 1;
}
inline void pushdown(int now) {
if (lazy[now] == 0) return;
getlazy(lc[now]), getlazy(rc[now]);
lazy[now] = 0;
}
void build(int l, int r, int now, int t) {
lazy[now] = 0;
if (l == r) {
maxx[0][now] = dep[t][dfnp[t][l]] - 1, maxx[1][now] = 0;
return;
}
int mid = (l + r) >> 1;
lc[now] = now << 1, rc[now] = now << 1 | 1;
build(l, mid, lc[now], t), build(mid + 1, r, rc[now], t);
pushup(now);
}
void update(int l, int r, int now, int L, int R) {
if (L <= l && r <= R) {
getlazy(now);
return;
}
int mid = (l + r) >> 1;
pushdown(now);
if (L <= mid) update(l, mid, lc[now], L, R);
if (mid < R) update(mid + 1, r, rc[now], L, R);
pushup(now);
}
int query(int l, int r, int now, int pos) {
if (l == r) return maxx[0][now];
int mid = (l + r) >> 1;
pushdown(now);
if (pos <= mid) return query(l, mid, lc[now], pos);
return query(mid + 1, r, rc[now], pos);
}
void print(int l, int r, int now) {
pushdown(now);
if (l == r) return;
int mid = (l + r) >> 1;
print(l, mid, lc[now]), print(mid + 1, r, rc[now]);
}
} S0, S1;
inline void add(int x, int y, int z, int i) {
then[++e] = start[x], start[x] = e, to[e] = y, worth[e] = z, id[e] = i;
}
void dfs1(int x, int last) {
dis[x] = dis[last] + 1;
if (dis[x] > maxdis) maxdis = dis[x], pos = x;
for (int i = start[x]; i; i = then[i]) {
int y = to[i];
if (y == last) continue;
dfs1(y, x);
}
}
void dfs2(int x, int last, int t) {
dep[t][x] = dep[t][last] + 1, size[t][x] = 1, dfn[t][x] = ++cnt[t],
dfnp[t][cnt[t]] = x;
for (int i = start[x]; i; i = then[i]) {
int y = to[i];
if (y == last) continue;
val[t][y] = worth[i], dfs2(y, x, t);
size[t][x] += size[t][y];
g[t][id[i]] = y;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z, i), add(y, x, z, i);
}
dis[1] = 0, maxdis = pos = 0;
dfs1(1, 0), rt0 = pos;
dis[rt1] = 0, maxdis = pos = 0;
dfs1(rt0, 0), rt1 = pos;
dfs2(rt0, 0, 0), dfs2(rt1, 0, 1);
S0.build(1, n, 1, 0), S1.build(1, n, 1, 1);
for (int i = 1; i <= n; i++) {
if (val[0][i]) S0.update(1, n, 1, dfn[0][i], dfn[0][i] + size[0][i] - 1);
if (val[1][i]) S1.update(1, n, 1, dfn[1][i], dfn[1][i] + size[1][i] - 1);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p, x, y;
scanf("%d", &p);
x = g[0][p], y = g[1][p];
S0.update(1, n, 1, dfn[0][x], dfn[0][x] + size[0][x] - 1);
S1.update(1, n, 1, dfn[1][y], dfn[1][y] + size[1][y] - 1);
printf("%d\n", max(S0.maxx[0][1], S1.maxx[0][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const long long mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n;
vector<pair<int, int> > v[N];
int get(int st) {
queue<int> q;
vector<int> d(n + 1, 1e9);
d[st] = 0;
q.push(st);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto y : v[x]) {
if (d[y.first] == 1e9) {
d[y.first] = d[x] + 1;
q.push(y.first);
}
}
}
int id = 1;
for (int i = 1; i <= n; i++) {
if (d[i] > d[id]) {
id = i;
}
}
return id;
}
struct tr {
int G, ch[N];
int t[4 * N];
int f[4 * N], lz[4 * N];
int d[N], c[N];
int tin[N], tout[N];
void meg(int &x) {
t[x] = max(t[x + x], t[x + x + 1]);
f[x] = max(f[x + x], f[x + x + 1]);
}
void dfs(int x, int par) {
tin[x] = ++G;
ch[G] = x;
for (auto y : v[x]) {
if (y.first != par) {
d[y.first] = d[x] + 1;
c[y.first] = (c[x] ^ y.second);
dfs(y.first, x);
}
}
tout[x] = G;
}
void build(int x, int l, int r) {
if (l == r) {
if (c[ch[l]] == 0) {
f[x] = d[ch[l]];
} else
t[x] = d[ch[l]];
return;
}
int m = (l + r) / 2;
build(x + x, l, m);
build(x + x + 1, m + 1, r);
meg(x);
}
void push(int &x) {
if (lz[x]) {
lz[x + x] ^= 1;
lz[x + x + 1] ^= 1;
swap(t[x + x], f[x + x]);
swap(t[x + x + 1], f[x + x + 1]);
lz[x] = 0;
}
}
void upd(int x, int l, int r, int tl, int tr) {
if (tl > tr) return;
if (l == tl && r == tr) {
lz[x] ^= 1;
swap(t[x], f[x]);
return;
}
push(x);
int m = (l + r) / 2;
upd(x + x, l, m, tl, min(tr, m));
upd(x + x + 1, m + 1, r, max(tl, m + 1), tr);
meg(x);
}
} D[2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
vector<pair<int, int> > g;
for (int i = 1; i < n; i++) {
int x, y, t;
cin >> x >> y >> t;
g.push_back({x, y});
v[x].push_back({y, t});
v[y].push_back({x, t});
}
int x = get(1);
int y = get(x);
D[0].dfs(x, x);
D[1].dfs(y, y);
D[0].build(1, 1, n);
D[1].build(1, 1, n);
int q;
cin >> q;
while (q--) {
int h;
cin >> h;
int x = g[h - 1].first, y = g[h - 1].second;
D[0].upd(1, 1, n, max(D[0].tin[x], D[0].tin[y]),
min(D[0].tout[x], D[0].tout[y]));
D[1].upd(1, 1, n, max(D[1].tin[x], D[1].tin[y]),
min(D[1].tout[x], D[1].tout[y]));
cout << max(D[0].f[1], D[1].f[1]) << "\n";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.