text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (n / 2) + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[] = {0, 1, 0, -1};
int y[] = {1, 0, -1, 0};
long long gcd(long long a, long long b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
long long fastpow(long long a, long long b) {
if (b == 0) return 1ll;
if (b == 1) return a;
long long sw;
if (b % 2 == 1)
sw = a;
else
sw = 1;
long long h = fastpow(a, b / 2);
return h * h * sw;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie();
long long a, b, c, d, n, t, m, k;
cin >> t;
while (t--) {
cin >> n;
cout << n / 2 + 1 << endl;
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long scan() {
long long x;
cin >> x;
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
t = scan();
while (t--) {
cout << (scan() / 2) + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long testcases = 1;
cin >> testcases;
while (testcases--) {
long long n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
} else if (n == 2) {
cout << 2 << endl;
} else {
if (n % 2 == 0) {
cout << (n / 2) + 1 << endl;
} else {
cout << (n / 2) + 1 << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pi = std::pair<int, int>;
using pill = std::pair<int, ll>;
using plli = std::pair<ll, int>;
using pll = std::pair<ll, ll>;
using pld = std::pair<ld, ld>;
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vull = std::vector<ull>;
using vld = std::vector<ld>;
using vpi = std::vector<pi>;
using vpill = std::vector<pill>;
using vplii = std::vector<plli>;
using vpll = std::vector<pll>;
using vpld = std::vector<pld>;
using vvi = std::vector<vi>;
using vvll = std::vector<vll>;
using vvvi = std::vector<vvi>;
using vvpi = std::vector<vpi>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using si = std::set<int>;
using sll = std::set<ll>;
using sull = std::set<ull>;
using spi = std::set<pi>;
const int MAX_INT = std::numeric_limits<int>::max();
const int MXI = 1e9;
const ll MAX_LL = std::numeric_limits<long long>::max();
const ull MAX_ULL = std::numeric_limits<unsigned long long>::max();
const ll MXLL = 1e18;
template <typename T1, typename T2, typename T3>
class triple {
public:
T1 first;
T2 second;
T3 third;
constexpr triple() {}
constexpr triple(const T1& first, const T2& second, const T3& third)
: first(first), second(second), third(third) {}
triple(const triple& t) = default;
triple(triple&& t) = default;
triple& operator=(const triple& t) {
first = t.first;
second = t.second;
third = t.third;
return *this;
}
bool operator==(const triple& t) const {
return first == t.first && second == t.second && third == t.third;
}
bool operator!=(const triple& t) const { return !(*this == t); }
bool operator<(const triple& t) const {
if (first == t.first) {
if (second == t.second) return third < t.third;
return second < t.second;
}
return first < t.first;
}
bool operator>(const triple& t) const {
if (first == t.first) {
if (second == t.second) return third > t.third;
return second > t.second;
}
return first > t.first;
}
bool operator<=(const triple& t) const { return !(*this > t); }
bool operator>=(const triple& t) const { return !(*this < t); }
friend std::ostream& operator<<(std::ostream& os, const triple& t) {
return os << t.first << ' ' << t.second << ' ' << t.third;
}
};
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
return os << p.first << ' ' << p.second;
}
template <typename... T, template <typename...> class Container,
typename std::enable_if<!std::is_same<
Container<T...>, std::string>::value>::type* = nullptr>
std::ostream& operator<<(std::ostream& os, const Container<T...>& c) {
for (auto&& x : c) os << x << ' ';
return os;
}
template <typename T,
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
inline void getcx(T& var) {
var = 0;
register char c = getchar();
register T sgn = 1;
while (c < '0' || c > '9') {
if (c == '-') sgn *= -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
var = (var << 3) + (var << 1) + c - '0';
c = getchar();
}
var *= sgn;
}
template <typename T,
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
inline void putcx(T var) {
if (var == 0) {
putchar('0');
putchar(' ');
return;
}
register T rev = 0;
register int zeros = 0;
while (var % 10 == 0) {
zeros++;
var /= 10;
}
while (var) {
rev = (rev << 3) + (rev << 1) + (var % 10);
var /= 10;
}
while (rev) {
putchar(rev % 10 + '0');
rev /= 10;
}
while (zeros--) putchar('0');
}
int t;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> t;
while (t--) {
int n;
std::cin >> n;
std::cout << n / 2 + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << (n / 2 + 1) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n <= 2)
cout << n;
else {
cout << n / 2 + 1;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int tc, x;
scanf("%d", &tc);
while (tc--) {
scanf("%d", &x);
x = x / 2 + 1;
printf("%d\n", x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<long long, long long>;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void solve() {
long long n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
} else {
cout << (n / 2) + 1 << endl;
}
}
int main() {
int t;
cin >> t;
for (int i = (0), i_len = (t); i < i_len; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
void sol() {
int n;
cin >> n;
cout << (n / 2 + 1) << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long ttt;
cin >> ttt;
while (ttt--) {
sol();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
void test_case() {
int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) test_case();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(1e5 + 3);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (n / 2) + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print1D(vector<long long> &v) {
cout << "Debug Array: ";
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "-----------------------------\n";
}
void print2D(vector<vector<long long>> &v) {
cout << "Debug2d: ";
long long n = v.size(), m = v[0].size();
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
cout << v[i][j] << " ";
}
cout << "\n";
;
}
cout << "--------------------------------------\n";
}
void printS(string &s) {
long long l = s.length(), i;
cout << "String: ";
for (i = 0; i < l; i++) {
cout << s[i];
}
cout << "\n---------------------------------------\n";
}
void vectorInput(vector<long long> &v) {
long long n = v.size();
long long x, y, z;
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
}
void pairInput(vector<pair<long long, long long>> &vp) {
long long n = vp.size(), i, j, k;
for (i = 0; i < n; i++) {
cin >> j >> k;
vp[i] = {j, k};
}
}
void swap(long long &a, long long &b) {
long long t = a;
a = b;
b = t;
}
long long solution(long long &n) {
cout << n / 2 + 1 << "\n";
;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long test = 1;
cin >> test;
while (test--) {
long long n, i, j, k, q;
cin >> n;
solution(n);
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int i, j, k, n, f = 0, c = 0, mx, mn, ans = 0;
vector<int> vec;
cin >> n;
cout << n / 2 + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxlimit = 1e5 + 2;
const long long int inf = 1e12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
long long int n, ans;
while (t--) {
cin >> n;
cout << n / 2 + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int size;
cin >> size;
cout << size / 2 + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
const long long mod = 998244353;
const int inf = 0x7fffffff;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << n / 2 + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("AAtest.in.txt");
long long k, n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> k;
while (k--) {
cin >> n;
cout << (n / 2) + 1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1) {
cout << 1 << endl;
continue;
}
if (n == 2) {
cout << 2 << endl;
continue;
}
if (n & 1) {
cout << 1 + (n - 1) / 2 << endl;
} else {
cout << 2 + (n - 2) / 2 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using big = long long;
const int N = 200200;
int main() {
ios_base::sync_with_stdio(false);
int cas;
cin >> cas;
while (cas--) {
int n;
cin >> n;
cout << (n / 2) + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ans = n >> 1;
cout << ans + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
if ((n + 1 / 2) % 2 == 0)
cout << ((n + 1) / 2 - 1) + 2 << endl;
else {
cout << (n + 1) / 2 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << n / 2 + 1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 50;
const long long mod = 1e9 + 7;
const double E = 1e-9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 1)
cout << 1 << '\n';
else
cout << n / 2 + 1 << '\n';
}
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, a[101], i, d;
scanf("%d\n", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
d = a[i] / 2 + 1;
printf("%d\n", d);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
while (n--) {
cin >> m;
if (m % 2 == 1)
cout << (m + 1) / 2 << endl;
else
cout << 1 + m / 2 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n == 1)
cout << "1\n";
else
cout << n / 2 + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
int T, n;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
printf("%d\n", n / 2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int main() {
int TC;
scanf("%d", &TC);
for (int tc = 1; tc <= TC; tc++) {
int n;
scanf("%d", &n);
printf("%d\n", n / 2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
unsigned long long int n;
cin >> n;
cout << n / 2 + 1 << endl;
return;
}
int main() {
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
printf("%d\n", n / 2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int power(int x, unsigned int y, int p) {
int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie();
int t, n;
cin >> t;
while (t--) {
cin >> n;
cout << (n + 2) / 2 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int test;
cin >> test;
while (test--) {
long long int n;
cin >> n;
n += 1;
long long int d = (ceil)(n / 2.0);
cout << d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
scanf("%lld", &t);
while (t--) {
long long n;
cin >> n;
long long ans = n / 2;
ans++;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int INF = 1000000000;
void solve() {
int n;
scanf("%d", &n);
int ans = 1 + n / 2;
printf("%d\n", ans);
}
int main() {
int t;
scanf("%d", &t);
for (int tc = 1; tc <= t; ++tc) {
solve();
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const int N = 1e2 + 10;
const int M = 1e5 + 100;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, k, x, y, t;
void solve() {
scanf("%d", &n);
printf("%d\n", n / 2 + 1);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T = 1;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long powmod(long long a, long long b, long long p) {
long long res = 1;
a %= p;
while (b) {
if (b & 1) res = res * a % p;
a = a * a % p;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int _;
int main() {
for (scanf("%d", &_); _; _--) {
int n;
scanf("%d", &n);
if (n == 1) {
puts("1");
} else if (n == 2 || n == 3) {
puts("2");
} else {
int x;
if (n % 2) {
x = n - 3 >> 1;
x += 2;
} else {
x = n - 2 >> 1;
x += 2;
}
printf("%d\n", x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
long long int MOD = 998244353;
long long int NUM = 1e9 + 7;
void solve() {
int n;
cin >> n;
cout << (n / 2) + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n;
int sovle(int x) {
if (x % 2 == 1)
return (x + 1) / 2;
else
return (x + 2) / 2;
}
int main() {
cin >> t;
while (t--) {
cin >> n;
cout << sovle(n) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, tc, x, y, u, v;
const int ms = 2e5 + 10;
int32_t main() {
cin >> tc;
while (tc--) {
cin >> n;
if (n == 1 || n == 2) {
cout << n << "\n";
continue;
}
cout << 2 + (n - 2) / 2 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e9 + 5;
const long long MOD = 2147483648;
const int INF = 0x3f;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long qpw(long long a, long long b, long long p) {
a %= p;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % p;
a = a * a % p;
b >>= 1;
}
return ans % p;
}
int cc;
int main() {
cin >> cc;
while (cc--) {
long long n;
cin >> n;
cout << n / 2 + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000001;
long long highp2(long long n) { return (n & (~(n - 1))); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long binarysearchlf(long long l, long long h, vector<long long> &a,
long long k) {
while (l < h) {
long long mid = l + ((h - l + 1) / 2);
if (a[mid] < k)
l = mid;
else
h = mid - 1;
}
return l;
}
long long binarysearchft(long long l, long long h, vector<long long> &a,
long long k) {
while (l < h) {
long long mid = l + ((h - l) / 2);
if (a[mid] < k)
l = mid + 1;
else
h = mid;
}
return l;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return (b, a % b);
}
string getstring(long long k, char x) {
string s(k, x);
return s;
}
bool sort1(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sort2(const vector<int> &v1, const vector<int> &v2) {
if (v1[1] > v2[1])
return true;
else if (v1[1] < v2[1])
return false;
else {
return v1[2] > v2[2];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (n / 2) + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a = floor(n / 2);
cout << (a + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (n / 2 + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << n / 2 + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, o, n;
int main() {
cin >> t;
for (o = 0; o < t; o++) {
cin >> n;
cout << n / 2 + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
cout << (n / 2 + 1) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
T res = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
res = (res << 3) + (res << 1) + c - '0';
c = getchar();
}
x = res * f;
}
const long long N = 200000 + 10;
int t, n;
int main() {
read(t);
while (t--) {
read(n);
printf("%d\n", n / 2 + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using LD = long double;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using PLD = pair<LD, LD>;
using VI = vector<int>;
using VLL = vector<LL>;
using VLD = vector<LD>;
using VPII = vector<PII>;
using VPLL = vector<PLL>;
using VPLD = vector<PLD>;
using VVI = vector<VI>;
const int inf = 1e9 + 7;
const int MOD = 998244353;
const LL INF = 1e18 + 7;
const long double PI = acos(-1);
const LD EPS = 1e-9;
namespace input {
template <class T>
istream& operator>>(istream& st, vector<T>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T, size_t N>
istream& operator>>(istream& st, array<T, N>& container) {
for (auto& u : container) st >> u;
return st;
}
template <class T, class U>
istream& operator>>(istream& st, pair<T, U>& p) {
st >> p.first >> p.second;
return st;
}
void re() {}
template <typename T, typename... TArgs>
void re(T& x, TArgs&... rest) {
cin >> x;
re(rest...);
}
} // namespace input
using namespace input;
namespace output {
template <class T>
ostream& operator<<(ostream& st, const vector<T>& container) {
for (auto& u : container) st << u << ' ';
return st;
}
template <class T, size_t N>
ostream& operator<<(ostream& st, const array<T, N>& container) {
for (auto& u : container) st << u << ' ';
return st;
}
template <class T, class U>
ostream& operator<<(ostream& st, pair<T, U> p) {
st << p.first << ' ' << p.second;
return st;
}
void pr() {}
template <typename T>
void pr(const T& x) {
cout << x;
}
template <typename T, typename... TArgs>
void pr(const T& x, const TArgs&... rest) {
cout << x << ' ';
pr(rest...);
}
template <typename... TArgs>
void prln(const TArgs&... args) {
pr(args...);
cout << '\n';
}
} // namespace output
using namespace output;
namespace pairs {
template <class T, class U, class V>
pair<T, U> operator*(pair<T, U> p, V val) {
return {p.first * val, p.second * val};
}
template <class T, class U, class V>
pair<T, U> operator/(pair<T, U> p, V val) {
return {p.first / val, p.second / val};
}
template <class T, class U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
return {a.first - b.first, a.second - b.second};
}
template <class T, class U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
return {a.first + b.first, a.second + b.second};
}
} // namespace pairs
using namespace pairs;
namespace triples {
template <class T1, class T2, class T3>
struct triple {
T1 x;
T2 y;
T3 z;
triple() : x(T1()), y(T2()), z(T3()){};
triple(T1 _x, T2 _y, T3 _z) : x(_x), y(_y), z(_z) {}
};
template <class T1, class T2, class T3>
bool operator<(const triple<T1, T2, T3>& t1, const triple<T1, T2, T3>& t2) {
if (t1.x != t2.x) return t1.x < t2.x;
if (t1.y != t2.y)
return t1.y < t2.y;
else
return t1.z < t2.z;
}
template <class T1, class T2, class T3>
bool operator>(const triple<T1, T2, T3>& t1, const triple<T1, T2, T3>& t2) {
if (t1.x != t2.x) return t1.x > t2.x;
if (t1.y != t2.y)
return t1.y > t2.y;
else
return t1.z > t2.z;
}
template <class T1, class T2, class T3>
bool operator==(const triple<T1, T2, T3>& t1, const triple<T1, T2, T3>& t2) {
return (t1.x == t2.x && t1.y == t2.y && t1.z == t2.z);
}
template <class T1, class T2, class T3>
inline istream& operator>>(istream& os, triple<T1, T2, T3>& t) {
return os >> t.x >> t.y >> t.y;
}
template <class T1, class T2, class T3>
ostream& operator<<(ostream& os, const triple<T1, T2, T3>& t) {
return os << t.x << " " << t.y << " " << t.z;
}
template <class T1, class T2, class T3>
triple<T1, T2, T3> operator+(triple<T1, T2, T3> a, triple<T1, T2, T3> b) {
return {a.x + b.x, a.y + b.y, a.z + b.z};
}
template <class T1, class T2, class T3>
triple<T1, T2, T3> operator-(triple<T1, T2, T3> a, triple<T1, T2, T3> b) {
return {a.x - b.x, a.y - b.y, a.z - b.z};
}
template <class T1, class T2, class T3, class T4>
triple<T1, T2, T3> operator*(triple<T1, T2, T3> a, T4 val) {
return {a.x * val, a.y * val, a.z * val};
}
template <class T1, class T2, class T3, class T4>
triple<T1, T2, T3> operator/(triple<T1, T2, T3> a, T4 val) {
return {a.x / val, a.y / val, a.z / val};
}
using TRII = triple<int, int, int>;
using TRLL = triple<LL, LL, LL>;
using TRLD = triple<LD, LD, LD>;
using VTRII = vector<TRII>;
using VTRLL = vector<TRLL>;
using VTRLD = vector<TRLD>;
} // namespace triples
using namespace triples;
namespace geo {
template <class T>
T dotProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.first + a.second * b.second;
}
template <class T>
T crossProduct(pair<T, T> a, pair<T, T> b) {
return a.first * b.second - a.second * b.first;
}
template <class T>
T lengthPow(pair<T, T> a) {
return a.first * 1ll * a.first + a.second * 1ll * a.second;
}
template <class T>
LD length(pair<T, T> a) {
return sqrt(lengthPow(a));
}
template <class T>
T dotProduct(triple<T, T, T> a, triple<T, T, T> b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
template <class T>
T crossProduct(triple<T, T, T> a, triple<T, T, T> b) {
return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}
template <class T>
T lengthPow(triple<T, T, T> a) {
return a.x * 1ll * a.x + a.y * 1ll * a.y + a.z * 1ll * a.z;
}
template <class T>
LD length(triple<T, T, T> a) {
return sqrt(lengthPow(a));
}
} // namespace geo
using namespace geo;
template <class T>
T invGeneral(T a, T b) {
a %= b;
if (a == 0) return b == 1 ? 0 : -1;
T x = invGeneral(b, a);
return x == -1 ? -1 : ((1 - (LL)b * x) / a + b) % b;
}
template <class T>
struct modular {
T val;
explicit operator T() const { return val; }
modular() { val = 0; }
modular(const LL& v) {
val = (-MOD <= v && v <= MOD) ? v : v % MOD;
if (val < 0) val += MOD;
}
friend ostream& operator<<(ostream& os, const modular& a) {
return os << a.val;
}
friend void pr(const modular& a) { pr(a.val); }
friend void re(modular& a) {
LL x;
re(x);
a = modular(x);
}
friend bool operator==(const modular& a, const modular& b) {
return a.val == b.val;
}
friend bool operator!=(const modular& a, const modular& b) {
return !(a == b);
}
friend bool operator<(const modular& a, const modular& b) {
return a.val < b.val;
}
modular operator-() const { return modular(-val); }
modular& operator+=(const modular& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
modular& operator-=(const modular& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
modular& operator*=(const modular& m) {
val = (LL)val * m.val % MOD;
return *this;
}
friend modular pow(modular a, LL p) {
modular ans = 1;
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend modular inv(const modular& a) {
auto i = invGeneral(a.val, MOD);
assert(i != -1);
return i;
}
modular& operator/=(const modular& m) { return (*this) *= inv(m); }
friend modular operator+(modular a, const modular& b) { return a += b; }
friend modular operator-(modular a, const modular& b) { return a -= b; }
friend modular operator*(modular a, const modular& b) { return a *= b; }
friend modular operator/(modular a, const modular& b) { return a /= b; }
};
using MI = modular<int>;
using PMI = pair<MI, MI>;
using VMI = vector<MI>;
using VPMI = vector<PMI>;
namespace debug {
template <typename _T>
inline void _debug(const char* s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _debug(const char* s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_debug(s + 1, a...);
}
} // namespace debug
using namespace debug;
template <class T>
bool setMax(T& v, T newV) {
if (v < newV) {
v = newV;
return true;
}
return false;
}
template <class T>
bool setMin(T& v, T newV) {
if (v > newV) {
v = newV;
return true;
}
return false;
}
const int N = 5e5 + 7;
namespace DSU {
int tab[N];
int sz[N];
VI members[N];
void init(int n) {
for (int i = (0); (1) > 0 ? i < (n) : i >= (n); i += (1)) {
sz[i] = 1;
tab[i] = i;
members[i] = {i};
}
}
int Find(int a) {
if (tab[a] != a) tab[a] = Find(tab[a]);
return tab[a];
}
void Union(int a, int b) {
a = Find(a);
b = Find(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
tab[b] = a;
sz[a] += sz[b];
members[a].insert(members[a].end(), begin((members[b])), end((members[b])));
}
} // namespace DSU
int val[N];
bool validEdge[N];
bool ok[N];
VI ids[N];
PII queries[N];
int setID[N];
set<int, greater<int>> sety[2 * N];
void solve() {
int n, m, q;
re(n, m, q);
VPII kra;
VI edgeQue;
DSU::init(n);
for (int i = (0); (1) > 0 ? i < (n) : i >= (n); i += (1)) {
re(val[i]);
}
for (int i = (0); (1) > 0 ? i < (m) : i >= (m); i += (1)) validEdge[i] = 1;
for (int i = (0); (1) > 0 ? i < (m) : i >= (m); i += (1)) {
int a, b;
re(a, b);
--a, --b;
kra.push_back({a, b});
}
for (int i = (0); (1) > 0 ? i < (q) : i >= (q); i += (1)) {
int t, a;
re(t, a);
--a;
queries[i] = {t, a};
if (t == 2) {
validEdge[a] = false;
edgeQue.push_back(a);
}
}
reverse(begin((edgeQue)), end((edgeQue)));
for (int i = (0); (1) > 0 ? i < (m) : i >= (m); i += (1)) {
if (not validEdge[i]) continue;
DSU::Union(kra[i].first, kra[i].second);
}
for (const auto& edgeID : edgeQue) {
auto a = DSU::Find(kra[edgeID].first);
auto b = DSU::Find(kra[edgeID].second);
if (a == b) continue;
if (DSU::sz[a] > DSU::sz[b]) swap(a, b);
ids[edgeID] = DSU::members[a];
DSU::Union(a, b);
}
int cnt = 0;
map<int, int> iddd;
for (int i = (0); (1) > 0 ? i < (n) : i >= (n); i += (1)) {
int a = DSU::Find(i);
if (iddd.count(a) == 0) iddd[a] = ++cnt;
setID[i] = iddd[a];
sety[setID[i]].insert(val[i]);
}
for (int i = (0); (1) > 0 ? i < (q) : i >= (q); i += (1)) {
auto [t, a] = queries[i];
if (t == 1) {
auto& set = sety[setID[a]];
if (set.empty()) {
prln(0);
continue;
}
prln(*set.begin());
set.erase(set.begin());
} else {
++cnt;
auto& setOld = sety[setID[kra[a].first]];
auto& setNew = sety[cnt];
for (auto u : ids[a]) {
setID[u] = cnt;
if (setOld.erase(val[u])) setNew.insert(val[u]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout << fixed << setprecision(13);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
const int N = 5e5;
vi g[N];
struct DSU {
vi par;
DSU(int n) : par(n) { iota((par).begin(), (par).end(), 0); }
int find(int u) { return par[u] == u ? u : par[u] = find(par[u]); }
void join(int u, int v, int e) {
u = find(u), v = find(v);
if (u == v) return;
par[u] = par[v] = e;
g[e].emplace_back(u), g[e].emplace_back(v);
}
};
int etf[N], etl[N], etp;
void dfs(int u) {
etf[u] = etp++;
for (int v : g[u]) dfs(v);
etl[u] = etp;
}
const int INF = 1e9;
struct Max {
int x;
Max(int _x = -INF) { x = _x; }
Max operator+(const Max &o) { return x > o.x ? *this : o; }
};
template <class T>
struct RMQ {
vector<T> t;
int n;
T &operator[](int p) { return t[p + n]; }
RMQ(int sz) { n = sz, t.resize(2 * n); }
void build() {
for (int i = int(n - 1); i >= int(1); i--) t[i] = t[i << 1] + t[i << 1 | 1];
}
void set(int p, T v) {
for (t[p += n] = v; p >>= 1;) t[p] = t[p << 1] + t[p << 1 | 1];
}
T get(int l, int r) {
T a, b;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) a = a + t[l++];
if (r & 1) b = t[--r] + b;
}
return a + b;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<bool> remove(m);
vector<pii> edges(m), queries(q);
vi val(n), idx(n + 1), root(q, -1);
for (int i = int(0); i < int(n); i++) cin >> val[i], idx[val[i]] = i;
for (auto &[x, y] : edges) cin >> x >> y, x--, y--;
for (auto &[t, i] : queries) {
cin >> t >> i, i--;
if (t == 2) remove[i] = true;
}
DSU dsu(n + m);
for (int i = int(0); i < int(m); i++)
if (!remove[i]) dsu.join(edges[i].first, edges[i].second, n + i);
for (int i = int(q - 1); i >= int(0); i--) {
auto [t, id] = queries[i];
if (t == 1)
root[i] = dsu.find(id);
else
dsu.join(edges[id].first, edges[id].second, n + id);
}
for (int i = int(0); i < int(n + m); i++)
if (dsu.par[i] == i) dfs(i);
RMQ<Max> rmq(n + m);
for (int i = int(0); i < int(n); i++) rmq[etf[i]] = val[i];
rmq.build();
for (int x : root)
if (x != -1) {
int ans = rmq.get(etf[x], etl[x]).x;
if (ans) rmq.set(etf[idx[ans]], 0);
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 7e5 + 5;
const int mod = 1e9 + 7;
int n, m, q;
int p[maxn], u[300010], v[300010], vis[300010], fa[maxn], op[500010][2],
sz[maxn], boss[500010];
int pos[maxn], dfn[maxn], tot;
struct node {
int w, pos;
} t[maxn << 2];
vector<int> G[maxn];
int fid(int x) { return x == fa[x] ? x : fa[x] = fid(fa[x]); }
void dfs(int u) {
pos[u] = ++tot;
dfn[tot] = u;
sz[u] = 1;
for (int v : G[u]) dfs(v), sz[u] += sz[v];
}
void push_up(int rt) {
if (t[rt << 1].w > t[rt << 1 | 1].w)
t[rt] = t[rt << 1];
else
t[rt] = t[rt << 1 | 1];
}
void build(int rt, int l, int r) {
t[rt].w = t[rt].pos = 0;
if (l == r) {
t[rt].w = p[dfn[l]];
t[rt].pos = l;
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
push_up(rt);
}
void upd(int rt, int l, int r, int z) {
if (l == r && r == z) {
t[rt].w = 0;
return;
}
int mid = l + r >> 1;
if (z <= mid)
upd(rt << 1, l, mid, z);
else
upd(rt << 1 | 1, mid + 1, r, z);
push_up(rt);
}
node ask(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return t[rt];
int mid = l + r >> 1;
node f1, f2;
f1.w = f2.w = f1.pos = f2.pos = 0;
if (ql <= mid) f1 = ask(rt << 1, l, mid, ql, qr);
if (qr > mid) f2 = ask(rt << 1 | 1, mid + 1, r, ql, qr);
if (f1.w > f2.w)
return f1;
else
return f2;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &op[i][0], &op[i][1]);
if (op[i][0] == 2) vis[op[i][1]] = 1;
}
for (int i = 1; i <= n + q; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
if (vis[i]) continue;
int fx = fid(u[i]), fy = fid(v[i]);
if (fx != fy) {
fa[fx] = fy;
G[fy].push_back(fx);
}
}
for (int i = q; i >= 1; i--) {
if (op[i][0] == 2) {
int x = op[i][1];
int fx = fid(u[x]), fy = fid(v[x]);
if (fx != fy) {
n++;
G[n].push_back(fx);
G[n].push_back(fy);
fa[fx] = n;
fa[fy] = n;
}
} else
boss[i] = fid(op[i][1]);
}
for (int i = 1; i <= n; i++) {
if (!dfn[pos[i]]) {
dfs(fid(i));
}
}
build(1, 1, tot);
for (int i = 1; i <= q; i++) {
if (op[i][0] == 1) {
node x = ask(1, 1, tot, pos[boss[i]], pos[boss[i]] + sz[boss[i]] - 1);
if (x.w > 0) upd(1, 1, tot, x.pos);
printf("%d\n", x.w);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using vb = vector<bool>;
using vi = vector<int>;
using vii = vector<ii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
namespace ds {
class dsu {
vi e;
public:
dsu(int n) : e(n, -1) {}
int find(int x) { return (e[x] < 0) ? x : (e[x] = find(e[x])); }
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
if (e[x] > e[y]) swap(x, y);
e[x] += e[y];
e[y] = x;
return true;
}
};
} // namespace ds
namespace ds {
template <typename T, typename... Args>
class segment_tree {
const int n;
void push(int x, int l, int r) {
if (l == r) return;
const int mid = (l + r) / 2;
const int y = x + (mid - l + 1) * 2;
prop(tree[x], tree[x + 1], tree[y]);
}
T query(int x, int l, int r, int ql, int qr) {
assert(0 <= ql and ql <= qr and qr < n);
if (ql <= l and r <= qr) {
return tree[x];
}
push(x, l, r);
const int mid = (l + r) / 2;
const int y = x + (mid - l + 1) * 2;
if (qr <= mid) {
return query(x + 1, l, mid, ql, qr);
} else if (mid < ql) {
return query(y, mid + 1, r, ql, qr);
} else {
return unite(query(x + 1, l, mid, ql, qr), query(y, mid + 1, r, ql, qr));
}
}
void update(int x, int l, int r, int ql, int qr, Args... upd) {
assert(0 <= ql and ql <= qr and qr < n);
push(x, l, r);
if (ql <= l and r <= qr) {
apply(tree[x], l, r, upd...);
return;
}
const int mid = (l + r) / 2;
const int y = x + (mid - l + 1) * 2;
if (ql <= mid) {
update(x + 1, l, mid, ql, qr, upd...);
}
if (mid < qr) {
update(y, mid + 1, r, ql, qr, upd...);
}
tree[x] = unite(tree[x + 1], tree[y]);
}
public:
vector<T> tree;
function<T(const T &left, const T &right)> unite;
function<void(T &node, T &left, T &right)> prop;
function<void(T &node, int l, int r, Args... upd)> apply;
segment_tree(int n) : n(n), tree(2 * n - 1) { assert(0 < n); }
T query(const int ql, const int qr) {
assert(0 <= ql);
assert(ql <= qr);
assert(qr < n);
return query(0, 0, n - 1, ql, qr);
}
void update(const int ql, const int qr, Args... upd) {
assert(0 <= ql);
assert(ql <= qr);
assert(qr < n);
update(0, 0, n - 1, ql, qr, upd...);
}
};
} // namespace ds
struct query {
int code = 0;
int x = 0;
int i = 0;
int ll = 0;
int rr = 0;
};
struct action {
int a, b;
int root;
int other;
int i;
};
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, Q;
cin >> n >> m >> Q;
vi p(n, 0);
for (int &x : p) {
cin >> x;
}
vii e(m);
for (auto &edge : e) {
cin >> edge.first >> edge.second;
edge.first--;
edge.second--;
}
vector<query> q(Q);
set<int> removed;
for (int i = 0; i < Q; i++) {
cin >> q[i].code >> q[i].x;
q[i].i = i;
q[i].x--;
if (q[i].code == 2) {
removed.insert(q[i].x);
}
}
ds::dsu dsu(n);
for (int i = 0; i < m; i++) {
if (removed.count(i) == 0) {
dsu.unite(e[i].first, e[i].second);
}
}
map<int, vi> cs({});
for (int i = 0; i < n; i++) {
cs[dsu.find(i)].push_back(i);
}
vector<action> act;
const auto build_order = [&](ds::dsu dsu, map<int, vi> cs) {
for (int i = Q - 1; i >= 0; i--) {
if (q[i].code == 2) {
const int x = e[q[i].x].first;
const int y = e[q[i].x].second;
if (dsu.find(x) != dsu.find(y)) {
int a = dsu.find(x);
int b = dsu.find(y);
dsu.unite(a, b);
int root = dsu.find(x);
int other = a + b - root;
act.push_back({a, b, root, other, i});
cs[root].insert(cs[root].end(), (cs[other]).begin(),
(cs[other]).end());
cs[other].clear();
}
}
}
vi order;
for (auto &[c, nodes] : cs) {
for (auto &x : nodes) {
order.push_back(x);
}
}
return order;
};
vi order = build_order(dsu, cs);
vi pos(n);
for (int i = 0; i < n; i++) {
pos[order[i]] = i;
}
{
int j = 0;
for (int i = Q - 1; i >= 0; i--) {
if (j != (int)act.size() and act[j].i == i) {
assert(q[i].code == 2);
const int to = act[j].root;
const int from = act[j].other;
cs[to].insert(cs[to].end(), (cs[from]).begin(), (cs[from]).end());
cs[from].clear();
dsu.unite(act[j].a, act[j].b);
j++;
}
if (q[i].code == 1) {
int root = dsu.find(q[i].x);
q[i].ll = pos[cs[root][0]];
q[i].rr = pos[cs[root].back()];
}
}
}
ds::segment_tree<ii, ii> st(n);
st.unite = [](ii x, ii y) { return x.first >= y.first ? x : y; };
st.apply = [](ii &x, int ll, int rr, ii v) {
assert(ll == rr);
x = v;
};
st.prop = [](ii &x, ii &left, ii &right) {
assert(x == x);
assert(left == left);
assert(right == right);
};
for (int i = 0; i < n; i++) {
st.update(pos[i], pos[i], {p[i], pos[i]});
}
for (int i = 0; i < Q; i++) {
if (q[i].code == 1) {
auto res = st.query(q[i].ll, q[i].rr);
cout << res.first << "\n";
st.update(res.second, res.second, {0, res.second});
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int i, k, m, n, x, y, rk[500050], id[500050], ot[500050], vis[500050], now, q,
P[500050], Now, fa[500050], del[500050];
pair<int, int> qus[500050], e[500050];
struct node {
int l, r;
} O[500050];
pair<int, int> T[500050 << 2];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void dfs(int x) {
vis[x] = 1, rk[id[x] = ++now] = x;
if (O[x].l) dfs(O[x].l);
if (O[x].r) dfs(O[x].r);
ot[x] = now;
}
inline void up(int k) { T[k] = max(T[k << 1], T[k << 1 | 1]); }
void build(int k, int l, int r) {
if (l == r) {
if (rk[l] <= n)
T[k] = make_pair(P[rk[l]], l);
else
T[k] = make_pair(0, 0);
return;
}
int m = l + r >> 1;
build(k << 1, l, m), build(k << 1 | 1, m + 1, r), up(k);
}
pair<int, int> query(int k, int l, int r, int L, int R) {
if (l >= L && r <= R) return T[k];
int m = l + r >> 1;
pair<int, int> res(0, 0);
if (L <= m) res = max(res, query(k << 1, l, m, L, R));
if (R > m) res = max(res, query(k << 1 | 1, m + 1, r, L, R));
return res;
}
void change(int k, int l, int r, int v) {
if (l == r) {
T[k] = make_pair(0, 0);
return;
}
int m = l + r >> 1;
if (v <= m)
change(k << 1, l, m, v);
else
change(k << 1 | 1, m + 1, r, v);
up(k);
}
int main() {
scanf("%d%d%d", &n, &m, &q), Now = n + 1;
for (i = 1; i <= n; ++i) scanf("%d", &P[i]), fa[i] = i;
for (i = 1; i <= m; ++i)
scanf("%d%d", &x, &y), e[i] = make_pair(x, y), del[i] = 0;
for (i = 1; i <= q; ++i) {
scanf("%d%d", &x, &y), qus[i] = make_pair(x, y);
if (x == 2) del[y] = 1;
}
for (i = 1; i <= m; ++i)
if (!del[i]) {
int p = find(e[i].first), q = find(e[i].second);
if (p != q) {
O[Now] = (node){p, q};
fa[Now] = fa[p] = fa[q] = Now, ++Now;
}
}
for (i = q; i >= 1; --i)
if (qus[i].first == 2) {
int p = find(e[qus[i].second].first), q = find(e[qus[i].second].second);
if (p != q) {
O[Now] = (node){p, q};
fa[Now] = fa[p] = fa[q] = Now, ++Now;
}
} else
qus[i].second = find(qus[i].second);
for (--Now, i = 1; i <= Now; ++i)
if (find(i) == i) dfs(i);
build(1, 1, Now);
for (i = 1; i <= q; ++i)
if (qus[i].first == 1) {
int p = qus[i].second;
pair<int, int> o = query(1, 1, Now, id[p], ot[p]);
if (o.first == 0)
puts("0");
else
printf("%d\n", o.first), change(1, 1, Now, o.second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 7, MAXQ = 8e5 + 7, MAXM = 3e5 + 7;
struct edge {
int x, y, flag;
edge() { flag = 0; }
edge(int xx, int yy) {
x = xx;
y = yy;
flag = 0;
}
};
edge edges[MAXM];
int n, m, q;
bool mrk[MAXN];
int v[MAXN], tp[MAXQ], z[MAXQ], pai[MAXN], aux[MAXQ],
t = 0, ent[MAXN], sai[MAXN], tree[4 * MAXN], node[MAXN];
vector<int> G[MAXN];
int raiz(int u) { return (u == pai[u]) ? u : pai[u] = raiz(pai[u]); }
void join(int u, int w) {
pai[u] = w;
G[w].push_back(u);
}
void dfs(int u) {
t++;
ent[u] = t;
node[t] = u;
for (int viz : G[u]) {
dfs(viz);
}
sai[u] = t;
}
void upt(int idx, int l, int r, int pos, int val) {
if (l == r) {
tree[idx] = val;
return;
}
if (pos <= (l + r) / 2)
upt(2 * idx, l, (l + r) / 2, pos, val);
else
upt(2 * idx + 1, (l + r) / 2 + 1, r, pos, val);
if (v[tree[2 * idx]] > v[tree[2 * idx + 1]])
tree[idx] = tree[2 * idx];
else
tree[idx] = tree[2 * idx + 1];
}
int query(int idx, int l, int r, int ql, int qr) {
if (r < ql || l > qr) return 0;
if (l >= ql && r <= qr) return tree[idx];
int esq = query(2 * idx, l, (l + r) / 2, ql, qr);
int dir = query(2 * idx + 1, (l + r) / 2 + 1, r, ql, qr);
if (v[esq] > v[dir]) return esq;
return dir;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> v[i];
pai[i] = i;
}
for (int i = 1; i <= m; i++) {
int xi, yi;
cin >> xi >> yi;
edges[i] = edge(xi, yi);
}
for (int i = 1; i <= q; i++) {
cin >> tp[i] >> z[i];
if (tp[i] == 2) edges[z[i]].flag = 1;
}
for (int i = 1; i <= m; i++) {
if (edges[i].flag == 0) {
q++;
tp[q] = 2;
z[q] = i;
}
}
for (int i = q; i >= 1; i--) {
if (tp[i] == 1) {
aux[i] = raiz(z[i]);
} else {
int rx = raiz(edges[z[i]].x);
int ry = raiz(edges[z[i]].y);
if (rx != ry) {
n++;
pai[n] = n;
pai[rx] = n;
pai[ry] = n;
G[n].push_back(rx);
G[n].push_back(ry);
}
}
}
for (int i = 1; i <= n; i++) {
int ii = raiz(i);
if (mrk[ii]) continue;
mrk[ii] = true;
dfs(ii);
}
assert(t == n);
for (int i = 1; i <= t; i++) {
upt(1, 1, t, i, node[i]);
}
for (int i = 1; i <= q; i++) {
if (tp[i] == 2) continue;
int rep = aux[i];
int u = query(1, 1, t, ent[rep], sai[rep]);
cout << v[u] << endl;
v[u] = 0;
upt(1, 1, t, ent[u], u);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int maxm = 4e5 * 26 + 5;
const int INF = 0x3f3f3f3f;
const long long LINF = 3e17 + 1;
const long long mod = 1e9 + 7;
const int MOD = 1e6 + 7;
inline long long read() {
register long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return (f == 1) ? x : -x;
}
int n, m, q;
int w[maxn];
struct edge {
int v, nxt, w;
} E[maxn], p[maxn];
int fa[maxn], dep[maxn], head[maxn], wei[maxn], tim[maxn], id[maxn];
pair<int, int> qs[maxn];
int f[maxn][21], eid;
int dfn[maxn], DFN, nfd[maxn], tr[maxn], ed[maxn], ans[maxn];
void add(int u, int v) {
E[eid] = {v, head[u]};
head[u] = eid++;
}
bool cmp(int a, int b) { return tim[a] > tim[b]; }
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
void dfs(int u, int ff) {
dep[u] = dep[ff] + 1;
dfn[u] = ++DFN;
nfd[DFN] = u;
for (int i = head[u]; i != -1; i = E[i].nxt) {
int v = E[i].v;
if (v == ff) continue;
f[v][0] = u;
dfs(v, u);
}
ed[u] = DFN;
}
void pushup(int o) {
tr[o] =
w[tr[(o << 1)]] == w[tr[(o << 1 | 1)]]
? (tr[(o << 1)] < tr[(o << 1 | 1)] ? tr[(o << 1)] : tr[(o << 1 | 1)])
: (w[tr[(o << 1)]] > w[tr[(o << 1 | 1)]] ? tr[(o << 1)]
: tr[(o << 1 | 1)]);
}
void build(int o, int l, int r) {
if (l == r) {
tr[o] = nfd[l];
return;
}
int mid = l + r >> 1;
build((o << 1), l, mid), build((o << 1 | 1), mid + 1, r);
pushup(o);
}
void upd(int o, int l, int r, int p, int v) {
if (l == r) {
tr[o] = v;
return;
}
int mid = l + r >> 1;
if (p <= mid)
upd((o << 1), l, mid, p, v);
else
upd((o << 1 | 1), mid + 1, r, p, v);
pushup(o);
}
int qry(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return tr[o];
int mid = l + r >> 1;
int res = -1;
if (ql <= mid) res = qry((o << 1), l, mid, ql, qr);
if (mid < qr) {
if (res == -1)
return qry((o << 1 | 1), mid + 1, r, ql, qr);
else {
int tt = qry((o << 1 | 1), mid + 1, r, ql, qr);
if (tt != -1)
res = w[res] == w[tt] ? (res < tt ? res : tt)
: (w[res] > w[tt] ? res : tt);
}
}
return res;
}
int get(int x, int val) {
for (int i = 20; i >= 0; i--)
if (f[x][i] && wei[f[x][i]] >= val) x = f[x][i];
return x;
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) w[i] = read(), wei[i] = q + 1;
int nn = n << 1;
for (int i = 1; i <= nn + 5; i++) fa[i] = i, head[i] = -1;
for (int i = 1; i <= m; i++) {
p[i].v = read(), p[i].nxt = read();
tim[i] = q + 1, id[i] = i;
}
for (int i = 1; i <= q; i++) {
ans[i] = -1;
qs[i].first = read(), qs[i].second = read();
if (qs[i].first == 2) tim[qs[i].second] = i;
}
sort(id + 1, id + 1 + m, cmp);
int k = n;
for (int i = 1; i <= m; i++) {
int u = p[id[i]].v, v = p[id[i]].nxt;
int uu = fd(u), vv = fd(v);
if (uu == vv) continue;
fa[uu] = fa[vv] = ++k;
wei[k] = tim[id[i]];
add(uu, k), add(k, uu);
add(vv, k), add(k, vv);
}
for (int i = k; i >= 1; i--)
if (!dfn[i]) dfs(i, 0);
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= k; i++) f[i][j] = f[f[i][j - 1]][j - 1];
build(1, 1, k);
for (int i = 1; i <= q; i++) {
if (qs[i].first == 2) continue;
int tt = get(qs[i].second, i);
int res = qry(1, 1, k, dfn[tt], ed[tt]);
ans[i] = w[res];
if (w[res]) upd(1, 1, k, dfn[res], 0);
w[res] = 0;
}
for (int i = 1; i <= q; i++) {
if (ans[i] != -1) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
vector<int> adj[N];
vector<int> ans;
vector<int> a(N, 0);
vector<pair<int, int> > query;
vector<pair<int, int> > edge, nodes(N, {0, 0});
pair<int, int> seg[4 * N];
int f[N], sz[N], tin[N], tout[N], z, timer;
void dfs(int v, int p = -1) {
tin[v] = ++timer;
for (int to : adj[v]) {
if (to != p) dfs(to, v);
}
tout[v] = timer;
}
struct SegmentTree {
void build(int node, int l, int r, vector<pair<int, int> > &a) {
if (l == r) {
seg[node] = a[l];
return;
}
int m = (l + r) >> 1;
build(2 * node + 1, l, m, a);
build(2 * node + 2, m + 1, r, a);
seg[node] = max(seg[2 * node + 1], seg[2 * node + 2]);
}
void update(int node, int i, pair<int, int> val, int l, int r) {
if (l == r) {
seg[node] = val;
return;
}
int m = (l + r) >> 1;
if (i <= m)
update(2 * node + 1, i, val, l, m);
else
update(2 * node + 2, i, val, m + 1, r);
seg[node] = max(seg[2 * node + 1], seg[2 * node + 2]);
}
pair<int, int> query(int node, int sl, int sr, int ql, int qr) {
if (sl > qr or sr < ql) return {0, 0};
if (sl >= ql and sr <= qr) return seg[node];
int m = (sl + sr) >> 1;
pair<int, int> l = query(2 * node + 1, sl, m, ql, qr);
pair<int, int> r = query(2 * node + 2, m + 1, sr, ql, qr);
return max(l, r);
}
};
void init(int n) {
for (int i = 0; i < n; ++i) f[i] = i, sz[i] = 1;
}
int root(int x) {
while (x != f[x]) {
f[x] = f[f[x]];
x = f[x];
}
return x;
}
bool merge(int x, int y) {
int r_a = root(x), b = root(y);
if (r_a == b) return true;
if (sz[r_a] > sz[b]) swap(r_a, b);
f[z] = z;
f[r_a] = z;
f[b] = z;
adj[z].push_back(r_a);
adj[z].push_back(b);
++z;
return false;
}
bool isConnected(int x, int y) {
if (root(x) == root(y))
return true;
else
return false;
}
void solve() {
memset(tin, -1, sizeof tin);
memset(tout, -1, sizeof tout);
int n, m, q;
cin >> n >> m >> q;
z = n;
vector<bool> isPresent(m, 1);
init(N);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
edge.emplace_back(u, v);
}
for (int i = 0; i < q; ++i) {
int t, u;
cin >> t >> u;
--u;
query.emplace_back(t, u);
if (t == 2) isPresent[u] = 0;
}
for (int i = 0; i < m; ++i) {
if (isPresent[i]) {
merge(edge[i].first, edge[i].second);
}
}
reverse(query.begin(), query.end());
vector<int> q_par(q);
int j = q - 1;
for (auto &[t, i] : query) {
if (t == 2) {
merge(edge[i].first, edge[i].second);
} else {
q_par[j] = root(i);
}
--j;
}
for (int i = 0; i <= z; ++i) {
if (root(i) == i) {
dfs(i);
}
}
for (int i = 0; i <= z; ++i) {
nodes[tin[i]] = {a[i], tin[i]};
}
reverse(query.begin(), query.end());
SegmentTree st;
st.build(0, 0, z, nodes);
j = 0;
for (auto &[t, i] : query) {
if (t == 2) {
++j;
continue;
}
int v = q_par[j];
pair<int, int> s = st.query(0, 0, z, tin[v], tout[v]);
ans.push_back(s.first);
st.update(0, s.second, {0, 0}, 0, z);
++j;
}
for (int i : ans) cout << i << " ";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
template <class T>
inline bool ckmin(T& a, T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool ckmax(T& a, T b) {
return b > a ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const char nl = '\n';
const int mxN = 5e5 + 10;
const int MOD = 1e9 + 7;
const long long infLL = 1e18;
int n, m, q, p[mxN], val[mxN], inv[mxN];
vi amt[mxN];
pii e[mxN];
set<int> second[mxN];
bool done[mxN];
void merge(int a, int b, vi& v) {
a = p[a];
b = p[b];
if (a == b) return;
if ((int)amt[a].size() > (int)amt[b].size()) {
swap(a, b);
}
v = amt[a];
for (auto& x : v) {
p[x] = b;
amt[b].push_back(x);
}
amt[a].clear();
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = (1); i < (n + 1); i++) cin >> val[i], inv[val[i]] = i;
for (int i = (1); i < (m + 1); i++) {
int e1, e2;
cin >> e1 >> e2;
e[i] = {e1, e2};
}
vpii qu(q);
for (int i = (0); i < (q); i++) {
cin >> qu[i].first >> qu[i].second;
if (qu[i].first == 2) done[qu[i].second] = 1;
}
for (int i = (1); i < (1 + n); i++) {
p[i] = i;
amt[i].push_back(i);
}
for (int i = (1); i < (m + 1); i++) {
if (!done[i]) {
vi tmp;
merge(e[i].first, e[i].second, tmp);
}
}
vector<vi> ex(q);
for (int i = (q - 1); i >= (0); i--) {
if (qu[i].first == 2) {
merge(e[qu[i].second].first, e[qu[i].second].second, ex[i]);
}
}
for (int i = (1); i < (n + 1); i++) {
if (i == p[i]) {
for (auto& x : amt[i]) {
second[i].insert(val[x]);
}
}
}
int nxt = n + 1;
for (int i = (0); i < (q); i++) {
if (qu[i].first == 1) {
int a = qu[i].second;
a = p[a];
if (!second[a].empty()) {
int va = *second[a].rbegin();
val[inv[va]] = 0;
second[a].erase(va);
cout << va << nl;
} else {
cout << 0 << nl;
}
} else {
nxt++;
for (auto& x : ex[i]) {
second[p[x]].erase(val[x]);
p[x] = nxt;
if (val[x]) second[nxt].insert(val[x]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 0x3f3f3f3f;
const int maxn = 5e5 + 5;
const int mod = 1e9 + 7;
int n, m, q;
int p[maxn];
int u[maxn], v[maxn], del[maxn];
int op[maxn], A[maxn];
int fa[maxn], del_time[maxn], tar_del[maxn];
int pos[maxn];
set<int> st[maxn];
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[1000000], *p1 = buf + 1000000, *pend = buf + 1000000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 1000000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
inline void readll(long long int &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
}; // namespace fastIO
using namespace fastIO;
int Find(int x, int now) {
while (fa[x] != x && now < del_time[x]) x = fa[x];
return x;
}
void DelGoUp(int x, vector<int> ve) {
while (true) {
if (!st[x].count(ve[0])) return;
for (auto val : ve) st[x].erase(val);
if (fa[x] == x) return;
x = fa[x];
}
}
void Merge(int x, int y, int t) {
x = Find(x, 0);
y = Find(y, 0);
if (x == y) return;
if ((int)st[x].size() > (int)st[y].size()) swap(x, y);
fa[x] = y;
del_time[x] = t;
tar_del[t] = x;
for (auto val : st[x]) st[y].insert(val);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
read(n);
read(m);
read(q);
for (int i = 1; i <= n; i++) {
read(p[i]);
pos[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
read(u[i]);
read(v[i]);
}
for (int i = 1; i <= q; i++) {
read(op[i]);
read(A[i]);
if (op[i] == 2) del[A[i]] = true;
}
for (int i = 1; i <= n; i++) {
fa[i] = i;
del_time[i] = q + 1;
st[i].insert(p[i]);
}
for (int i = 1; i <= m; i++) {
if (!del[i]) Merge(u[i], v[i], q + 1);
}
for (int i = q; i >= 1; i--) {
if (op[i] == 2) Merge(u[A[i]], v[A[i]], i);
}
for (int i = 1; i <= q; i++) {
if (op[i] == 1) {
int x = Find(A[i], i);
if (st[x].empty())
cout << 0 << "\n";
else {
int val = *st[x].rbegin();
cout << val << "\n";
DelGoUp(pos[val], {val});
}
} else {
int x = tar_del[i];
if (x == 0 || fa[x] == x || st[x].empty()) continue;
vector<int> ve((int)st[x].size());
int ii = 0;
for (auto val : st[x]) ve[ii++] = val;
DelGoUp(fa[x], ve);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int r[N], s[N], x[N];
vector<int> v[N];
pair<int, int> ans[500005];
pair<int, int> seg[4 * N];
pair<int, int> update(int l, int u, int i, int a, int b) {
if (l >= a && u <= a) return seg[i] = {b, a};
if (l > a || u < a) return seg[i];
return seg[i] = max(update(l, ((l + u) / 2), (i * 2 + 1), a, b),
update(((l + u) / 2) + 1, u, (i * 2 + 2), a, b));
}
pair<int, int> query(int l, int u, int i, int a, int b) {
if (l >= a && u <= b) return seg[i];
if (l > b || u < a) return {0, -1};
return max(query(l, ((l + u) / 2), (i * 2 + 1), a, b),
query(((l + u) / 2) + 1, u, (i * 2 + 2), a, b));
}
int findr(int k) {
if (k == r[k]) return k;
return findr(r[k]);
}
void UNION(int a, int b) {
int r1 = findr(a), r2 = findr(b);
if (r1 == r2) return;
if (s[r1] < s[r2]) swap(r1, r2);
r[r2] = r1;
s[r1] += s[r2];
for (int j : v[r2]) v[r1].push_back(j);
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> x[i];
r[i] = i;
s[i] = 1;
v[i].push_back(i);
}
pair<int, int> e[m + 1];
set<int> ss;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
e[i] = {a, b};
ss.insert(i);
}
pair<int, int> qq[q + 5];
for (int i = 1; i <= q; i++) {
int a, b;
cin >> a >> b;
qq[i] = {a, b};
if (a == 1) continue;
ss.erase(b);
}
for (int j : ss) {
UNION(e[j].first, e[j].second);
}
for (int i = q; i >= 1; i--) {
if (qq[i].first == 2) {
UNION(e[qq[i].second].first, e[qq[i].second].second);
} else {
int temp = findr(qq[i].second);
ans[i] = {v[temp][0], v[temp].size() - 1};
}
}
int loc[n + 1];
for (int i = 1; i <= n; i++) loc[i] = -1;
int b = 0;
for (int i = 1; i <= n; i++) {
if (loc[i] != -1) continue;
int k = findr(i);
for (int j : v[k]) {
update(0, n - 1, 0, b, x[j]);
loc[j] = b++;
}
}
for (int i = 1; i <= q; i++) {
if (qq[i].first == 2) continue;
pair<int, int> homie = query(0, n - 1, 0, loc[ans[i].first],
loc[ans[i].first] + ans[i].second);
cout << homie.first << endl;
update(0, n - 1, 0, homie.second, 0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 5e5 + 5;
int U[maxn], V[maxn], type[maxn], id[maxn];
int tin[maxn], tout[maxn], par[maxn], a[maxn], root[maxn];
int N, M, Q;
bool del[maxn];
vector<int> adj[maxn];
pair<int, int> tr[4 * maxn];
int finds(int u) {
if (par[u] == u) return u;
return par[u] = finds(par[u]);
}
void merges(int u, int v) {
u = finds(u);
v = finds(v);
if (u == v) return;
++N;
par[N] = N;
par[u] = N;
par[v] = N;
adj[N].emplace_back(u);
adj[N].emplace_back(v);
}
void upd(int pos, pair<int, int> v, int id = 1, int l = 1, int r = N) {
if (l == r) {
tr[id] = v;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
upd(pos, v, id << 1, l, mid);
else
upd(pos, v, id << 1 | 1, mid + 1, r);
tr[id] = max(tr[id << 1], tr[id << 1 | 1]);
}
pair<int, int> query(int L, int R, int id = 1, int l = 1, int r = N) {
if (R < l || r < L) return make_pair(0, 0);
if (L <= l && r <= R) return tr[id];
int mid = (l + r) / 2;
return max(query(L, R, id << 1, l, mid),
query(L, R, id << 1 | 1, mid + 1, r));
}
void dfs(int u) {
static int nTime = 0;
tin[u] = ++nTime;
for (int v : adj[u]) {
dfs(v);
}
tout[u] = nTime;
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> Q;
iota(par + 1, par + 1 + N, 1);
for (int i = 1; i <= N; ++i) {
cin >> a[i];
}
for (int i = 1; i <= M; ++i) {
cin >> U[i] >> V[i];
}
for (int i = 1; i <= Q; ++i) {
cin >> type[i] >> id[i];
if (type[i] == 2) {
del[id[i]] = true;
}
}
for (int i = 1; i <= M; ++i) {
if (!del[i]) {
merges(U[i], V[i]);
}
}
for (int i = Q; i >= 1; --i) {
if (type[i] == 1) {
root[i] = finds(id[i]);
} else {
merges(U[id[i]], V[id[i]]);
}
}
for (int i = 1; i <= N; ++i) {
if (finds(i) == i) {
dfs(i);
}
}
for (int i = 1; i <= N; ++i) {
upd(tin[i], make_pair(a[i], i));
}
for (int i = 1; i <= Q; ++i) {
if (type[i] == 1) {
pair<int, int> res = query(tin[root[i]], tout[root[i]]);
cout << res.first << '\n';
upd(tin[res.second], make_pair(0, res.second));
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500010;
inline int read() {
int n = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = 10 * n + (c ^ '0');
c = getchar();
}
return f * n;
}
int n, m, q;
int val[MAXN], pos[MAXN], dsu[MAXN];
pair<int, int> edge[MAXN], ask[MAXN];
bool del[MAXN];
vector<int> E[MAXN];
int in[MAXN], out[MAXN], total;
int find(int u) {
if (dsu[u] == u) return u;
return dsu[u] = find(dsu[u]);
}
void merge(int u, int v) {
int fu = find(u);
int fv = find(v);
if (fu == fv) return;
n = n + 1;
dsu[fu] = dsu[fv] = dsu[n] = n;
E[n].push_back(fu);
E[n].push_back(fv);
}
void dfs(int u, int f) {
in[u] = ++total;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i];
if (in[v]) continue;
dfs(v, u);
}
out[u] = total;
}
struct SegTree {
int l, r, v;
} node[4 * MAXN];
void build(int i, int l, int r) {
node[i].l = l, node[i].r = r;
if (l == r) return;
int m = l + r >> 1;
build(i << 1, l, m);
build(i << 1 | 1, m + 1, r);
}
void update(int i, int k, int v) {
if (node[i].l == node[i].r) {
node[i].v = v;
return;
}
int m = node[i].l + node[i].r >> 1;
if (k <= m)
update(i << 1, k, v);
else
update(i << 1 | 1, k, v);
node[i].v = max(node[i << 1].v, node[i << 1 | 1].v);
}
int query(int i, int l, int r) {
if (node[i].l == l && node[i].r == r) return node[i].v;
int m = node[i].l + node[i].r >> 1;
if (r <= m) return query(i << 1, l, r);
if (l > m) return query(i << 1 | 1, l, r);
return max(query(i << 1, l, m), query(i << 1 | 1, m + 1, r));
}
int main() {
n = read(), m = read(), q = read();
for (int i = 1; i <= n; i++) {
val[i] = read();
pos[val[i]] = dsu[i] = i;
}
for (int i = 1; i <= m; i++) {
edge[i].first = read();
edge[i].second = read();
}
for (int i = 1; i <= q; i++) {
ask[i].first = read();
ask[i].second = read();
if (ask[i].first == 2) {
del[ask[i].second] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (del[i]) continue;
merge(edge[i].first, edge[i].second);
}
for (int i = q; i >= 1; i--) {
if (ask[i].first == 1) {
ask[i].second = find(ask[i].second);
} else {
int k = ask[i].second;
merge(edge[k].first, edge[k].second);
}
}
for (int i = 1; i <= n; i++) {
if (dsu[i] == i) {
dfs(i, -1);
}
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
update(1, in[i], val[i]);
}
for (int i = 1; i <= q; i++) {
if (ask[i].first == 1) {
int u = ask[i].second;
int ans = query(1, in[u], out[u]);
printf("%d\n", ans);
if (ans != 0) update(1, in[pos[ans]], 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long sz = 2e5 + 10, esz = 3e5 + 10, qsz = 5e5 + 10;
int p[sz], erased[esz], par[sz], siz[sz];
struct info {
long long a, b;
} edge[esz], qry[qsz];
struct rollback {
int par, node, siz;
} chng[qsz];
long long findp(long long u) {
if (par[u] == u) return u;
return findp(par[u]);
}
vector<int> lst[sz];
const bool cmp(int &a, int &b) { return p[a] < p[b]; }
void dsu_uni(int u, int v, int id = 0) {
int pu = findp(u), pv = findp(v);
if (pu == pv) return;
if (siz[pu] < siz[pv]) swap(pu, pv);
if (id != 0) chng[id] = {pu, pv, siz[pu]};
par[pv] = pu;
lst[pu].insert(lst[pu].end(), lst[pv].begin(), lst[pv].end());
siz[pu] += siz[pv];
}
int main() {
long long n, m, q;
cin >> n >> m >> q;
for (long long i = 1; i <= n; ++i) scanf("%d", &p[i]);
for (long long i = 1; i <= m; ++i)
scanf("%lld", &edge[i].a), scanf("%lld", &edge[i].b);
for (long long i = 1; i <= q; ++i) {
scanf("%lld", &qry[i].a), scanf("%lld", &qry[i].b);
if (qry[i].a == 2) erased[qry[i].b] = 1;
}
for (long long i = 1; i <= n; ++i)
par[i] = i, siz[i] = 1, lst[i].push_back(i);
for (long long i = 1; i <= m; ++i) {
if (erased[i]) continue;
dsu_uni(edge[i].a, edge[i].b);
}
for (long long i = q; i >= 1; --i) {
if (qry[i].a == 1) continue;
long long id = qry[i].b;
dsu_uni(edge[id].a, edge[id].b, i);
}
for (long long i = 1; i <= n; ++i) sort(lst[i].begin(), lst[i].end(), cmp);
for (long long i = 1; i <= q; ++i) {
if (qry[i].a == 1) {
long long pu = findp(qry[i].b);
while (!lst[pu].empty()) {
long long now = lst[pu].back(), pnow = findp(now);
if (pnow != pu || p[now] == 0) {
lst[pu].pop_back();
continue;
}
break;
}
long long ans = 0;
if (!lst[pu].empty()) ans = p[lst[pu].back()], p[lst[pu].back()] = 0;
printf("%lld\n", ans);
} else {
par[chng[i].node] = chng[i].node;
siz[chng[i].par] = chng[i].siz;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n, m, q, t;
vector<int> p, delete_edges, parents, tin, tout, a;
vector<pair<int, int>> edges, queries;
map<int, vector<int>> g;
struct segtree {
int sz;
vector<int> tree, pos;
segtree(const vector<int> &a) {
sz = 1;
while (sz < a.size()) sz *= 2;
tree.resize(2 * sz);
pos.resize(n + 1);
build(a, 0, 0, sz);
}
void build(const vector<int> &a, int x, int lx, int rx) {
if (lx + 1 == rx) {
if (lx < a.size()) {
int v = a[lx];
if (v < n) {
tree[x] = p[v];
pos[tree[x]] = lx;
}
}
return;
}
int m = (lx + rx) / 2;
build(a, 2 * x + 1, lx, m);
build(a, 2 * x + 2, m, rx);
tree[x] = max(tree[2 * x + 1], tree[2 * x + 2]);
}
int query(int l, int r, int x, int lx, int rx) {
if (r <= lx || rx <= l) return 0;
if (l <= lx && rx <= r) return tree[x];
int m = (lx + rx) / 2;
return max(query(l, r, 2 * x + 1, lx, m), query(l, r, 2 * x + 2, m, rx));
}
int query(int l, int r) { return query(l, r, 0, 0, sz); }
void update(int i, int x, int lx, int rx) {
if (lx + 1 == rx) {
tree[x] = 0;
return;
}
int m = (lx + rx) / 2;
if (i < m) {
update(i, 2 * x + 1, lx, m);
} else {
update(i, 2 * x + 2, m, rx);
}
tree[x] = max(tree[2 * x + 1], tree[2 * x + 2]);
}
void update(int v) { update(pos[v], 0, 0, sz); }
};
void dfs(int u, int p) {
tin[u] = t;
a.push_back(u);
for (int v : g[u])
if (v != p) {
++t;
dfs(v, u);
}
tout[u] = t;
}
struct dsu {
vector<int> p;
dsu(int n) {
p.resize(n);
for (int i = 0; i < n; ++i) p[i] = i;
}
int find(int u) {
if (p[u] != u) {
p[u] = find(p[u]);
}
return p[u];
}
void merge(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
int w = p.size();
p.push_back(w);
p[u] = p[v] = w;
g[w].push_back(u);
g[w].push_back(v);
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
p.resize(n);
delete_edges.resize(m);
edges.resize(m);
queries.resize(q);
for (int i = 0; i < n; ++i) {
cin >> p[i];
}
for (int i = 0; i < m; ++i) {
cin >> edges[i].first >> edges[i].second;
edges[i].first--, edges[i].second--;
}
for (int i = 0; i < q; ++i) {
cin >> queries[i].first >> queries[i].second;
queries[i].second--;
if (queries[i].first == 2) {
assert(delete_edges[queries[i].second] == 0);
delete_edges[queries[i].second] = 1;
}
}
for (int i = 0; i < m; ++i)
if (delete_edges[i] == 0) {
delete_edges[i] = 1;
queries.push_back({2, i});
}
q = queries.size();
reverse(queries.begin(), queries.end());
dsu d(n);
for (auto &[type, x] : queries) {
if (type == 1) {
parents.push_back(d.find(x));
} else {
int u = edges[x].first, v = edges[x].second;
d.merge(u, v);
}
}
reverse(queries.begin(), queries.end());
reverse(parents.begin(), parents.end());
int sz = d.p.size();
tin.resize(sz);
tout.resize(sz);
for (int i = 0; i < sz; ++i)
if (d.p[i] == i) {
dfs(i, i);
++t;
}
segtree st(a);
int idx = 0;
for (auto &[type, x] : queries)
if (type == 1) {
int p = parents[idx++];
int an = st.query(tin[p], tout[p] + 1);
if (an != 0) {
st.update(an);
}
cout << an << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
int N, M, Q;
int A[MAXN], Anc[MAXN], Del[MAXN], Rt[MAXN];
pair<int, int> E[MAXN], B[MAXN];
vector<int> G[MAXN];
int findAnc(int x) { return x == Anc[x] ? x : Anc[x] = findAnc(Anc[x]); }
void merge(int x, int y) {
x = findAnc(x), y = findAnc(y);
if (x == y) return;
Anc[x] = Anc[y] = ++N;
Anc[N] = N;
G[N].push_back(x);
G[N].push_back(y);
}
int Sz[MAXN], Dfn[MAXN], Id[MAXN], cntD;
int dfs(int x) {
Dfn[++cntD] = x;
Id[x] = cntD;
Sz[x] = 1;
for (auto u : G[x]) Sz[x] += dfs(u);
return Sz[x];
}
int Mx[MAXN << 2];
int mx(int x, int y) { return A[x] > A[y] ? x : y; }
void pushUp(int rt) { Mx[rt] = mx(Mx[rt << 1], Mx[rt << 1 | 1]); }
void build(int rt, int l, int r) {
if (l == r) {
Mx[rt] = Dfn[l];
return;
}
int m = (l + r) >> 1;
build(rt << 1, l, m);
build(rt << 1 | 1, m + 1, r);
pushUp(rt);
}
int query(int rt, int l, int r, int a, int b) {
if (a <= l && r <= b) return Mx[rt];
int m = (l + r) >> 1, res = 0;
if (a <= m) res = mx(res, query(rt << 1, l, m, a, b));
if (m < b) res = mx(res, query(rt << 1 | 1, m + 1, r, a, b));
return res;
}
void update(int rt, int l, int r, int p, int x) {
if (l == r) {
A[Mx[rt]] = x;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(rt << 1, l, m, p, x);
else
update(rt << 1 | 1, m + 1, r, p, x);
pushUp(rt);
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int i = 1; i <= N; ++i) scanf("%d", &A[i]);
for (int i = 1; i <= M; ++i) scanf("%d%d", &E[i].first, &E[i].second);
for (int i = 1; i <= N; ++i) Anc[i] = i;
for (int i = 1; i <= Q; ++i) {
scanf("%d%d", &B[i].first, &B[i].second);
if (B[i].first == 2) Del[B[i].second] = 1;
}
for (int i = 1; i <= M; ++i) {
if (!Del[i]) merge(E[i].first, E[i].second);
}
for (int i = Q; i >= 1; --i) {
if (B[i].first == 2) {
merge(E[B[i].second].first, E[B[i].second].second);
} else {
Rt[i] = findAnc(B[i].second);
}
}
for (int i = 1; i <= N; ++i) {
if (i == findAnc(i)) {
Sz[i] = dfs(i);
}
}
build(1, 1, N);
for (int i = 1; i <= Q; ++i) {
if (B[i].first == 1) {
int p = query(1, 1, N, Id[Rt[i]], Id[Rt[i]] + Sz[Rt[i]] - 1);
printf("%d\n", A[p]);
update(1, 1, N, Id[p], 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
std::vector<int> val(500005);
std::map<int, pair<int, int> > edges;
std::vector<pair<int, int> > query(500005);
int vis[500005];
int par[500005];
set<pair<int, int> > ss[500005];
int sz[500005];
std::vector<pair<int, int> > changes[500005];
int st[500005], en[500005];
int getpar(int x) {
if (par[x] == x)
return x;
else
return getpar(par[x]);
}
void merge(int n1, int n2, int idx) {
int p1 = getpar(n1);
int p2 = getpar(n2);
if (p1 == p2) return;
if (sz[p1] > sz[p2]) swap(p1, p2);
sz[p2] += sz[p1];
sz[p1] = 0;
for (auto i : ss[p1]) {
ss[p2].insert(i);
}
par[p1] = p2;
if (idx != -1) {
st[idx] = p1;
en[idx] = p2;
for (auto i : ss[p1]) {
changes[idx].push_back(i);
}
}
ss[p1].clear();
}
int getans(int node) {
int pp = getpar(node);
pair<int, int> zz = *(ss[pp].rbegin());
cout << zz.first << '\n';
auto it = ss[pp].rbegin();
ss[pp].erase(zz);
val[zz.second] = 0;
ss[pp].insert({val[zz.second], zz.second});
return zz.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i < n + 1; i++) {
cin >> val[i];
sz[i] = 1;
par[i] = i;
ss[par[i]].insert({val[i], i});
}
for (int i = 1; i < m + 1; i++) {
int x, y;
cin >> x >> y;
edges[i] = {x, y};
}
for (int i = 1; i < q + 1; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 2) {
vis[query[i].second] = 1;
}
}
for (int i = 1; i < m + 1; i++) {
if (!vis[i]) {
merge(edges[i].first, edges[i].second, -1);
}
}
for (int i = q; i >= 1; i--) {
if (query[i].first == 2) {
merge(edges[query[i].second].first, edges[query[i].second].second, i);
}
}
for (int i = 1; i < q + 1; i++) {
if (query[i].first == 1) {
getans(query[i].second);
} else {
int st1 = st[i];
int en1 = en[i];
ss[st1].clear();
for (auto j : changes[i]) {
ss[st1].insert({val[j.second], j.second});
ss[en1].erase({val[j.second], j.second});
}
par[st1] = st1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
struct segtree {
int size;
vector<pair<int, int>> vals;
void init(int n) {
size = 1;
while (size < n) size *= 2;
vals.assign(2 * size, {0, 0});
}
void build(vector<int> &a, int x, int lx, int rx) {
if (rx - lx == 1) {
if (lx < (int)a.size()) vals[x] = {a[lx], lx};
return;
}
int m = (lx + rx) / 2;
build(a, 2 * x + 1, lx, m);
build(a, 2 * x + 2, m, rx);
vals[x] = max(vals[2 * x + 1], vals[2 * x + 2]);
}
void build(vector<int> &a) { build(a, 0, 0, size); }
void set(int i, int v, int x, int lx, int rx) {
if (rx - lx == 1) {
vals[x].first = v;
return;
}
int m = (lx + rx) / 2;
if (i < m) {
set(i, v, 2 * x + 1, lx, m);
} else {
set(i, v, 2 * x + 2, m, rx);
}
vals[x] = max(vals[2 * x + 1], vals[2 * x + 2]);
}
void set(int i, int v) { set(i, v, 0, 0, size); }
pair<int, int> calc(int l, int r, int x, int lx, int rx) {
if (lx >= l && rx <= r) return vals[x];
if (lx >= r || rx <= l) return {-1, -1};
int m = (lx + rx) / 2;
pair<int, int> s1 = calc(l, r, 2 * x + 1, lx, m);
pair<int, int> s2 = calc(l, r, 2 * x + 2, m, rx);
return max(s1, s2);
}
pair<int, int> calc(int l, int r) { return calc(l, r, 0, 0, size); }
};
int n, m, q, t = -1;
int par[600001];
pair<int, int> edges[300001];
set<int> second;
pair<int, int> query[500001];
vector<int> adj[600001];
int p[600001];
int qp[500001];
bool vis[600001];
int tin[600001];
int tout[600001];
vector<int> et;
vector<int> ind;
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
void join(int a, int b, int c) {
par[c] = c;
par[a] = c;
par[b] = c;
adj[c].push_back(b);
adj[c].push_back(a);
adj[b].push_back(c);
adj[a].push_back(c);
}
void dfs(int x) {
vis[x] = true;
t++;
tin[x] = t;
et.push_back(p[x]);
ind.push_back(x);
for (auto &k : adj[x]) {
if (!vis[k]) dfs(k);
}
t++;
tout[x] = t;
et.push_back(p[x]);
ind.push_back(x);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> p[i];
par[i] = i;
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
edges[i] = {u, v};
second.insert(i);
}
for (int i = 1; i <= q; i++) {
int op;
cin >> op;
if (op == 1) {
int u;
cin >> u;
query[i] = {1, u};
} else {
int x;
cin >> x;
query[i] = {2, x};
second.erase(x);
}
}
int cur = n;
for (auto it = second.begin(); it != second.end(); it++) {
int i = *it;
int u = edges[i].first;
int v = edges[i].second;
if (find(u) == find(v)) continue;
cur++;
join(find(u), find(v), cur);
}
for (int i = q; i >= 1; i--) {
if (query[i].first == 1) {
qp[i] = find(query[i].second);
} else {
int u = edges[query[i].second].first;
int v = edges[query[i].second].second;
if (find(u) == find(v)) continue;
cur++;
join(find(u), find(v), cur);
}
}
int N = cur;
for (int i = N; i >= 1; i--) {
if (!vis[i]) dfs(i);
}
segtree st;
st.init(t + 2);
st.build(et);
for (int i = 1; i <= q; i++) {
if (query[i].first == 2) continue;
pair<int, int> ans = st.calc(tin[qp[i]], tout[qp[i]] + 1);
cout << ans.first << "\n";
st.set(tin[ind[ans.second]], 0);
st.set(tout[ind[ans.second]], 0);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx")
template <int, typename T>
struct MINMAX {
T val;
MINMAX(T val) : val(val) {}
};
template <typename T>
MINMAX<1, T> MAX(T val) {
return MINMAX<1, T>(val);
};
template <typename T>
MINMAX<2, T> MIN(T val) {
return MINMAX<2, T>(val);
};
template <typename T, typename U>
inline T &operator|=(T &lhs, MINMAX<1, U> rhs) {
return lhs = max(lhs, rhs.val);
}
template <typename T, typename U>
inline T &operator|=(T &lhs, MINMAX<2, U> rhs) {
return lhs = min(lhs, rhs.val);
}
template <typename T, typename U>
istream &operator>>(istream &in, pair<T, U> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T = int>
inline vector<T> READ(int n) {
vector<T> vec(n);
for (int i = 0; i < int(n); i++) cin >> vec[i];
return vec;
}
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T> >;
const int INF = 1e9;
struct tree {
vector<int> p;
vector<pair<int, int> > ch;
int find(int u) {
if (p[u] == -1) return u;
return p[u] = find(p[u]);
}
void add() {
p.push_back(-1);
ch.push_back({-1, -1});
}
void join(int u, int v) {
int ru = find(u);
int rv = find(v);
if (ru == rv) return;
add();
p[ru] = p.size() - 1;
p[rv] = p.size() - 1;
ch.back() = {ru, rv};
}
void etr(vector<int> &in, vector<int> &out) {
in.assign(p.size(), -1);
out.assign(p.size(), -1);
int t = 0;
for (int i = 0; i < int(p.size()); i++) {
if (p[i] < 0) etr(i, t, in, out);
}
}
void etr(int u, int &t, vector<int> &in, vector<int> &out) {
in[u] = t++;
if (ch[u].first >= 0) {
etr(ch[u].first, t, in, out);
etr(ch[u].second, t, in, out);
}
out[u] = t++;
}
} T;
struct SegTree {
static const int H = 20;
static const int N = 1 << H;
pair<int, int> t[2 * N] = {};
private:
void update(int ID) { t[ID] = max(t[(ID << 1)], t[(ID << 1 | 1)]); }
public:
void setPoint(int pos, int val, int ID = 1, int L = 0, int R = N - 1) {
if (L == R) {
t[ID] = {val, pos};
return;
}
int mid = L + R >> 1;
if (pos <= mid)
setPoint(pos, val, ID * 2, L, mid);
else
setPoint(pos, val, ID * 2 + 1, mid + 1, R);
update(ID);
}
pair<int, int> queryMax(int from, int to, int ID = 1, int L = 0,
int R = N - 1) {
if (from <= L && to >= R) return t[ID];
pair<int, int> res = {0, -1};
int mid = L + R >> 1;
if (from <= mid) res |= MAX(queryMax(from, to, ID * 2, L, mid));
if (to > mid) res |= MAX(queryMax(from, to, ID * 2 + 1, mid + 1, R));
return res;
}
} st;
const int MAXN = 2e5 + 5;
vector<int> adj[MAXN];
int visited[MAXN] = {0};
void dfs(int u, map<int, int> &res) {
if (visited[u]) return;
visited[u] = 1;
if (res.count(u)) return;
int newid = res.size();
res[u] = newid;
for (int to : adj[u]) dfs(to, res);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed << setprecision(12);
int n, m, Q;
cin >> n >> m >> Q;
vector<int> p = READ(n);
vector<pair<int, int> > edges = READ<pair<int, int> >(m);
vector<pair<int, int> > qry = READ<pair<int, int> >(Q);
p.insert(p.begin(), 1e9);
for (int i = 0; i < int(n + 1); i++) T.add();
set<pair<int, int> > edgeDelete;
vector<pair<int, int> > edgeOrder;
for (auto q : qry) {
if (q.first == 1) continue;
;
pair<int, int> e = edges[q.second - 1];
edgeDelete.insert(e);
}
for (int i = 0; i < int(m); i++) {
pair<int, int> e = edges[i];
if (!edgeDelete.count(e)) {
T.join(e.first, e.second);
}
}
stack<int> qryRoot;
reverse((qry).begin(), (qry).end());
for (auto q : qry) {
if (q.first == 2) {
pair<int, int> e = edges[q.second - 1];
T.join(e.first, e.second);
}
if (q.first == 1) {
int rt = T.find(q.second);
qryRoot.push(rt);
}
}
reverse((qry).begin(), (qry).end());
vector<int> in, out;
T.etr(in, out);
for (int i = 0; i < int(n + 1); i++) st.setPoint(in[i], p[i]);
for (auto q : qry) {
if (q.first == 2) continue;
;
int u = qryRoot.top();
qryRoot.pop();
pair<int, int> mx = st.queryMax(in[u], out[u]);
cout << mx.first << endl;
if (mx.second >= 0) st.setPoint(mx.second, 0);
}
}
|
#include <bits/stdc++.h>
void solve();
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int tc = 1;
while (tc--) solve();
return 0;
}
using ll = long long;
using pii = std::pair<int, int>;
using vi = std::vector<int>;
using vii = std::vector<pii>;
using std::cin;
using std::cout;
using std::sort;
using std::string;
using std::vector;
const int inf = 0x3f3f3f3f;
const int MOD = 998244853;
const int N = 700000 + 8;
int n, m, q;
pii t[N * 2], e[N], que[N];
vi adj[N];
int par[N], tin[N], tout[N], arr[N], timer = 0;
bool del[N];
int getParent(int x) {
if (x != par[x]) par[x] = getParent(par[x]);
return par[x];
}
void dsu_union(int x, int y) {
x = getParent(x);
y = getParent(y);
if (x == y) return;
++n;
par[n] = n;
par[x] = n;
par[y] = n;
adj[n].push_back(x);
adj[n].push_back(y);
}
void dfs(int x) {
tin[x] = ++timer;
for (int y : adj[x]) dfs(y);
tout[x] = timer;
}
pii segMax(int l, int r) {
r++;
pii ans(0, 0);
for (l += timer, r += timer; l < r; l /= 2, r /= 2) {
if (l & 1) ans = std::max(ans, t[l++]);
if (r & 1) ans = std::max(ans, t[--r]);
}
return ans;
}
void updatePos(int x, pii value) {
x += timer;
t[x] = value;
while (x > 1) {
x /= 2;
t[x] = std::max(t[x * 2], t[x * 2 + 1]);
}
}
void solve() {
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= m; ++i) cin >> e[i].first >> e[i].second;
for (int i = 1; i <= q; ++i) cin >> que[i].first >> que[i].second;
for (int i = 1; i <= q; ++i)
if (que[i].first == 2) del[que[i].second] = true;
for (int i = 1; i <= n; ++i) par[i] = i;
for (int i = 1; i <= m; ++i) {
if (!del[i]) dsu_union(e[i].first, e[i].second);
}
for (int i = q; i >= 1; --i) {
int type = que[i].first;
if (type == 2) {
int id = que[i].second;
dsu_union(e[id].first, e[id].second);
} else {
que[i].second = getParent(que[i].second);
}
}
for (int i = 1; i <= n; ++i) {
if (getParent(i) == i) dfs(i);
}
for (int i = 1; i <= n; ++i) updatePos(tin[i], pii(arr[i], tin[i]));
for (int i = 1; i <= q; ++i) {
int type = que[i].first;
if (type == 2) continue;
int v = que[i].second;
pii mx = segMax(tin[v], tout[v]);
cout << mx.first << '\n';
if (mx.first) updatePos(mx.second, pii(0, 0));
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long N = 1e6 + 13;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const int rx[] = {-1, +1, 0, 0};
const int ry[] = {0, 0, -1, +1};
const long double eps = 0.00001;
int p[N], us[N], pr[N];
vector<pair<int, int> > e, qq;
vector<int> g[N];
int last;
int get(int a) {
if (pr[a] == a) return a;
return pr[a] = get(pr[a]);
}
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
pr[a] = last;
pr[b] = last;
pr[last] = last;
g[last].push_back(a);
g[last].push_back(b);
g[a].push_back(last);
g[b].push_back(last);
++last;
}
int timer = 0;
int tin[N], tout[N];
void dfs(int v, int p) {
tin[v] = timer;
++timer;
for (auto to : g[v]) {
if (to == p) continue;
dfs(to, v);
}
tout[v] = timer;
}
pair<int, int> t[4 * N];
pair<int, int> mx(int v, int cl, int cr, int l, int r) {
if (cr < l || cl > r) return {0, -1};
if (l <= cl && cr <= r) return t[v];
int mid = (cl + cr) / 2;
return max(mx(v * 2, cl, mid, l, r), mx(v * 2 + 1, mid + 1, cr, l, r));
}
void upd(int v) {
t[v].first = 0;
v /= 2;
while (v > 0) {
t[v] = max(t[v * 2], t[v * 2 + 1]);
v /= 2;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < n; ++i) {
cin >> p[i];
pr[i] = i;
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
e.push_back({a, b});
}
for (int i = 0; i < q; ++i) {
int a, b;
cin >> a >> b;
--b;
if (a == 2) us[b] = 1;
qq.push_back({a, b});
}
last = n;
for (int i = 0; i < m; ++i) {
if (!us[i]) {
unite(e[i].first, e[i].second);
}
}
vector<int> need;
for (int i = q - 1; i >= 0; --i) {
if (qq[i].first == 1) {
need.push_back(get(qq[i].second));
} else {
unite(e[qq[i].second].first, e[qq[i].second].second);
}
}
reverse(need.begin(), need.end());
for (int i = 0; i < last; ++i) {
if (get(i) == i) {
dfs(i, i);
}
}
int h = 0;
while ((1ll << h) < tout[last - 1]) ++h;
int st = (1ll << h);
for (int i = n; i < last; ++i) p[i] = -1;
for (int i = 0; i < last; ++i) {
t[tin[i] + st] = {p[i], i};
}
for (int i = st - 1; i > 0; --i) {
t[i] = max(t[i * 2], t[i * 2 + 1]);
}
for (auto to : need) {
pair<int, int> cur = mx(1, 0, st - 1, tin[to], tout[to] - 1);
upd(tin[cur.second] + st);
cout << cur.first << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 100;
int p[maxn];
pair<int, int> g[maxn];
map<int, int> mp;
pair<int, int> Q[maxn];
set<pair<int, int>> st[maxn];
bool vis[maxn];
struct UFS {
int rt[maxn], sz[maxn];
void init() {
for (int i = 0; i < maxn; i++) rt[i] = i, sz[i] = 1;
}
int Find(int x) {
while (x != rt[x]) x = rt[x];
return x;
}
void Merge(int x, int y, stack<pair<int, int>>& stk) {
x = Find(x), y = Find(y);
if (x == y) {
stk.push({0, 0});
return;
}
if (sz[x] > sz[y]) swap(x, y);
for (auto it : st[x]) {
if (!vis[it.second]) st[y].insert(it);
}
rt[x] = y, sz[y] += sz[x];
stk.push({x, y});
}
void Cancel(stack<pair<int, int>>& stk) {
if (!stk.empty()) {
int x = stk.top().first, y = stk.top().second;
stk.pop();
if (x == y && x == 0) return;
set<pair<int, int>> stt;
for (auto it : st[x]) {
if (st[y].find(it) != st[y].end()) {
st[y].erase(it);
if (!vis[it.second]) stt.insert(it);
}
}
st[x].clear();
st[x] = stt;
rt[x] = x, sz[y] -= sz[x];
}
}
} ufs;
stack<pair<int, int>> stk;
int main() {
ufs.init();
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
st[i].insert({p[i], i});
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &g[i].first, &g[i].second);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) mp[Q[i].second] = 1;
}
for (int i = 1; i <= m; i++) {
if (mp.count(i) == 0) ufs.Merge(g[i].first, g[i].second, stk);
}
for (int i = q; i >= 1; i--) {
if (Q[i].first == 2)
ufs.Merge(g[Q[i].second].first, g[Q[i].second].second, stk);
}
for (int i = 1; i <= q; i++) {
if (Q[i].first == 1) {
int x = ufs.Find(Q[i].second);
if (st[x].size() == 0) {
puts("0");
continue;
}
auto it = st[x].end();
--it;
int flag = 0;
while (!flag) {
if (!vis[(*it).second]) {
flag = (*it).first;
vis[(*it).second] = 1;
st[x].erase(it);
break;
} else {
if (it == st[x].begin())
break;
else
it--;
}
}
printf("%d\n", flag);
} else {
ufs.Cancel(stk);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
inline int sign(double x) { return (x > eps) - (x < -eps); }
const int maxn = 5e5 + 10, mod = 1e9 + 7, INF = 0x3f3f3f3f;
int a[maxn];
int mx[maxn << 2], pos[maxn << 2];
void upd(int p, int c, int l, int r, int rt) {
if (l == r) {
mx[rt] = c;
pos[rt] = p;
return;
}
int m = l + r >> 1;
if (p <= m)
upd(p, c, l, m, rt << 1);
else
upd(p, c, m + 1, r, rt << 1 | 1);
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
pos[rt] = mx[rt << 1] > mx[rt << 1 | 1] ? pos[rt << 1] : pos[rt << 1 | 1];
}
pair<int, int> qry(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return make_pair(mx[rt], pos[rt]);
int m = l + r >> 1;
pair<int, int> res = make_pair(-1, -1);
if (L <= m) res = max(res, qry(L, R, l, m, rt << 1));
if (R > m) res = max(res, qry(L, R, m + 1, r, rt << 1 | 1));
return res;
}
int fa[maxn], rt;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
vector<int> e[maxn];
int dfn[maxn], sz[maxn], tim;
void dfs(int u) {
dfn[u] = ++tim;
sz[u] = 1;
upd(tim, a[u], 1, rt, 1);
for (auto v : e[u]) {
dfs(v);
sz[u] += sz[v];
}
}
int op[maxn], b[maxn], del[maxn], bl[maxn];
pair<int, int> p[maxn];
int main() {
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%d%d", &p[i].first, &p[i].second);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &op[i], &b[i]);
if (op[i] == 2) del[b[i]] = 1;
}
for (int i = 1; i <= 2 * n; ++i) fa[i] = i;
rt = n;
for (int i = 1; i <= m; ++i) {
if (del[i]) continue;
int x = p[i].first, y = p[i].second;
int fx = find(x), fy = find(y);
if (fx != fy) {
fa[fx] = fa[fy] = ++rt;
e[rt].push_back(fx);
e[rt].push_back(fy);
}
}
for (int i = q; i; --i) {
if (op[i] == 1)
bl[i] = find(b[i]);
else {
int x = p[b[i]].first, y = p[b[i]].second;
int fx = find(x), fy = find(y);
if (fx != fy) {
fa[fx] = fa[fy] = ++rt;
e[rt].push_back(fx);
e[rt].push_back(fy);
}
}
}
for (int i = rt; i; --i)
if (!sz[i]) dfs(i);
for (int i = 1; i <= q; ++i) {
if (op[i] == 2) continue;
int u = bl[i];
pair<int, int> res = qry(dfn[u], dfn[u] + sz[u] - 1, 1, rt, 1);
upd(res.second, 0, 1, rt, 1);
printf("%d\n", res.first);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t M1 = 998244353;
const int64_t M2 = 1000000007;
mt19937 rng((uint64_t)chrono::steady_clock::now().time_since_epoch().count());
vector<vector<int64_t>> node(600001);
vector<int64_t> root(600001), in(600001), out(600001), a;
int64_t n, time_stamp = 0;
int64_t get_root(int64_t u) {
return (u == root[u] ? u : (root[u] = get_root(root[u])));
}
void merge(int64_t u, int64_t v) {
u = get_root(u);
v = get_root(v);
if (u == v) return;
root[n] = n;
root[u] = n;
root[v] = n;
node[n].push_back(u);
node[n].push_back(v);
a.push_back(0);
n++;
}
class seg_tree {
int64_t n;
vector<tuple<int64_t, int64_t>> tree;
public:
seg_tree(int64_t _n) : n(_n) {
tree.resize(4 * n + 11, tuple<int64_t, int64_t>(0, 0));
}
void upd(int64_t n, int64_t s, int64_t e, int64_t i,
tuple<int64_t, int64_t> x) {
if (s == e) {
tree[n] = x;
} else {
int64_t m = (s + e) >> 1;
if (i <= m) {
upd(n << 1, s, m, i, x);
} else {
upd(n << 1 | 1, m + 1, e, i, x);
}
tree[n] = max(tree[n << 1], tree[n << 1 | 1]);
}
}
void upd(int64_t i, tuple<int64_t, int64_t> x) {
if (i < 1 || i > n) return;
upd(1, 1, n, i, x);
}
tuple<int64_t, int64_t> get_sum(int64_t n, int64_t s, int64_t e, int64_t l,
int64_t r) {
if (s > e || s > r || e < l) return tuple<int64_t, int64_t>(0, 0);
if (l <= s && e <= r) return tree[n];
int64_t m = (s + e) >> 1;
return max(get_sum(n << 1, s, m, l, r),
get_sum(n << 1 | 1, m + 1, e, l, r));
}
tuple<int64_t, int64_t> get_sum(int64_t l, int64_t r) {
if (l > r) {
return tuple<int64_t, int64_t>(0, 0);
} else {
return get_sum(1, 1, n, l, r);
}
}
};
void dfs(int64_t u) {
in[u] = ++time_stamp;
for (int64_t v : node[u]) dfs(v);
out[u] = time_stamp;
}
void solve() {
int64_t m, q;
cin >> n >> m >> q;
vector<int64_t> good(m, 1), ty(q), ui(q);
a.resize(n);
vector<tuple<int64_t, int64_t>> edges;
for (int64_t &i : a) cin >> i;
for (int64_t i = 0; i < m; i++) {
int64_t u, v;
cin >> u >> v;
edges.push_back({--u, --v});
}
for (int64_t i = 0; i < q; i++) {
cin >> ty[i] >> ui[i];
ui[i]--;
if (ty[i] == 2) {
good[ui[i]] = 0;
}
}
for (int64_t i = 0; i < n; i++) root[i] = i;
for (int64_t i = 0; i < m; i++) {
if (good[i]) {
merge(get<0>(edges[i]), get<1>(edges[i]));
}
}
for (int64_t i = q - 1; ~i; --i) {
if (ty[i] == 2) {
merge(get<0>(edges[ui[i]]), get<1>(edges[ui[i]]));
} else {
ui[i] = get_root(ui[i]);
}
}
for (int64_t i = 0; i < n; i++) {
if (i == get_root(i)) dfs(i);
}
seg_tree tree(time_stamp);
for (int64_t i = 0; i < n; i++) {
tree.upd(in[i], tuple<int64_t, int64_t>(a[i], in[i]));
}
for (int64_t i = 0; i < q; i++) {
int64_t u, v;
if (ty[i] == 1) {
tie(u, v) = tree.get_sum(in[ui[i]], out[ui[i]]);
cout << u << "\n";
tree.upd(v, tuple<int64_t, int64_t>(0, 0));
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
const int N = 2e5 + 5;
const int M = 3e5 + 5;
set<int> val[N];
vector<int> cmp[N];
int p[N], a[N], r[M];
ii qr[N + M], ed[M];
bool era[M];
void add(int i) {
int u = p[ed[i].first];
int v = p[ed[i].second];
if (u == v) return;
if (cmp[u].size() < cmp[v].size()) swap(u, v);
r[i] = v;
for (int w : cmp[v]) {
p[w] = u;
cmp[u].emplace_back(w);
}
}
void roll(int i) {
if (!r[i]) return;
int u = p[ed[i].first], v = r[i];
for (int w : cmp[v]) {
p[w] = v;
if (val[u].count(a[w])) {
val[u].erase(a[w]);
val[v].insert(a[w]);
}
cmp[u].pop_back();
}
}
void query(int u) {
u = p[u];
if (val[u].empty()) {
cout << "0\n";
return;
}
int res = *val[u].rbegin();
val[u].erase(res);
cout << res << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[i] = i;
cmp[i].emplace_back(i);
}
for (int i = 1; i <= m; i++) cin >> ed[i].first >> ed[i].second;
for (int i = 1; i <= q; i++) {
cin >> qr[i].second >> qr[i].first;
if (qr[i].second == 2) era[qr[i].first] = 1;
}
for (int i = 1; i <= m; i++)
if (!era[i]) add(i);
for (int i = q; i > 0; i--)
if (qr[i].second == 2) add(qr[i].first);
for (int i = 1; i <= n; i++) val[p[i]].insert(a[i]);
for (int i = 1; i <= q; i++)
if (qr[i].second == 1)
query(qr[i].first);
else
roll(qr[i].first);
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 5e5 + 100;
int p[maxn];
pair<int, int> g[maxn];
map<int, int> mp;
pair<int, int> Q[maxn];
set<pair<int, int>> st[maxn];
bool vis[maxn];
struct UFS {
int rt[maxn], sz[maxn];
void init() {
for (int i = 0; i < maxn; i++) rt[i] = i, sz[i] = 1;
}
int Find(int x) {
while (x != rt[x]) x = rt[x];
return x;
}
void Merge(int x, int y, stack<pair<int, int>>& stk) {
x = Find(x), y = Find(y);
if (x == y) {
stk.push({0, 0});
return;
}
if (sz[x] > sz[y]) swap(x, y);
for (auto it : st[x]) {
if (!vis[it.second]) st[y].insert(it);
}
rt[x] = y, sz[y] += sz[x];
stk.push({x, y});
}
void Cancel(stack<pair<int, int>>& stk) {
if (!stk.empty()) {
int x = stk.top().first, y = stk.top().second;
stk.pop();
if (x == y && x == 0) return;
set<pair<int, int>> stt;
for (auto it : st[x]) {
if (st[y].find(it) != st[y].end()) {
st[y].erase(it);
if (!vis[it.second]) stt.insert(it);
}
}
st[x].clear();
st[x] = stt;
rt[x] = x, sz[y] -= sz[x];
}
}
} ufs;
stack<pair<int, int>> stk;
int main() {
ufs.init();
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
st[i].insert({p[i], i});
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &g[i].first, &g[i].second);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) mp[Q[i].second] = 1;
}
for (int i = 1; i <= m; i++) {
if (mp.count(i) == 0) ufs.Merge(g[i].first, g[i].second, stk);
}
for (int i = q; i >= 1; i--) {
if (Q[i].first == 2)
ufs.Merge(g[Q[i].second].first, g[Q[i].second].second, stk);
}
for (int i = 1; i <= q; i++) {
if (Q[i].first == 1) {
int x = ufs.Find(Q[i].second);
if (st[x].size() == 0) {
puts("0");
continue;
}
auto it = st[x].end();
--it;
int flag = 0;
while (!flag) {
if (!vis[(*it).second]) {
flag = (*it).first;
vis[(*it).second] = 1;
st[x].erase(it);
break;
} else {
if (it == st[x].begin())
break;
else
it--;
}
}
printf("%d\n", flag);
} else {
ufs.Cancel(stk);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, timer, real_n;
vector<int> a, g, ts, te;
vector<vector<int>> adj;
vector<pair<int, int>> segtree;
int get(int u) { return u == g[u] ? u : g[u] = get(g[u]); }
void uni(int u, int v) {
u = get(u);
v = get(v);
if (u == v) return;
adj.push_back({u, v});
g.push_back(n);
g[u] = n;
g[v] = n;
n++;
}
void dfs(int u) {
segtree.emplace_back(u < real_n ? a[u] : 0, timer);
ts[u] = timer++;
for (int v : adj[u]) {
dfs(v);
}
te[u] = timer;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> n >> m >> q;
real_n = n;
a.resize(n);
for (auto& it : a) cin >> it;
vector<array<int, 2>> edges(m);
for (auto& it : edges) {
cin >> it[0] >> it[1];
--it[0], --it[1];
}
vector<array<int, 2>> queries(q);
vector<int> erased(m);
for (auto& it : queries) {
cin >> it[0] >> it[1];
--it[1];
if (it[0] == 2) {
erased[it[1]] = true;
}
}
g.reserve(n * 2);
g.resize(n);
adj.reserve(n * 2);
adj.resize(n);
iota(g.begin(), g.end(), 0);
for (int i = 0; i < m; i++) {
if (!erased[i]) {
uni(edges[i][0], edges[i][1]);
}
}
vector<int> real_queries;
for (int i = q - 1; i >= 0; i--) {
if (queries[i][0] == 1) {
real_queries.push_back(get(queries[i][1]));
} else {
auto& e = edges[queries[i][1]];
uni(e[0], e[1]);
}
}
ts.resize(n, -1);
te.resize(n, -1);
segtree.reserve(n * 2);
segtree.resize(n, {0, -1});
for (int i = 0; i < real_n; i++) {
int leader = get(i);
if (ts[leader] == -1) {
dfs(leader);
}
}
for (int i = n - 1; i > 0; i--) {
segtree[i] = max(segtree[i << 1], segtree[i << 1 | 1]);
}
reverse(real_queries.begin(), real_queries.end());
for (int qi : real_queries) {
int l = ts[qi] + n, r = te[qi] + n;
pair<int, int> res = {0, -1};
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, segtree[l++]);
if (r & 1) res = max(res, segtree[--r]);
}
cout << res.first << '\n';
if (res.first != 0) {
int i = res.second + n;
segtree[i].first = 0;
for (; i >>= 1;) {
segtree[i] = max(segtree[i << 1], segtree[i << 1 | 1]);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e6 + 20;
const int INF = 0x3f3f3f3f;
int n, m, q;
int arr[MAX_N];
pair<int, int> e[MAX_N], que[MAX_N];
int del[MAX_N];
int par[MAX_N];
int tin[MAX_N], tout[MAX_N];
int tree[MAX_N * 4];
vector<int> V[MAX_N];
int vis[MAX_N];
int find_p(int x) {
if (par[x] == x)
return x;
else {
return par[x] = find_p(par[x]);
}
}
void unite(int x, int y) {
x = find_p(x), y = find_p(y);
if (x == y) return;
n++;
par[n] = n;
par[x] = n, par[y] = n;
V[n].push_back(x), V[n].push_back(y);
}
void update(int nod, int l, int r, int k, int v) {
if (l == r) {
tree[nod] = v;
return;
}
int mid = (l + r) / 2;
if (k <= mid) {
update(nod * 2, l, mid, k, v);
} else {
update(nod * 2 + 1, mid + 1, r, k, v);
}
tree[nod] = max(tree[nod * 2], tree[nod * 2 + 1]);
}
int query(int nod, int l, int r, int ll, int rr) {
if (l == ll && r == rr) {
return tree[nod];
}
int mid = (l + r) / 2;
if (mid >= rr) {
return query(nod * 2, l, mid, ll, rr);
} else if (mid < ll) {
return query(nod * 2 + 1, mid + 1, r, ll, rr);
} else {
return max(query(nod * 2, l, mid, ll, mid),
query(nod * 2 + 1, mid + 1, r, mid + 1, rr));
}
}
int t = 0;
void dfs(int u) {
tin[u] = ++t;
for (auto v : V[u]) {
if (tin[v]) continue;
dfs(v);
}
tout[u] = t;
}
int M[MAX_N];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
M[arr[i]] = i;
}
for (int i = 1; i <= n; i++) par[i] = i;
int x, y;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
e[i] = pair<int, int>(x, y);
}
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
que[i] = pair<int, int>(x, y);
if (x == 2) {
del[y] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (!del[i]) unite(e[i].first, e[i].second);
}
for (int i = q; i >= 1; i--) {
if (que[i].first == 2) {
int v = que[i].second;
unite(e[v].first, e[v].second);
} else {
que[i].second = find_p(que[i].second);
}
}
for (int i = 1; i <= n; i++) {
if (find_p(i) == i) {
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
update(1, 1, t, tin[i], arr[i]);
}
for (int i = 1; i <= q; i++) {
int op = que[i].first;
if (op == 1) {
int v = que[i].second;
int x = query(1, 1, t, tin[v], tout[v]);
printf("%d\n", x);
if (x != 0) update(1, 1, t, tin[M[x]], 0);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 5e5 + 5;
const int M = 7e5 + 5;
int p[M], fa[M], id[M];
int u[N], v[N], vis[N], op[N][2];
vector<int> G[M];
int fid(int x) { return fa[x] == x ? x : fa[x] = fid(fa[x]); }
int in[M], out[M], cnt, pos[M];
void dfs(int x) {
in[x] = ++cnt;
pos[cnt] = x;
for (int i : G[x]) {
dfs(i);
}
out[x] = cnt;
}
struct node {
int x, id;
} tree[M << 2];
void pushup(int root) {
if (tree[root << 1].x > tree[root << 1 | 1].x)
tree[root] = tree[root << 1];
else
tree[root] = tree[root << 1 | 1];
}
void build(int root, int l, int r) {
if (l == r) {
tree[root].x = p[pos[l]];
tree[root].id = l;
return;
}
int mid = (l + r) >> 1;
build(root << 1, l, mid);
build(root << 1 | 1, mid + 1, r);
pushup(root);
}
void update(int root, int l, int r, int po) {
if (l == r) {
tree[root].x = 0;
return;
}
int mid = (l + r) >> 1;
if (po <= mid)
update(root << 1, l, mid, po);
else
update(root << 1 | 1, mid + 1, r, po);
pushup(root);
}
node query(int root, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return tree[root];
}
int mid = (l + r) >> 1;
node tmp1, tmp2;
tmp1.x = tmp2.x = 0;
if (L <= mid) tmp1 = query(root << 1, l, mid, L, R);
if (R > mid) tmp2 = query(root << 1 | 1, mid + 1, r, L, R);
if (tmp1.x > tmp2.x) return tmp1;
return tmp2;
}
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
fa[i] = i;
scanf("%d", &p[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
}
for (int i = 1; i <= q; i++) {
fa[n + i] = n + i;
scanf("%d%d", &op[i][0], &op[i][1]);
if (op[i][0] == 2) {
vis[op[i][1]] = 1;
}
}
for (int i = 1; i <= m; i++) {
if (vis[i]) continue;
int uu = fid(u[i]), vv = fid(v[i]);
if (uu == vv) continue;
fa[uu] = vv;
G[vv].push_back(uu);
}
for (int i = q; i > 0; i--) {
int x = op[i][1];
if (op[i][0] == 1) {
id[i] = fid(x);
continue;
}
int uu = fid(u[x]), vv = fid(v[x]);
if (uu != vv) {
n++;
fa[uu] = fa[vv] = n;
G[n].push_back(uu);
G[n].push_back(vv);
}
}
for (int i = 1; i <= n; i++) {
if (in[i]) continue;
dfs(fid(i));
}
build(1, 1, cnt);
for (int i = 1; i <= q; i++) {
if (op[i][0] == 2) continue;
node maxx = query(1, 1, cnt, in[id[i]], out[id[i]]);
if (maxx.x > 0) update(1, 1, cnt, maxx.id);
printf("%d\n", maxx.x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.141592653589793;
const int mod = 1e9 + 7;
int qt[1 << 20], qv[1 << 20], p[1 << 20], n, m, q;
pair<int, int> edg[1 << 20];
vector<int> g[1 << 20];
void append_queries() {
vector<int> help(m + 1, 0);
for (int i = 0; i < q; i++)
if (qt[i] == 2) help[qv[i]] = 1;
for (int i = 1; i <= m; i++) {
if (help[i] == 0) {
qt[q] = 2;
qv[q++] = i;
}
}
}
int parent[1 << 20], real_parent[1 << 20], tin[1 << 20], tout[1 << 20],
counter = 0, a[1 << 20], size[1 << 20];
void make_set(int v) {
parent[v] = v;
size[v] = 1;
real_parent[v] = v;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
int ra = real_parent[a], rb = real_parent[b];
real_parent[a] = ++n;
g[n].push_back(ra);
g[n].push_back(rb);
g[ra].push_back(n);
g[rb].push_back(n);
}
}
void dfs(int s, int p) {
tin[s] = ++counter;
a[counter] = s;
for (int x : g[s])
if (x != p) dfs(x, s);
tout[s] = counter;
}
int t[2000999];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = tl;
} else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
if (p[a[t[v * 2]]] > p[a[t[v * 2 + 1]]])
t[v] = t[v * 2];
else
t[v] = t[v * 2 + 1];
}
}
int max_in(int v, int tl, int tr, int l, int r) {
if (l > r) return -1;
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
int x = max_in(v * 2, tl, tm, l, min(r, tm));
int b = max_in(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
if (x == -1) return b;
if (b == -1) return x;
if (p[a[x]] > p[a[b]]) return x;
return b;
}
void update(int v, int tl, int tr, int pos) {
if (tl == tr) {
t[v] = tl;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos);
else
update(v * 2 + 1, tm + 1, tr, pos);
if (p[a[t[v * 2]]] > p[a[t[v * 2 + 1]]])
t[v] = t[v * 2];
else
t[v] = t[v * 2 + 1];
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &edg[i].first, &edg[i].second);
}
for (int i = 0; i < q; i++) {
scanf("%d %d", &qt[i], &qv[i]);
}
append_queries();
for (int i = 1; i <= n; i++) make_set(i);
for (int i = q - 1; i >= 0; i--) {
if (qt[i] == 2) {
int u = edg[qv[i]].first, v = edg[qv[i]].second;
union_sets(u, v);
} else {
qv[i] = real_parent[find_set(qv[i])];
}
}
for (int i = 1; i <= n; i++) {
if (i == parent[i]) {
int x = real_parent[i];
dfs(x, -1);
}
}
build(1, 1, n);
for (int i = 0; i < q; i++) {
if (qt[i] == 1) {
int inmx = max_in(1, 1, n, tin[qv[i]], tout[qv[i]]);
cout << p[a[inmx]] << endl;
p[a[inmx]] = 0;
update(1, 1, n, inmx);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int INF = 0x3f3f3f3f;
const int inf = -INF;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-5;
int n, m, q;
vector<int> g[N];
int a[N], in[N], out[N], f[N];
int tot;
int tree[N], ui[N], vi[N];
int Find(int x) { return x == f[x] ? x : f[x] = Find(f[x]); }
void merge(int x, int y) {
x = Find(x), y = Find(y);
if (x == y) return;
if (x != y) {
n++;
f[n] = n;
f[x] = n;
f[y] = n;
g[n].push_back(x);
g[n].push_back(y);
}
}
void dfs(int u) {
in[u] = ++tot;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (in[v]) continue;
dfs(v);
}
out[u] = tot;
}
void up(int root) { tree[root] = max(tree[root << 1], tree[root << 1 | 1]); }
void build(int pos, int c, int i, int l, int r) {
if (l == r) {
tree[i] = c;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
build(pos, c, i << 1, l, mid);
else
build(pos, c, i << 1 | 1, mid + 1, r);
up(i);
}
int query(int L, int R, int i, int l, int r) {
if (L <= l && r <= R) return tree[i];
int res = 0;
int mid = l + r >> 1;
if (L <= mid) {
res = max(res, query(L, R, i << 1, l, mid));
}
if (R > mid) res = max(res, query(L, R, i << 1 | 1, mid + 1, r));
return res;
}
int pos[N], op[N], x[N], del[N];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
f[i] = i;
}
for (int i = 1; i <= m; i++) scanf("%d%d", &ui[i], &vi[i]);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &op[i], &x[i]);
if (op[i] == 2) del[x[i]] = 1;
}
for (int i = 1; i <= m; i++)
if (!del[i]) merge(ui[i], vi[i]);
for (int i = q; i >= 1; i--) {
if (op[i] == 1)
x[i] = Find(x[i]);
else
merge(ui[x[i]], vi[x[i]]);
}
for (int i = 1; i <= n; i++)
if (f[i] == i) dfs(i);
for (int i = 1; i <= n; i++) build(in[i], a[i], 1, 1, n);
for (int i = 1; i <= q; i++) {
if (op[i] == 1) {
int ans = query(in[x[i]], out[x[i]], 1, 1, n);
printf("%d\n", ans);
if (ans) build(in[pos[ans]], 0, 1, 1, n);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500500;
using pii = pair<int, int>;
set<pii> s[N];
int parent[N];
int w[N];
pii edge[N];
pii request[N];
int destroy[N];
int active[N];
int n, m, q;
int ex[N];
int ey[N];
int iii;
int get_parent(int x) {
while (x != parent[x]) {
x = parent[x];
}
return x;
}
int unite(int x, int y) {
x = get_parent(x);
y = get_parent(y);
if (x == y) return 0;
if (w[x] < w[y]) swap(x, y);
ex[iii] = x;
ey[iii] = y;
parent[y] = x;
w[x] += w[y];
for (auto q : s[y]) {
s[x].insert({q.first, y});
}
return 1;
}
void update_parent(int v, int x, int from) {
if (parent[v] != v) {
update_parent(parent[v], x, v);
}
s[v].erase({x, from});
}
void dbg() {
cout << "OK" << endl;
for (int i = 1; i <= n; ++i) {
cout << "i=" << i << " parent=" << parent[i] << " w=" << w[i] << " ... ";
for (auto q : s[i]) cout << "(" << q.first << "," << q.second << ") ";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
parent[i] = i;
w[i] = 1;
s[i].insert({-x, i});
}
for (int i = 1; i <= m; ++i) {
cin >> edge[i].first >> edge[i].second;
}
for (int i = 1; i <= q; ++i) {
cin >> request[i].first >> request[i].second;
if (request[i].first == 2) {
destroy[request[i].second] = true;
}
}
for (int i = 1; i <= m; ++i) {
if (destroy[i]) continue;
unite(edge[i].first, edge[i].second);
}
for (int i = q; i >= 1; --i) {
if (request[i].first == 2) {
int v = request[i].second;
iii = v;
if (unite(edge[v].first, edge[v].second)) active[v] = true;
}
}
for (int i = 1; i <= q; ++i) {
if (request[i].first == 2) {
int index = request[i].second;
if (!active[index]) continue;
int x = ex[index];
int y = ey[index];
for (auto q : s[y]) {
update_parent(x, q.first, y);
}
parent[y] = y;
continue;
}
int v = request[i].second;
v = get_parent(v);
if (s[v].size() == 0) {
cout << 0 << "\n";
continue;
}
auto it = s[v].begin();
cout << -it->first << "\n";
while (it->second != v) {
int vn = it->second;
s[v].erase(it);
v = vn;
it = s[v].begin();
if (it == s[v].end()) {
cout << "Fuck!" << endl;
return 0;
}
}
s[v].erase(it);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
os << "]";
return os;
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const int N = 200005;
int p[N];
int x[N << 1], y[N << 1];
bool removed[N << 1];
vector<pair<int, int>> query;
struct DSU {
vector<int> a, s;
vector<pair<int, int>> changes;
vector<set<int>> elements;
DSU(int n) {
a.resize(n + 1);
s.resize(n + 1);
elements.resize(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = i;
s[i] = 1;
elements[i].insert(p[i]);
}
}
int root(int i) {
while (i != a[i]) i = a[i];
return i;
}
bool merge(int x, int y) {
int xr = root(x), yr = root(y);
if (xr == yr) {
changes.push_back({xr, xr});
return false;
}
if (s[xr] < s[yr]) swap(xr, yr);
s[xr] += s[yr];
elements[xr].insert(elements[yr].begin(), elements[yr].end());
a[yr] = xr;
changes.push_back({xr, yr});
return true;
}
void rollBack() {
if (changes.empty()) return;
pair<int, int> p = changes.back();
int xr = p.first, yr = p.second;
changes.pop_back();
if (xr == yr) return;
for (auto it = elements[yr].begin(); it != elements[yr].end();) {
if (elements[xr].find(*it) != elements[xr].end())
elements[xr].erase(*it), it++;
else
it = elements[yr].erase(it);
}
a[yr] = yr;
s[xr] = elements[xr].size();
s[yr] = elements[yr].size();
}
int query(int x) {
int xr = root(x);
if (elements[xr].empty()) return 0;
int ret = *(--elements[xr].end());
elements[xr].erase(--elements[xr].end());
s[xr]--;
return ret;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
set<int> s;
s.erase(5);
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i < n + 1; i++) cin >> p[i];
for (int i = 1; i < m + 1; i++) cin >> x[i] >> y[i];
query.resize(q);
vector<int> r;
for (int i = 0; i < q; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 2)
removed[query[i].second] = true, r.push_back(query[i].second);
}
DSU d(n);
for (int i = 1; i < m + 1; i++) {
if (!removed[i]) d.merge(x[i], y[i]);
}
reverse(r.begin(), r.end());
for (int i = 0; i < r.size(); i++) d.merge(x[r[i]], y[r[i]]);
for (int i = 0; i < q; i++) {
if (query[i].first == 1)
cout << d.query(query[i].second) << '\n';
else
d.rollBack();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const double PI = acos(-1.0);
struct UF {
vector<long long> p, r;
long long conjuntos = 0;
UF(long long n) {
conjuntos = n;
for (long long i = 0; i < n; i++) {
p.push_back(i);
r.push_back(0);
}
}
long long find(long long x) { return p[x] = p[x] == x ? x : find(p[x]); }
void join(long long x, long long y) {
x = find(x);
y = find(y);
if (x != y) {
conjuntos--;
if (r[x] >= r[y]) {
if (r[x] == r[y]) r[x]++;
p[y] = x;
} else
p[x] = y;
}
}
};
struct SegmentTree {
vector<pair<long long, long long> > ST;
long long N;
SegmentTree(vector<long long>& A) {
N = A.size();
ST.resize(4 * N);
build(1, 0, N - 1, A);
}
void build(long long n, long long l, long long r, vector<long long>& A) {
if (l == r) {
ST[n] = {A[r], l};
return;
}
build(2 * n, l, (l + r) / 2, A);
build(2 * n + 1, (l + r) / 2 + 1, r, A);
ST[n] = max(ST[2 * n], ST[2 * n + 1]);
}
pair<long long, long long> query(long long i, long long j) {
return query(1, 0, N - 1, i, j);
}
pair<long long, long long> query(long long n, long long l, long long r,
long long i, long long j) {
if (r < i || j < l) return {-1, -1};
if (i <= l && r <= j) return ST[n];
return max(query(2 * n, l, (l + r) / 2, i, j),
query(2 * n + 1, (l + r) / 2 + 1, r, i, j));
}
void update(long long i, long long v) { return update(1, 0, N - 1, i, v); }
void update(long long n, long long l, long long r, long long i, long long v) {
if (i < l || r < i) return;
if (l == r) {
ST[n].first = v;
return;
}
update(2 * n, l, (l + r) / 2, i, v);
update(2 * n + 1, (l + r) / 2 + 1, r, i, v);
ST[n] = max(ST[2 * n], ST[2 * n + 1]);
}
};
long long cont = -1, n;
vector<long long> L(400005, -1), R(400005, -1), ID(400005, -1);
vector<long long> arr;
void dfs(vector<vector<long long> >& g, vector<long long>& vis,
vector<long long>& c, long long in, long long id) {
if (!vis[in]) {
vis[in] = 1;
cont++;
if (in >= n)
arr.push_back(-1);
else
arr.push_back(c[in]);
L[in] = cont;
ID[in] = id;
for (int i = 0; i < g[in].size(); i++) {
if (!vis[g[in][i]]) dfs(g, vis, c, g[in][i], id);
}
R[in] = cont;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long m, q, x, y;
cin >> n >> m >> q;
vector<long long> c;
for (int i = 0; i < n; i++) {
cin >> x;
c.push_back(x);
}
vector<pair<long long, long long> > ar;
vector<long long> visar(m, 0);
for (int i = 0; i < m; i++) {
cin >> x >> y;
ar.push_back({x - 1, y - 1});
}
vector<pair<long long, long long> > Q;
for (int i = 0; i < q; i++) {
cin >> x >> y;
Q.push_back({x, y - 1});
if (x == 2) visar[y - 1] = 1;
}
for (int i = 0; i < m; i++) {
if (!visar[i]) Q.push_back({2, i});
}
UF uf(400005);
long long in = n;
vector<vector<long long> > g(400005, vector<long long>(0));
vector<long long> que(Q.size(), -1);
for (int i = Q.size() - 1; i >= 0; i--) {
if (Q[i].first == 2) {
long long x = uf.find(ar[Q[i].second].first),
y = uf.find(ar[Q[i].second].second);
if (x == y) continue;
g[in].push_back(x);
g[in].push_back(y);
uf.p[x] = in;
uf.p[y] = in;
in++;
} else {
long long x = uf.find(Q[i].second);
que[i] = x;
}
}
set<long long> nod;
for (int i = 0; i < n; i++) {
nod.insert(uf.find(i));
}
long long id = 0;
vector<SegmentTree> STs;
for (auto it : nod) {
arr.clear();
vector<long long> vis(in, 0);
cont = -1;
dfs(g, vis, c, it, id);
SegmentTree ST(arr);
STs.push_back(ST);
id++;
}
for (int i = 0; i < Q.size(); i++) {
if (Q[i].first == 1) {
long long id, v;
tie(v, id) = STs[ID[que[i]]].query(L[que[i]], R[que[i]]);
cout << v << "\n";
STs[ID[que[i]]].update(id, 0);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
const int M = (int)3e5 + 7;
const int Q = (int)5e5 + 7;
int n;
int m;
int q;
int val[N + M];
int a[M];
int b[M];
int type[Q];
int memo[Q];
int dsu[N + M];
bool use[M];
int node[Q];
vector<int> g[N + M];
int dsu_root(int x) {
if (dsu[x] == x) {
return x;
} else {
return dsu[x] = dsu_root(dsu[x]);
}
}
void unite(int x, int y) { dsu[dsu_root(x)] = dsu_root(y); }
void unite_edge(int i) {
int x = a[i];
int y = b[i];
if (dsu_root(x) != dsu_root(y)) {
g[i + n].push_back(dsu_root(x));
g[i + n].push_back(dsu_root(y));
unite(x, i + n);
unite(y, i + n);
}
}
int l[N + M];
int r[N + M];
int top;
int tree[4 * (N + M)];
int best(int i, int j) {
if (val[i] > val[j]) {
return i;
} else {
return j;
}
}
void dfs(int a) {
l[a] = ++top;
for (auto &b : g[a]) {
dfs(b);
}
r[a] = top;
}
void upd(int v, int tl, int tr, int i) {
if (tr < i || i < tl) {
return;
}
if (tl == tr) {
tree[v] = i;
return;
}
int tm = (tl + tr) / 2;
upd(2 * v, tl, tm, i);
upd(2 * v + 1, tm + 1, tr, i);
tree[v] = best(tree[2 * v], tree[2 * v + 1]);
}
int get(int v, int tl, int tr, int l, int r) {
if (tr < l || r < tl) {
return 0;
}
if (l <= tl && tr <= r) {
return tree[v];
}
int tm = (tl + tr) / 2;
return best(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm + 1, tr, l, r));
}
void upd(int i, int x) {
val[i] = x;
upd(1, 1, n + m, i);
}
int get(int l, int r) { return get(1, 1, n + m, l, r); }
bool poate[N + M];
int kek[N + M];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) {
cin >> val[i];
}
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
val[n + i] = -1;
}
for (int i = 1; i <= q; i++) {
cin >> type[i] >> memo[i];
if (type[i] == 2) {
use[memo[i]] = 1;
}
}
for (int i = 1; i <= n + m; i++) {
dsu[i] = i;
}
for (int i = 1; i <= m; i++) {
if (use[i] == 0) {
unite_edge(i);
}
}
for (int i = q; i >= 1; i--) {
if (type[i] == 1) {
node[i] = dsu_root(memo[i]);
} else {
unite_edge(memo[i]);
}
}
for (int i = 1; i <= n + m; i++) {
poate[i] = 1;
}
val[0] = -1;
for (int i = 1; i <= n + m; i++) {
for (auto &j : g[i]) {
poate[j] = 0;
}
}
for (int i = 1; i <= n + m; i++) {
if (poate[i]) {
g[n + m + 1].push_back(i);
}
}
m++;
dfs(n + m);
for (int i = 1; i <= n + m; i++) {
kek[i] = val[i];
}
for (int i = 1; i <= n + m; i++) {
upd(l[i], kek[i]);
}
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
int k = get(l[node[i]], r[node[i]]);
cout << val[k] << "\n";
upd(k, 0);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 400003;
int n = 0, m = 0, q = 0, cPoint = 0;
int p[maxn];
struct Edge {
int u, e;
int id;
};
Edge E[maxn];
int deleteTime[maxn];
inline bool operator<(Edge const &lhs, Edge const &rhs) {
return deleteTime[lhs.id] > deleteTime[rhs.id];
}
int opt[500003], Sec[500003];
int head[maxn], nxt[maxn], to[maxn], cnt = 0;
inline void insert(int u, int e) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = e;
}
int fath[maxn];
inline int find(int x) { return fath[x] == x ? x : fath[x] = find(fath[x]); }
int ti[maxn];
void CreateTheTree() {
std::sort(E + 1, E + m + 1);
for (int i = 1; i <= 2 * n; ++i) fath[i] = i;
cPoint = n;
for (int i = 1; i <= m; ++i) {
if (find(E[i].u) == find(E[i].e)) continue;
++cPoint;
ti[cPoint] = deleteTime[E[i].id];
insert(cPoint, find(E[i].u));
insert(cPoint, find(E[i].e));
fath[find(E[i].u)] = cPoint;
fath[find(E[i].e)] = cPoint;
}
}
int fa[20][maxn], Ldfn[maxn], Rdfn[maxn];
int dfn[maxn], idfn[maxn];
void dfs(int x, int f) {
fa[0][x] = f;
for (int j = 1; j <= 18; ++j) fa[j][x] = fa[j - 1][fa[j - 1][x]];
if (x <= n) {
Ldfn[x] = Rdfn[x] = dfn[x] = ++dfn[0];
idfn[dfn[x]] = x;
return;
}
Ldfn[x] = cPoint + 1, Rdfn[x] = 0;
for (int i = head[x]; i; i = nxt[i]) {
dfs(to[i], x);
Ldfn[x] = std::min(Ldfn[x], Ldfn[to[i]]);
Rdfn[x] = std::max(Rdfn[x], Rdfn[to[i]]);
}
}
struct MX {
int v, pos;
};
MX operator|(MX const &lhs, MX const &rhs) { return lhs.v > rhs.v ? lhs : rhs; }
MX mx[maxn << 2];
void CreateSeg(int po, int L, int R) {
if (L == R) {
mx[po].v = p[idfn[L]];
mx[po].pos = idfn[L];
return;
}
int mid = (L + R) >> 1;
CreateSeg(po << 1, L, mid);
CreateSeg(po << 1 | 1, mid + 1, R);
mx[po] = mx[po << 1] | mx[po << 1 | 1];
}
void Modify(int po, int L, int R, int x) {
if (L == R) {
mx[po].v = p[idfn[L]];
return;
}
int mid = (L + R) >> 1;
if (x <= mid)
Modify(po << 1, L, mid, x);
else
Modify(po << 1 | 1, mid + 1, R, x);
mx[po] = mx[po << 1] | mx[po << 1 | 1];
}
MX query(int po, int L, int R, int l, int r) {
if (l <= L && R <= r) return mx[po];
int mid = (L + R) >> 1;
if (r <= mid)
return query(po << 1, L, mid, l, r);
else if (l > mid)
return query(po << 1 | 1, mid + 1, R, l, r);
else
return query(po << 1, L, mid, l, r) | query(po << 1 | 1, mid + 1, R, l, r);
}
int jump(int x, int time) {
for (int j = 18; ~j; --j)
if (ti[fa[j][x]] > time) x = fa[j][x];
return x;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) scanf("%d", p + i);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &E[i].u, &E[i].e);
E[i].id = i;
deleteTime[i] = q + 1;
}
for (int i = 1; i <= q; ++i) {
scanf("%d %d", opt + i, Sec + i);
if (opt[i] == 2) deleteTime[Sec[i]] = i;
}
CreateTheTree();
for (int i = 1; i <= cPoint; ++i)
if (fath[i] == i) dfs(i, 0);
CreateSeg(1, 1, n);
for (int i = 1; i <= q; ++i)
if (opt[i] == 1) {
int x = jump(Sec[i], i);
MX res = query(1, 1, n, Ldfn[x], Rdfn[x]);
printf("%d\n", res.v);
if (res.v != 0) {
p[res.pos] = 0;
Modify(1, 1, n, dfn[res.pos]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxm = 6e5 + 10;
const int maxn = 6e5 + 10;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
return 1;
}
inline bool read(char &x) {
while ((x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
x == '\n' || x == '\r')
;
return x != EOF;
}
inline bool read(char *x) {
while ((*x = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*x == ' ' || *x == '\r')
;
if (*x == EOF) return 0;
while (!(*x == '\n' || *x == ' ' || *x == '\r' || *x == EOF))
*(++x) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*x = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &x, B &...y) {
return read(x) && read(y...);
}
template <typename A>
inline bool write(A x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char x) {
putc(x);
return 0;
}
inline bool write(const char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
inline bool write(char *x) {
while (*x) {
putc(*x);
++x;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A x, B... y) {
return write(x) || write(y...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int p[maxm], fa[maxn], res[maxm], del[maxn], ch[maxm][2];
int in[maxm], rk[maxm], out[maxm], pos[maxm];
int tree[maxm << 2];
int cnt, tot;
struct Edge {
int u, v;
} ed[maxn];
struct Query {
int op, x;
} q[maxm];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void unite(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
++cnt;
fa[cnt] = cnt;
fa[u] = fa[v] = cnt;
ch[cnt][0] = u;
ch[cnt][1] = v;
}
void init(int n, int m) {
cnt = n;
for (int i = 1; i <= n; i++) {
fa[i] = i;
}
for (int i = 1; i <= m; i++) {
if (!del[i]) unite(ed[i].u, ed[i].v);
}
}
void dfs(int x) {
in[x] = ++tot;
rk[tot] = x;
for (int i = 0; i < 2; i++)
if (ch[x][i]) dfs(ch[x][i]);
out[x] = tot;
}
void pushup(int rt) { tree[rt] = max(tree[rt << 1], tree[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
tree[rt] = p[rk[l]];
return;
}
int mid = l + r >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int pos, int l, int r, int rt) {
if (l == r) {
tree[rt] = 0;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
update(pos, l, mid, rt << 1);
else
update(pos, mid + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return tree[rt];
}
int mid = l + r >> 1;
int res = 0;
if (L <= mid) res = query(L, R, l, mid, rt << 1);
if (R > mid) res = max(res, query(L, R, mid + 1, r, rt << 1 | 1));
return res;
}
int main() {
int n, m, Q;
read(n, m, Q);
for (int i = 1; i <= n; i++) read(p[i]), pos[p[i]] = i;
for (int i = 1; i <= m; i++) {
int u, v;
read(u, v);
ed[i] = {u, v};
}
for (int i = 1; i <= Q; i++) {
int op, x;
read(op, x);
q[i] = {op, x};
if (op == 2) del[x] = 1;
}
init(n, m);
for (int i = Q; i; i--) {
int op = q[i].op, x = q[i].x;
if (op == 2) {
unite(ed[x].u, ed[x].v);
}
if (op == 1) {
x = find(x);
res[i] = x;
}
}
int last = 0;
for (int i = 1; i <= cnt; i++) {
if (i == find(i)) {
if (!last)
last = i;
else
unite(last, i);
}
}
dfs(cnt);
build(1, tot, 1);
for (int i = 1; i <= Q; i++) {
if (q[i].op == 2) continue;
int ans = query(in[res[i]], out[res[i]], 1, tot, 1);
printf("%d\n", ans);
if (!ans) continue;
update(in[pos[ans]], 1, tot, 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int& a) {
static char c = getchar();
a = 0;
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
a *= f;
return;
}
int n, m, q, ti[500010 << 1], w[500010 << 1], fa[500010 << 1];
int fd(int x) {
if (x != fa[x]) fa[x] = fd(fa[x]);
return fa[x];
}
int fi[500010 << 1], ne[500010 << 2], to[500010 << 2], tot, cnt;
int dfn[500010 << 1], dfcnt, siz[500010 << 1], rev[500010 << 1];
int jp[500010 << 1][21], A[500010], B[500010], type[500010], qr[500010],
deled[500010];
inline void add(int x, int y) {
ne[++tot] = fi[x];
to[tot] = y;
fi[x] = tot;
}
inline void ad(int x, int y) {
add(x, y);
add(y, x);
}
void dfs(int x) {
for (int i = 1; i <= 20; i++) jp[x][i] = jp[jp[x][i - 1]][i - 1];
rev[dfn[x] = ++dfcnt] = x;
siz[x] = 1;
for (int i = fi[x]; i; i = ne[i]) {
if (to[i] == jp[x][0]) continue;
jp[to[i]][0] = x;
dfs(to[i]);
siz[x] += siz[to[i]];
}
}
namespace seg {
int tr[500010 << 3];
inline void up(int now) {
if (w[tr[now << 1]] > w[tr[now << 1 | 1]])
tr[now] = tr[now << 1];
else
tr[now] = tr[now << 1 | 1];
}
void build(int now = 1, int l = 1, int r = cnt) {
if (l == r) {
tr[now] = rev[l];
return;
}
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
up(now);
}
void upd(int x, int now = 1, int l = 1, int r = cnt) {
if (l == r) {
w[tr[now]] = 0;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
upd(x, now << 1, l, mid);
else
upd(x, now << 1 | 1, mid + 1, r);
up(now);
}
int qry(int x, int y, int now = 1, int l = 1, int r = cnt) {
if (x <= l && y >= r) return tr[now];
int mid = (l + r) >> 1, ans = 0;
if (x <= mid) {
int nans = qry(x, y, now << 1, l, mid);
if (w[nans] > w[ans]) ans = nans;
}
if (y > mid) {
int nans = qry(x, y, now << 1 | 1, mid + 1, r);
if (w[nans] > w[ans]) ans = nans;
}
return ans;
}
} // namespace seg
using seg::qry;
using seg::upd;
int main() {
read(n);
read(m);
read(q);
w[0] = -1;
cnt = n;
for (int i = 1; i <= n; i++) read(w[i]), ti[i] = q + 1, fa[i] = i;
for (int i = 1; i <= m; i++) read(A[i]), read(B[i]);
for (int i = 1; i <= q; i++) {
read(type[i]);
read(qr[i]);
if (type[i] == 2) deled[qr[i]] = 1;
}
for (int i = 1; i <= m; i++) {
if (deled[i]) continue;
int x = fd(A[i]), y = fd(B[i]);
if (x != y) {
++cnt;
w[cnt] = -1;
ad(x, cnt);
ad(y, cnt);
fa[x] = fa[y] = cnt;
fa[cnt] = cnt;
ti[cnt] = q + 1;
}
}
for (int i = q; i; i--) {
if (type[i] == 2) {
int x = fd(A[qr[i]]), y = fd(B[qr[i]]);
if (x != y) {
++cnt;
w[cnt] = -1;
ad(x, cnt);
ad(y, cnt);
fa[x] = fa[y] = cnt;
fa[cnt] = cnt;
ti[cnt] = i;
}
}
}
for (int i = 1; i <= cnt; i++)
if (fd(i) == i) jp[i][0] = 0, dfs(i);
seg::build();
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
int x = qr[i];
for (int j = 20; ~j; j--)
if (ti[jp[x][j]] >= i) x = jp[x][j];
int y = qry(dfn[x], dfn[x] + siz[x] - 1);
printf("%d\n", w[y]);
upd(dfn[y]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
std::vector<int> val(1000005);
std::map<int, pair<int, int> > edges;
std::vector<pair<int, int> > query(1000005);
int vis[1000005];
int par[1000005];
set<pair<int, int> > ss[1000005];
int sz[1000005];
std::vector<pair<int, int> > changes[1000005];
int st[1000005], en[1000005];
int getpar(int x) {
if (par[x] == x)
return x;
else
return getpar(par[x]);
}
void merge(int n1, int n2, int idx) {
assert(n1 >= 0 && n1 < 1000005);
assert(n2 >= 0 && n2 < 1000005);
int p1 = getpar(n1);
int p2 = getpar(n2);
assert(p1 >= 0 && p1 < 1000005);
assert(p2 >= 0 && p2 < 1000005);
if (p1 == p2) return;
if (sz[p1] > sz[p2]) swap(p1, p2);
sz[p2] += sz[p1];
sz[p1] = 0;
for (auto i : ss[p1]) {
ss[p2].insert(i);
}
par[p1] = p2;
if (idx != -1) {
st[idx] = p1;
en[idx] = p2;
for (auto i : ss[p1]) {
changes[idx].push_back(i);
}
}
ss[p1].clear();
}
int getans(int node) {
int pp = getpar(node);
assert(ss[pp].size());
pair<int, int> zz = *(ss[pp].rbegin());
cout << zz.first << '\n';
auto it = ss[pp].rbegin();
ss[pp].erase(zz);
val[zz.second] = 0;
assert(zz.second >= 0 && zz.second < 1000005);
ss[pp].insert({val[zz.second], zz.second});
return zz.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i < n + 1; i++) {
cin >> val[i];
sz[i] = 1;
par[i] = i;
ss[par[i]].insert({val[i], i});
}
for (int i = 1; i < m + 1; i++) {
int x, y;
cin >> x >> y;
edges[i] = {x, y};
}
for (int i = 1; i < q + 1; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 2) {
vis[query[i].second] = 1;
}
}
for (int i = 1; i < m + 1; i++) {
if (!vis[i]) {
merge(edges[i].first, edges[i].second, -1);
}
}
for (int i = q; i >= 1; i--) {
if (query[i].first == 2) {
merge(edges[query[i].second].first, edges[query[i].second].second, i);
}
}
for (int i = 1; i < q + 1; i++) {
if (query[i].first == 1) {
getans(query[i].second);
} else {
int st1 = st[i];
assert(st1 >= 0 && st1 < 1000005);
int en1 = en[i];
assert(en1 >= 0 && en1 < 1000005);
ss[st1].clear();
for (auto j : changes[i]) {
assert(j.second >= 0 && j.second < 1000005);
ss[st1].insert({val[j.second], j.second});
ss[en1].erase({val[j.second], j.second});
}
changes[i].clear();
par[st1] = st1;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)5e5 + 5;
const int MAXM = (int)3e5 + 5;
const int MAXQ = (int)5e5 + 5;
pair<int, int> e[MAXM], que[MAXQ], t[MAXN << 2];
vector<int> adj[MAXN];
int tin[MAXN], tout[MAXN], timer;
int par[MAXN], arr[MAXN];
bool del[MAXM];
int n, m, q;
int getPar(int x) {
if (x == par[x]) {
return x;
}
return par[x] = getPar(par[x]);
}
void uni(int a, int b) {
a = getPar(a);
b = getPar(b);
if (a == b) {
return;
}
++n;
par[n] = n;
par[a] = n;
par[b] = n;
adj[n].push_back(a);
adj[n].push_back(b);
}
void dfs(int v) {
tin[v] = ++timer;
for (int to : adj[v]) {
dfs(to);
}
tout[v] = timer;
}
pair<int, int> segMax(int v, int tl, int tr, int l, int r) {
if (l > r || tl > r || tr < l) {
return make_pair(0, 0);
}
if (l <= tl && tr <= r) {
return t[v];
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
return max(segMax(c1, tl, mid, l, r), segMax(c2, mid + 1, tr, l, r));
}
void updPos(int v, int tl, int tr, int p, pair<int, int> x) {
if (tl == tr) {
t[v] = x;
return;
}
int mid = (tl + tr) >> 1;
int c1 = (v << 1), c2 = (c1 | 1);
if (p <= mid) {
updPos(c1, tl, mid, p, x);
} else {
updPos(c2, mid + 1, tr, p, x);
}
t[v] = max(t[c1], t[c2]);
}
void solve() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
}
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
e[i] = make_pair(u, v);
}
for (int i = 1; i <= q; ++i) {
int a, b;
scanf("%d %d", &a, &b);
que[i] = make_pair(a, b);
if (a == 2) {
del[b] = 1;
}
}
for (int i = 1; i <= n; ++i) {
par[i] = i;
}
for (int i = 1; i <= m; ++i) {
if (!del[i]) {
uni(e[i].first, e[i].second);
}
}
for (int i = q; i > 0; --i) {
int tp = que[i].first;
if (tp == 2) {
int id = que[i].second;
uni(e[id].first, e[id].second);
} else {
que[i].second = getPar(que[i].second);
}
}
for (int i = 1; i <= n; ++i) {
if (getPar(i) == i) {
dfs(i);
}
}
for (int i = 1; i <= n; ++i) {
updPos(1, 1, n, tin[i], make_pair(arr[i], tin[i]));
}
for (int i = 1; i <= q; ++i) {
int tp = que[i].first;
if (tp == 1) {
int v = que[i].second;
pair<int, int> tmp = segMax(1, 1, n, tin[v], tout[v]);
if (tmp.first == 0) {
printf("0\n");
} else {
printf("%d\n", tmp.first);
updPos(1, 1, n, tmp.second, make_pair(0, 0));
}
}
}
}
int main() {
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
vector<pair<int, int>> edges;
vector<pair<int, int>> queries;
int nodes[MAX], ds[MAX], currentNode, tourID;
bool dels[MAX];
vector<int> ady[MAX];
pair<int, int> stree[4 * MAX];
int idIni[MAX], idFin[MAX];
int dsFind(int v) {
if (ds[v] == v) {
return v;
}
return ds[v] = dsFind(ds[v]);
}
void dsJoin(int u, int v) {
currentNode++;
u = dsFind(u);
v = dsFind(v);
if (u == v) return;
ds[currentNode] = currentNode;
ds[u] = currentNode;
ds[v] = currentNode;
ady[currentNode].push_back(u);
ady[currentNode].push_back(v);
}
pair<int, int> query(int n, int ini, int fin, int a, int b) {
if (ini > b || fin < a) {
return make_pair(INT_MIN, INT_MIN);
} else if (ini >= a && fin <= b) {
return stree[n];
} else {
int mid = (ini + fin) / 2;
return max(query(n * 2, ini, mid, a, b),
query(n * 2 + 1, mid + 1, fin, a, b));
}
}
void update(int n, int ini, int fin, int p, int v) {
if (ini > p || fin < p) {
return;
} else if (ini >= p && fin <= p) {
stree[n] = make_pair(v, p);
} else {
int mid = (ini + fin) / 2;
update(n * 2, ini, mid, p, v);
update(n * 2 + 1, mid + 1, fin, p, v);
stree[n] = max(stree[n * 2], stree[n * 2 + 1]);
}
}
void dfs(int u) {
tourID++;
idIni[u] = tourID;
for (auto v : ady[u]) {
dfs(v);
}
idFin[u] = tourID;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
memset(stree, -63, sizeof stree);
int N, M, Q;
cin >> N >> M >> Q;
currentNode = N;
for (int i = 1; i <= N; i++) {
cin >> nodes[i];
}
edges.emplace_back(0, 0);
queries.emplace_back(0, 0);
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
edges.emplace_back(u, v);
}
for (int i = 0; i < Q; i++) {
int t, v;
cin >> t >> v;
if (t == 2) {
dels[v] = true;
}
queries.emplace_back(t, v);
}
for (int i = 1; i <= N; i++) {
ds[i] = i;
}
for (int i = 1; i <= M; i++) {
if (!dels[i]) {
dsJoin(edges[i].first, edges[i].second);
}
}
for (int i = Q; i > 0; i--) {
int t = queries[i].first;
int n = queries[i].second;
if (t == 1) {
queries[i].second = dsFind(n);
} else {
dsJoin(edges[n].first, edges[n].second);
}
}
for (int i = 1; i < MAX; i++) {
if (ds[i] == i) {
dfs(i);
}
}
tourID++;
for (int i = 1; i <= N; i++) {
int p = idIni[i];
update(1, 1, tourID, p, nodes[i]);
}
for (int i = 1; i <= Q; i++) {
int t = queries[i].first;
int n = queries[i].second;
if (t == 1) {
auto res = query(1, 1, tourID, idIni[n], idFin[n]);
cout << res.first << "\n";
update(1, 1, tourID, res.second, 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 100;
int n, m, q;
struct Qu {
int op, x;
} qu[N];
struct Edge {
int u, v, w;
bool operator<(const Edge& t) const { return w < t.w; }
} edge[N];
struct Max {
int val, pos;
Max() {}
Max(int val, int pos) : val(val), pos(pos) {}
static Max inf() { return Max(-0x3f3f3f3f, 0); }
bool operator<(const Max& t) const { return val < t.val; }
};
struct Node {
int l, r;
Max mmax;
} tree[N << 2];
int a[N], f[N], val[N], dp[N][25], L[N], R[N], id[N], tot;
vector<int> node[N];
void pushup(int k) {
tree[k].mmax = max(tree[k << 1].mmax, tree[k << 1 | 1].mmax);
}
void build(int k, int l, int r) {
tree[k].l = l;
tree[k].r = r;
if (l == r) {
tree[k].mmax.val = a[id[l]];
tree[k].mmax.pos = l;
return;
}
int mid = l + r >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
pushup(k);
}
void update(int k, int pos) {
if (tree[k].l == tree[k].r) {
tree[k].mmax.val = 0;
return;
}
int mid = tree[k].l + tree[k].r >> 1;
if (pos <= mid)
update(k << 1, pos);
else
update(k << 1 | 1, pos);
pushup(k);
}
Max query(int k, int l, int r) {
if (tree[k].l > r || tree[k].r < l) return Max::inf();
if (tree[k].l >= l && tree[k].r <= r) return tree[k].mmax;
return max(query(k << 1, l, r), query(k << 1 | 1, l, r));
}
void dfs(int u, int fa) {
dp[u][0] = fa;
for (int i = 1; i <= 20; i++) dp[u][i] = dp[dp[u][i - 1]][i - 1];
L[u] = ++tot;
id[tot] = u;
for (auto v : node[u]) dfs(v, u);
R[u] = tot;
}
int get_pos(int u, int up) {
for (int i = 20; i >= 0; i--)
if (dp[u][i] != 0 && val[dp[u][i]] <= up) u = dp[u][i];
return u;
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int Ex_Kruskal() {
for (int i = 1; i <= n << 1; i++) f[i] = i;
int index = n;
sort(edge + 1, edge + 1 + m);
for (int i = 1; i <= m; i++) {
int xx = find(edge[i].u), yy = find(edge[i].v);
if (xx != yy) {
f[xx] = f[yy] = ++index;
val[index] = edge[i].w;
node[index].push_back(xx);
node[index].push_back(yy);
}
}
int last = 1;
for (int i = 1; i <= n; i++) {
int xx = find(last), yy = find(i);
if (xx != yy) {
f[xx] = f[yy] = ++index;
val[index] = inf;
node[index].push_back(xx);
node[index].push_back(yy);
last = index;
}
}
return index;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &edge[i].u, &edge[i].v);
edge[i].w = 0;
}
int val = inf;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &qu[i].op, &qu[i].x);
if (qu[i].op == 2) edge[qu[i].x].w = --val;
}
int root = Ex_Kruskal();
dfs(root, 0);
build(1, 1, root);
val = inf - 1;
for (int i = 1; i <= q; i++) {
if (qu[i].op == 1) {
int x = get_pos(qu[i].x, val);
Max ans = query(1, L[x], R[x]);
printf("%d\n", ans.val);
update(1, ans.pos);
} else
val--;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
int u[MAXN], v[MAXN], per[MAXN];
int su[MAXN], sv[MAXN];
bool rmv[MAXN];
int p[MAXN];
int n, m, q;
int qi[MAXN], val[MAXN], sz[MAXN];
int find(int x) {
if (p[x] == x) return x;
return p[x] = find(p[x]);
}
void join(int x, int y) {
sz[find(y)] += sz[find(x)];
p[find(x)] = find(y);
}
bool out[MAXN];
set<int> S[MAXN];
int ss;
int where[MAXN];
vector<pair<int, int> > g[MAXN];
bool V[MAXN];
int vis;
void dfs(int cur, int prev, int to) {
V[cur] = true;
where[cur] = to;
S[to].insert(cur);
for (int i = 0; i < (int)g[cur].size(); i++) {
int next = g[cur][i].first;
if (next == prev) continue;
dfs(next, cur, to);
}
}
void dfs1(int cur, int prev, int from, int to) {
vis++;
S[from].erase(cur);
if (!out[cur])
S[to].insert(cur);
else
S[to].insert(0);
where[cur] = to;
for (int i = 0; i < (int)g[cur].size(); i++) {
if (rmv[g[cur][i].second]) continue;
int next = g[cur][i].first;
if (next == prev) continue;
dfs1(next, cur, from, to);
}
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &per[i]);
p[i] = i;
sz[i] = 1;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u[i], &v[i]);
u[i] = per[u[i]];
v[i] = per[v[i]];
}
for (int i = 0; i < q; i++) {
scanf("%d %d", &qi[i], &val[i]);
if (qi[i] == 2)
rmv[val[i]] = true;
else
val[i] = per[val[i]];
}
for (int i = 1; i <= m; i++) {
if (rmv[i]) continue;
if (find(u[i]) == find(v[i])) continue;
join(u[i], v[i]);
}
for (int i = q - 1; i >= 0; i--) {
if (qi[i] == 2) {
int x = u[val[i]], y = v[val[i]];
if (find(x) == find(y)) {
su[i] = sv[i] = -1;
continue;
}
su[i] = sz[find(x)];
sv[i] = sz[find(y)];
g[x].push_back(make_pair(y, val[i]));
g[y].push_back(make_pair(x, val[i]));
join(x, y);
}
}
for (int i = 1; i <= n; i++) {
p[i] = i;
sz[i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)g[i].size(); j++) {
int x = i, y = g[i][j].first;
join(x, y);
}
}
for (int i = 1; i <= m; i++) {
if (rmv[i]) continue;
int x = u[i], y = v[i];
if (find(x) == find(y)) continue;
g[x].push_back(make_pair(y, i));
g[y].push_back(make_pair(x, i));
join(x, y);
}
ss = 0;
memset(V, false, sizeof V);
for (int i = 1; i <= n; i++) {
if (!V[i]) dfs(i, i, ss++);
}
for (int i = 1; i <= m; i++) rmv[i] = false;
for (int i = 0; i < q; i++) {
if (qi[i] == 1) {
int cur = val[i];
int w = where[cur];
int ans = *S[w].rbegin();
printf("%d\n", ans);
if (ans) {
out[ans] = true;
S[w].erase(ans);
S[w].insert(0);
}
} else {
rmv[val[i]] = true;
if (su[i] == -1) continue;
int ei = val[i];
if (su[i] < sv[i]) {
vis = 0;
dfs1(u[ei], u[ei], where[u[ei]], ss++);
if (vis != su[i]) {
printf("%d %d\n", vis, su[i]);
return 0;
}
} else {
vis = 0;
dfs1(v[ei], v[ei], where[v[ei]], ss++);
if (vis != sv[i]) {
printf("%d %d\n", vis, sv[i]);
return 0;
}
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, M = 2e4 + 5, inf = 0x3f3f3f3f, mod = 1e9 + 7;
int n, m, q, cnt;
int a[N], f[N], in[N], out[N], pos[N], del[N];
pair<int, int> edge[N], Q[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
vector<int> g[N];
struct node {
int l, r, mx;
} tr[N << 2];
void Merge(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
n++;
f[n] = n, f[x] = f[y] = n;
g[n].push_back(x), g[n].push_back(y);
}
void dfs(int u) {
in[u] = ++cnt;
for (int v : g[u])
if (!in[v]) dfs(v);
out[u] = cnt;
}
void re(int x) { tr[x].mx = max(tr[x << 1].mx, tr[x << 1 | 1].mx); }
void build(int x, int l, int r) {
tr[x].l = l, tr[x].r = r, tr[x].mx = 0;
if (l == r) {
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
}
void upd(int x, int p, int val) {
if (tr[x].l == tr[x].r) {
tr[x].mx = val;
return;
}
int mid = (tr[x].l + tr[x].r) >> 1;
if (p <= mid)
upd(x << 1, p, val);
else
upd(x << 1 | 1, p, val);
re(x);
}
int que(int x, int l, int r) {
if (tr[x].l >= l && tr[x].r <= r) return tr[x].mx;
int ans = 0, mid = (tr[x].l + tr[x].r) >> 1;
if (l <= mid) ans = max(ans, que(x << 1, l, r));
if (r > mid) ans = max(ans, que(x << 1 | 1, l, r));
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), pos[a[i]] = i, f[i] = i;
}
for (int i = 1; i <= m; i++) scanf("%d%d", &edge[i].first, &edge[i].second);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &Q[i].first, &Q[i].second);
if (Q[i].first == 2) del[Q[i].second] = 1;
}
for (int i = 1; i <= m; i++)
if (!del[i]) Merge(edge[i].first, edge[i].second);
for (int i = q; i; i--) {
if (Q[i].first == 1)
Q[i].second = find(Q[i].second);
else
Merge(edge[Q[i].second].first, edge[Q[i].second].second);
}
for (int i = 1; i <= n; i++)
if (f[i] == i) dfs(i);
build(1, 1, n);
for (int i = 1; i <= n; i++) upd(1, in[i], a[i]);
for (int i = 1; i <= q; i++) {
if (Q[i].first == 1) {
int ans = que(1, in[Q[i].second], out[Q[i].second]);
printf("%d\n", ans);
if (ans) upd(1, in[pos[ans]], 0);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int l, int r) { return l + rng() % (r - l + 1); }
using ii = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
const int N = 5e5 + 5;
int n, m, q, a[N], p[N], era[N], r[N];
vector<int> cmp[N];
ii ed[N], qu[N];
multiset<int> val[N];
void add(int i) {
int u = p[ed[i].first], v = p[ed[i].second];
if (u == v) return;
if (cmp[u].size() < cmp[v].size()) swap(u, v);
r[i] = v;
for (auto &w : cmp[v]) {
p[w] = u;
cmp[u].emplace_back(w);
}
}
void roll(int i) {
if (!r[i]) return;
int u = p[ed[i].first], v = r[i];
for (auto &w : cmp[v]) {
p[w] = v;
if (val[u].count(a[w])) {
val[u].erase(a[w]);
val[v].insert(a[w]);
}
cmp[u].pop_back();
}
}
void query(int u) {
u = p[u];
if (!val[u].size()) {
cout << 0 << '\n';
return;
}
int res = *val[u].rbegin();
val[u].erase(val[u].find(res));
cout << res << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> q;
for (int i = 1, _c = n; i <= _c; ++i) cin >> a[i];
for (int i = 1, _c = n; i <= _c; ++i) p[i] = i;
for (int i = 1, _c = n; i <= _c; ++i) cmp[i].emplace_back(i);
for (int i = 1, _c = m; i <= _c; ++i) cin >> ed[i].first >> ed[i].second;
for (int i = 1, _c = q; i <= _c; ++i) {
cin >> qu[i].second >> qu[i].first;
if (qu[i].second == 2) {
era[qu[i].first] = 1;
}
}
for (int i = 1, _c = m; i <= _c; ++i)
if (!era[i]) add(i);
for (int i = q, _c = 1; i >= _c; --i)
if (qu[i].second == 2) {
add(qu[i].first);
}
for (int i = 1, _c = n; i <= _c; ++i) val[p[i]].insert(a[i]);
for (int i = 1, _c = q; i <= _c; ++i)
if (qu[i].second == 1)
query(qu[i].first);
else
roll(qu[i].first);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
namespace IO {
bool REOF = 1;
inline char nc() {
static char buf[1 << 20], *p1 = buf, *p2 = buf;
return p1 == p2 && REOF &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 20, stdin), p1 == p2)
? (REOF = 0, EOF)
: *p1++;
}
template <typename T>
inline bool read(T &x) {
char c = nc();
bool f = 0;
x = 0;
while (c < '0' || c > '9') c == '-' && (f = 1), c = nc();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + (c ^ 48), c = nc();
if (f) x = -x;
return REOF;
}
template <typename T>
inline void write(T x) {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
template <typename T, typename... T2>
inline bool read(T &x, T2 &...rest) {
read(x);
return read(rest...);
}
inline bool isdowncase(char c) { return (c >= 'a') && (c <= 'z'); }
inline bool isupcase(char c) { return (c >= 'A') && (c <= 'Z'); }
inline bool isdigit(char c) { return (c >= '0') && (c <= '9'); }
inline bool need(char &c) { return isdowncase(c) || isupcase(c) || isdigit(c); }
inline bool read_str(char *a) {
while ((*a = nc()) && need(*a) && REOF) ++a;
*a = '\0';
return REOF;
}
inline bool read_db(double &x) {
bool f = 0;
char ch = nc();
x = 0;
while (ch < '0' || ch > '9') {
f |= (ch == '-');
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10.0 + (ch ^ 48);
ch = nc();
}
if (ch == '.') {
double temp = 1;
ch = nc();
while (ch >= '0' && ch <= '9') {
temp = temp / 10.0;
x = x + temp * (ch ^ 48);
ch = nc();
}
}
if (f) x = -x;
return REOF;
}
template <typename TH>
inline void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <typename TH, typename... TA>
inline void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',' << ' ';
_dbg(sdbg + 1, a...);
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto vv : V) os << vv << ",";
return os << " ]";
}
template <typename T>
ostream &operator<<(ostream &os, set<T> V) {
os << "[ ";
for (auto vv : V) os << vv << ",";
return os << " ]";
}
template <typename T>
ostream &operator<<(ostream &os, multiset<T> V) {
os << "[ ";
for (auto vv : V) os << vv << ",";
return os << " ]";
}
template <typename T>
ostream &operator<<(ostream &os, map<T, T> V) {
os << "[ ";
for (auto vv : V) os << vv << ",";
return os << " ]";
}
template <typename L, typename R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <typename TH>
TH MIN(TH a, TH b) {
return min(a, b);
}
template <typename TH, typename... TA>
TH MIN(TH a, TA... c) {
return min(a, MIN(c...));
}
template <typename TH>
TH MAX(TH a, TH b) {
return max(a, b);
}
template <typename TH, typename... TA>
TH MAX(TH a, TA... c) {
return max(a, MIN(c...));
}
template <typename T>
void updMin(T &a, T b) {
if (a > b) a = b;
}
template <typename T>
void updMax(T &a, T b) {
if (a < b) a = b;
}
} // namespace IO
using namespace IO;
const int N = 5e5 + 5;
const int M = 5e5 + 5;
const int V = 5e7 + 5;
const long long MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-8;
vector<int> G[N];
int n, m, q, p[N], is[N];
pair<int, int> query[N], e[N];
int fa[N];
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
++n;
fa[n] = n;
fa[x] = n;
fa[y] = n;
G[n].push_back(x);
G[n].push_back(y);
}
pair<int, int> ma[N << 2];
pair<int, int> queryMax(int x, int l, int r, int L, int R) {
if (L > R || l > R || r < L) return pair<int, int>(0, 0);
if (l == L && r == R) return ma[x];
int mid = (l + r) >> 1;
if (R <= mid)
return queryMax(x << 1, l, mid, L, R);
else if (L > mid)
return queryMax(x << 1 | 1, mid + 1, r, L, R);
return max(queryMax(x << 1, l, mid, L, mid),
queryMax(x << 1 | 1, mid + 1, r, mid + 1, R));
}
void updatePosition(int x, int l, int r, int pos, pair<int, int> val) {
if (l == r) {
ma[x] = val;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
updatePosition(x << 1, l, mid, pos, val);
else
updatePosition(x << 1 | 1, mid + 1, r, pos, val);
ma[x] = max(ma[x << 1], ma[x << 1 | 1]);
}
int dfs_clock, st[N], ed[N];
void dfs(int u) {
st[u] = ++dfs_clock;
for (int v : G[u]) {
dfs(v);
}
ed[u] = dfs_clock;
}
void solve(int Case) {
read(n, m, q);
for (int i = (1); i <= (n); ++i) read(p[i]);
int u, v;
for (int i = (1); i <= (m); ++i) {
read(u, v);
e[i] = pair<int, int>(u, v);
}
int op;
for (int i = (1); i <= (q); ++i) {
read(op, v);
query[i] = pair<int, int>(op, v);
if (op == 2) is[v] = 1;
}
for (int i = (1); i <= (n); ++i) fa[i] = i;
for (int i = (1); i <= (m); ++i)
if (!is[i]) {
merge(e[i].first, e[i].second);
}
for (int i = (q); i >= (1); --i) {
if (query[i].first == 1) {
query[i].second = find(query[i].second);
} else {
int eid = query[i].second;
merge(e[eid].first, e[eid].second);
}
}
for (int i = (1); i <= (n); ++i)
if (find(i) == i) {
dfs(i);
}
for (int i = (1); i <= (n); ++i) {
updatePosition(1, 1, n, st[i], pair<int, int>(p[i], st[i]));
}
for (int i = (1); i <= (q); ++i)
if (query[i].first == 1) {
int id = query[i].second;
pair<int, int> ans = queryMax(1, 1, n, st[id], ed[id]);
printf("%d\n", ans.first);
if (ans.first != 0)
updatePosition(1, 1, n, ans.second, pair<int, int>(0, 0));
}
}
int main() {
int T = 1;
for (int _ = 1; _ <= T; _++) solve(_);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.