├── README.md
└── dsa.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # CP Algorithms
2 | Lucid C++ codes for standard DSA
3 | 


--------------------------------------------------------------------------------
/dsa.cpp:
--------------------------------------------------------------------------------
   1 | /* = = = = = = = = =
   2 | AUTHOR: SINGLABHARAT
   3 | = = = = = = = = = */
   4 | 
   5 | /* = =
   6 | Arrays
   7 | = = */
   8 | 
   9 | vector<int> pref_sums(vector<int> &a) {
  10 |     int n = size(a);
  11 |     vector<int> ps = a;
  12 |     for (int i = 1; i < n; i++) ps[i] += ps[i - 1];
  13 |     return ps;
  14 | }
  15 | 
  16 | vector<vector<int>> pref_sums_2D(vector<vector<int>> &a) {
  17 |     int n = size(a), m = size(a[0]);
  18 |     vector<vector<int>> ps(n + 1, vector<int>(m + 1));
  19 |     for (int i = 1; i <= n; i++) {
  20 |         for (int j = 1; j <= m; j++) {
  21 |             ps[i][j] = a[i - 1][j - 1] + ps[i][j - 1] + ps[i - 1][j] - ps[i - 1][j - 1];
  22 |         }
  23 |     }
  24 |     return ps;
  25 | }
  26 | 
  27 | auto sum = [&](int r1, int c1, int r2, int c2) {
  28 |     r1++, c1++, r2++, c2++;
  29 |     return ps[r2][c2] - ps[r2][c1 - 1] - ps[r1 - 1][c2] + ps[r1 - 1][c1 - 1];
  30 | };
  31 | 
  32 | vector<int> suff_sums(vector<int> &a) {
  33 |     int n = size(a);
  34 |     vector<int> ss = a;
  35 |     for (int i = n - 2; i >= 0; i--) ss[i] += ss[i + 1];
  36 |     return s;
  37 | }
  38 | 
  39 | int max_subarr_sum(vector<int> &a) {
  40 |     int res = -1e9, curr = 0;
  41 |     for (int i : a) {
  42 |         curr = max(curr + i, i);
  43 |         res = max(res, curr);
  44 |     }
  45 |     return res;
  46 | }
  47 | 
  48 | int sliding_window(vector<int> &a, int k) {
  49 |     int n = size(a);
  50 |     int curr = accumulate(begin(a), begin(a) + k, 0ll);
  51 |     int res = curr;
  52 |     for (int l = 1, r = k; r < n; l++, r++) {
  53 |         curr = curr - a[l - 1] + a[r];
  54 |         res = max(res, curr);
  55 |     }
  56 |     return res;
  57 | }
  58 | 
  59 | vector<vector<int>> matrix_mul(vector<vector<int>> &a1, vector<vector<int>> &a2) {
  60 |     int n1 = size(a1), m1 = size(a1[0]), m2 = size(a2[0]);
  61 |     vector<vector<int>> res(n1, vector<int>(m2));
  62 |     for (int i = 0; i < n1; i++) {
  63 |         for (int j = 0; j < m2; j++) {
  64 |             for (int k = 0; k < m1; k++) res[i][j] += a1[i][k] * a2[k][j];
  65 |         }
  66 |     }
  67 |     return res;
  68 | }
  69 | 
  70 | /* = = =
  71 | Sorting
  72 | = = = */
  73 | 
  74 | void bubble_sort(vector<int> &a) {
  75 |     int n = size(a);
  76 |     for (int i = 0; i < n - 1; i++) {
  77 |         for (int j = 0; j < n - i - 1; j++) {
  78 |             if (a[j] > a[j + 1]) swap(a[j], a[j + 1]);
  79 |         }
  80 |     }
  81 | }
  82 | 
  83 | void insertion_sort(vector<int> &a) {
  84 |     int n = size(a);
  85 |     for (int j = 1; j < n; j++) {
  86 |         for (int i = j - 1; i >= 0 and a[i] > a[i + 1]; i--) {
  87 |             swap(a[i], a[i + 1]);
  88 |         }
  89 |     }
  90 | }
  91 | 
  92 | void selection_sort(vector<int> &a) {
  93 |     int n = size(a);
  94 |     for (int i = 0; i < n - 1; i++) {
  95 |         int mni = i;
  96 |         for (int j = i + 1; j < n; j++) {
  97 |             if (a[j] < a[mni]) mni = j;
  98 |         }
  99 |         swap(a[i], a[mni]);
 100 |     }
 101 | }
 102 | 
 103 | void merge(vector<int> &a, int l, int r) {
 104 |     int n = r - l + 1;
 105 |     int m = (l + r) / 2;
 106 |     vector<int> temp(n);
 107 |     int i = l, j = m + 1, k = 0;
 108 |     while (i <= m and j <= r) {
 109 |         if (a[i] < a[j]) temp[k++] = a[i++];
 110 |         else temp[k++] = a[j++];
 111 |     }
 112 |     while (i <= m) temp[k++] = a[i++];
 113 |     while (j <= r) temp[k++] = a[j++];
 114 |     for (int i = 0; i < n; i++) a[l + i] = temp[i];
 115 | }
 116 | 
 117 | void merge_sort(vector<int> &a, int l, int r) {
 118 |     if (l >= r) return;
 119 |     int m = (l + r) / 2;
 120 |     merge_sort(a, l, m);
 121 |     merge_sort(a, m + 1, r);
 122 |     merge(a, l, r);
 123 | }
 124 | 
 125 | int partition(vector<int> &a, int l, int r) {
 126 |     int pivot = a[r];
 127 |     int pi = l;
 128 |     for (int i = l; i < r; i++) {
 129 |         if (a[i] <= pivot) swap(a[i], a[pi++]);
 130 |     }
 131 |     swap(a[pi], a[r]);
 132 |     return pi;
 133 | }
 134 | 
 135 | void quick_sort(vector<int> &a, int l, int r) {
 136 |     if (l >= r) return;
 137 |     int pi = partition(a, l, r);
 138 |     quick_sort(a, l, pi - 1);
 139 |     quick_sort(a, pi + 1, r);
 140 | }
 141 | 
 142 | vector<int> counting_sort(vector<int> &a) {
 143 |     int mx = *max_element(begin(a), end(a));
 144 |     vector<int> freq(mx + 1);
 145 |     for (int i : a) freq[i]++;
 146 |     vector<int> res;
 147 |     for (int i = 0; i <= mx; i++) {
 148 |         while (freq[i]--) res.push_back(i);
 149 |     }
 150 |     a = res;
 151 | }
 152 | 
 153 | /* = = = =
 154 | Searching
 155 | = = = = */
 156 | 
 157 | int binary_search(int x, vector<int> &a) {
 158 |     l = 0, r = (int)size(a) - 1;
 159 |     while (l <= r) {
 160 |         int m = (l + r) / 2;
 161 |         if (a[m] == x) return m;
 162 |         if (a[m] > x) r = m - 1;
 163 |         else l = m + 1;
 164 |     }
 165 |     return -1;
 166 | }
 167 | 
 168 | auto ok = [&](int m) -> bool {};
 169 | 
 170 | auto binary_search = [&]() -> int {
 171 |     int res = -1, l = 0, r = 1e9;
 172 |     while (l <= r) {
 173 |         int m = (l + r) / 2;
 174 |         if (ok(m)) {
 175 |             res = m;
 176 |             r = m - 1;
 177 |         } else {
 178 |             l = m + 1;
 179 |         }
 180 |     }
 181 |     return res;
 182 | };
 183 | 
 184 | const double EPS = 1e-9;
 185 | 
 186 | auto f = [&](double x) -> double {};
 187 | 
 188 | auto ternary_search = [&]() -> double {
 189 |     double l = 0, r = 1e9;
 190 |     while (r - l > EPS) {
 191 |         double m1 = l + (r - l) / 3;
 192 |         double m2 = r - (r - l) / 3;
 193 |         if (f(m1) < f(m2)) l = m1;
 194 |         else r = m2;
 195 |     }
 196 |     return f(l);
 197 | };
 198 | 
 199 | /* = = = = = =
 200 | Number Theory
 201 | = = = = = = */
 202 | 
 203 | bool prime(int n) {
 204 |     if (n < 2) return 0;
 205 |     for (int i = 2; i * i <= n; i++) {
 206 |         if (n % i == 0) return 0;
 207 |     }
 208 |     return 1;
 209 | }
 210 | 
 211 | set<int> factors(int n) {
 212 |     set<int> f;
 213 |     for (int i = 1; i * i <= n; i++) {
 214 |         if (n % i == 0) f.insert(i), f.insert(n / i);
 215 |     }
 216 |     return f;
 217 | }
 218 | 
 219 | vector<pair<int, int>> prime_factors(int n) {
 220 |     vector<pair<int, int>> pf;
 221 |     for (int i = 2; i * i <= n; i++) {
 222 |         if (n % i == 0) {
 223 |             int p = 0;
 224 |             while (n % i == 0) {
 225 |                 n /= i;
 226 |                 p++;
 227 |             }
 228 |             pf.push_back({i, p});
 229 |         }
 230 |     }
 231 |     if (n > 1) pf.push_back({n, 1});
 232 |     return pf;
 233 | }
 234 | 
 235 | vector<bool> sieve_of_eratosthenes(int n) {
 236 |     vector<bool> prime(n, 1);
 237 |     prime[0] = prime[1] = 0;
 238 |     for (int i = 2; i * i < n; i++) {
 239 |         if (prime[i]) {
 240 |             for (int j = i * i; j < n; j += i) prime[j] = 0;
 241 |         }
 242 |     }
 243 |     return prime;
 244 | }
 245 | 
 246 | vector<int> spf_sieve(int n) {
 247 |     vector<int> spf(N, -1);
 248 |     for (int i = 2; i < N; i++) {
 249 |         if (spf[i] == -1) {
 250 |             for (int j = i; j < N; j += i) {
 251 |                 if (spf[j] == -1) spf[j] = i;
 252 |             }
 253 |         }
 254 |     }
 255 |     return spf;
 256 | }
 257 | 
 258 | struct Mint {
 259 |     int val;
 260 | 
 261 |     Mint(int v = 0) {
 262 |         val = v % MOD;
 263 |         if (val < 0) val += MOD;
 264 |     }
 265 | 
 266 |     explicit operator int() {
 267 |         return val;
 268 |     }
 269 | 
 270 |     Mint& operator+=(const Mint &other) {
 271 |         val += other.val;
 272 |         if (val >= MOD) val -= MOD;
 273 |         return *this;
 274 |     }
 275 | 
 276 |     Mint& operator-=(const Mint &other) {
 277 |         val -= other.val;
 278 |         if (val < 0) val += MOD;
 279 |         return *this;
 280 |     }
 281 | 
 282 |     Mint& operator*=(const Mint &other) {
 283 |         val = (val * other.val) % MOD;
 284 |         return *this;
 285 |     }
 286 | 
 287 |     friend Mint power(Mint a, int b) {
 288 |         Mint res = 1;
 289 |         while (b) {
 290 |             if (b & 1) res *= a;
 291 |             a *= a;
 292 |             b >>= 1;
 293 |         }
 294 |         return res;
 295 |     }
 296 | 
 297 |     friend Mint inverse(Mint a) {
 298 |         return power(a, MOD - 2);
 299 |     }
 300 | 
 301 |     Mint &operator/=(const Mint &other) {
 302 |         return *this *= inverse(other);
 303 |     }
 304 | 
 305 |     friend Mint operator+(Mint a, const Mint other) {
 306 |         return a += other;
 307 |     }
 308 | 
 309 |     friend Mint operator-(Mint a, const Mint other) {
 310 |         return a -= other;
 311 |     }
 312 | 
 313 |     friend Mint operator-(const Mint a) {
 314 |         return 0 - a;
 315 |     }
 316 | 
 317 |     friend Mint operator*(Mint a, const Mint other) {
 318 |         return a *= other;
 319 |     }
 320 | 
 321 |     friend Mint operator/(Mint a, const Mint other) {
 322 |         return a /= other;
 323 |     }
 324 | 
 325 |     friend std::ostream &operator<<(std::ostream &os, Mint const& a) {
 326 |         return os << a.val;
 327 |     }
 328 | 
 329 |     friend std::istream &operator>>(std::istream &is, Mint &a) {
 330 |         is >> a.val;
 331 |         a.val %= MOD;
 332 |         if (a.val < 0) a.val += MOD;
 333 |         return is;
 334 |     }
 335 | 
 336 |     friend bool operator==(const Mint &a, const Mint &other) {
 337 |         return a.val == other.val;
 338 |     }
 339 | 
 340 |     friend bool operator!=(const Mint &a, const Mint &other) {
 341 |         return a.val != other.val;
 342 |     }
 343 | };
 344 | 
 345 | vector<Mint> fact;
 346 | 
 347 | Mint C(int n, int r) {
 348 |     if (r < 0 or r > n) return 0;
 349 |     return fact[n] / fact[r] / fact[n - r];
 350 | }
 351 | 
 352 | fact.resize(1e5);
 353 | fact[0] = 1;
 354 | for (int i = 1; i < MX; i++) fact[i] = fact[i - 1] * i;
 355 | 
 356 | int gcd(int a, int b) {
 357 |     return (b == 0 ? a : gcd(b, a % b));
 358 | }
 359 | 
 360 | pair<int, int> extended_gcd(int a, int b) {
 361 |     if (b == 0) return {1, 0};
 362 |     auto [x2, y2] = extended_gcd(b, a % b);
 363 |     return {y2, x2 - a / b * y2};
 364 | }
 365 | 
 366 | 
 367 | /* = = =
 368 | Strings
 369 | = = = */
 370 | 
 371 | Mint my_hash(string s) {
 372 |     int n = size(s);
 373 |     Mint h = 0;
 374 |     for (int i = 0; i < n; i++) h = h * 31 + (s[i] - 'a' + 1);
 375 |     return h;
 376 | }
 377 | 
 378 | vector<int> rabin_karp(string &s, string &t) {
 379 |     int n = size(s), m = size(t);
 380 |     Mint p = power(Mint(31), m - 1);
 381 |     Mint ht = my_hash(t);
 382 |     Mint hs = my_hash(s.substr(0, m));
 383 |     vector<int> pos;
 384 |     if (hs == ht) pos.push_back(0);
 385 |     for (int l = 1, r = m; r < n; l++, r++) {
 386 |         hs = (hs - (s[l - 1] - 'a' + 1) * p) * 31 + (s[r] - 'a' + 1);
 387 |         if (hs == ht) pos.push_back(l);
 388 |     }
 389 |     return pos;
 390 | }
 391 | 
 392 | vector<int> pref_func(string &s) {
 393 |     int n = size(s);
 394 |     vector<int> lps(n);
 395 |     for (int i = 1; i < n; i++) {
 396 |         int j = lps[i - 1];
 397 |         while (j > 0 and s[j] != s[i]) j = lps[j - 1];
 398 |         lps[i] = j + (s[j] == s[i]);
 399 |     }
 400 |     return lps;
 401 | }
 402 | 
 403 | vector<int> kmp(string &s, string &t) {
 404 |     int n = size(s), m = size(t);
 405 |     string temp = t + "#" + s;
 406 |     vector<int> lps = pref_func(temp);
 407 |     vector<int> pos;
 408 |     for (int i = m + 1; i < n + m + 1; i++) {
 409 |         if (lps[i] == m) pos.push_back(i - 2 * m);
 410 |     }
 411 |     return pos;
 412 | }
 413 | 
 414 | /* = = = = = = = = = = =
 415 | Dynamic Programming (DP)
 416 | = = = = = = = = = = = */
 417 | 
 418 | int knapsack(vector<pair<int, int>> &items, int cap) {
 419 |     vector<int> dp(cap + 1);
 420 |     for (auto [w, c] : items) {
 421 |         for (int i = cap; i >= w; i--) dp[i] = max(dp[i], c + dp[i - w]);
 422 |     }
 423 |     return dp[cap];
 424 | }
 425 | 
 426 | int longest_common_subseq(vector<int> &a, vector<int> &b) {
 427 |     int n = size(a), m = size(b);
 428 |     vector<vector<int>> dp(n + 1, vector<int>(m + 1));
 429 |     for (int i = 1; i <= n; i++) {
 430 |         for (int j = 1; j <= m; j++) {
 431 |             if (a[i - 1] == b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
 432 |             else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
 433 |         }
 434 |     }
 435 |     return dp[n][m];
 436 | }
 437 | 
 438 | int longest_common_subarr(vector<int> &a, vector<int> &b) {
 439 |     int n = size(a), m = size(b);
 440 |     vector<vector<int>> dp(n + 1, vector<int>(m + 1));
 441 |     int res = 0;
 442 |     for (int i = 1; i <= n; i++) {
 443 |         for (int j = 1; j <= m; j++) {
 444 |             if (a[i - 1] == b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
 445 |             res = max(res, dp[i][j]);
 446 |         }
 447 |     }
 448 |     return res;
 449 | }
 450 | 
 451 | int longest_inc_subseq(vector<int> &a) {
 452 |     vector<int> lis;
 453 |     for (int i : a) {
 454 |         auto it = lower_bound(begin(lis), end(lis), i);
 455 |         if (it == end(lis)) lis.push_back(i);
 456 |         else *it = i;
 457 |     }
 458 |     return size(lis);
 459 | }
 460 | 
 461 | int edit_distance(string &s, string &t) {
 462 |     int n = size(s), m = size(t);
 463 |     vector<vector<int>> dp(n + 1, vector<int>(m + 1));
 464 |     for (int i = 0; i <= n; i++) dp[i][0] = i;
 465 |     for (int j = 0; j <= m; j++) dp[0][j] = j;
 466 |     for (int i = 1; i <= n; i++) {
 467 |         for (int j = 1; j <= m; j++) {
 468 |             if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1];
 469 |             else dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
 470 |         }
 471 |     }
 472 |     return dp[n][m];
 473 | }
 474 | 
 475 | vector<int> digts(int n) {
 476 |     vector<int> d;
 477 |     while (n > 0) {
 478 |         d.push_back(n % 10);
 479 |         n /= 10;
 480 |     }
 481 |     reverse(begin(d), end(d));
 482 |     return d;
 483 | }
 484 | 
 485 | int dp[19][163][2];
 486 | 
 487 | int rec(int pos, int sod, bool tight, vector<int> &num) {
 488 |     if (pos == size(num)) return sod == ?;
 489 |     int &res = dp[pos][sod][tight];
 490 |     if (res != -1) return res;
 491 |     res = 0;
 492 |     int lim = (tight ? num[pos] : 9);
 493 |     for (int d = 0; d <= lim; d++) {
 494 |         int new_sod = sod + d;
 495 |         bool new_tight = tight and d == lim;
 496 |         res += rec(pos + 1, new_sod, new_tight, num);
 497 |     }
 498 |     return res;
 499 | }
 500 | 
 501 | int digit_dp(int l, int r) {
 502 |     memset(dp, -1, sizeof(dp));
 503 |     vector<int> dl = digts(l - 1);
 504 |     int ansl = (l == 0 ? 0 : rec(0, 0, true, dl));
 505 |     memset(dp, -1, sizeof(dp));
 506 |     vector<int> dr = digts(r);
 507 |     int ansr = rec(0, 0, true, dr);
 508 |     return ansr - ansl;
 509 | }
 510 | 
 511 | 
 512 | /* = =
 513 | Graphs
 514 | = = */
 515 | 
 516 | int n, m;
 517 | cin >> n >> m;
 518 | vector<vector<int>> g(n);
 519 | for (int i = 0; i < m; i++) {
 520 |     int u, v;
 521 |     cin >> u >> v;
 522 |     u--, v--;
 523 |     g[u].push_back(v);
 524 |     g[v].push_back(u);
 525 | }
 526 | 
 527 | int n, m;
 528 | cin >> n >> m;
 529 | vector<vector<pair<int, int>>> g(n);
 530 | for (int i = 0; i < m; i++) {
 531 |     int u, v, w;
 532 |     cin >> u >> v >> w;
 533 |     u--, v--;
 534 |     g[u].push_back(pair(v, w));
 535 |     g[v].push_back(pair(u, w));
 536 | }
 537 | 
 538 | vector<bool> vis(n);
 539 | function<void(int)> dfs = [&](int u) {
 540 |     vis[u] = true;
 541 |     for (int v : g[u]) {
 542 |         if (!vis[v]) {
 543 |             dfs(v);
 544 |         }
 545 |     }
 546 | };
 547 | 
 548 | function<void(int, int)> dfs = [&](int u, int p) {
 549 |     for (int v : tree[u]) {
 550 |         if (v != p) {
 551 |             dfs(v, u);
 552 |         }
 553 |     }
 554 | };
 555 | 
 556 | const vector<pair<int, int>> DIRS = {{ -1, 0}, {0, 1}, {1, 0}, {0, -1}};
 557 | vector<vector<bool>> vis(n, vector<bool>(m));
 558 | 
 559 | auto valid = [&](int i, int j) -> bool {
 560 |     return 0 <= i and i < n and 0 <= j and j < m and !vis[i][j];
 561 | };
 562 | 
 563 | function<void(int, int)> dfs = [&](int i, int j) {
 564 |     vis[i][j] = true;
 565 |     for (auto [di, dj] : DIRS) {
 566 |         int new_i = i + di, new_j = j + dj;
 567 |         if (valid(new_i, new_j)) {
 568 |             dfs(new_i, new_j);
 569 |         }
 570 |     }
 571 | };
 572 | 
 573 | auto bfs = [&](int src) -> vector<int> {
 574 |     vector<int> dist(n, INF);
 575 |     queue<int> q;
 576 |     q.push(src);
 577 |     dist[src] = 0;
 578 |     while (!empty(q)) {
 579 |         int u = q.front();
 580 |         q.pop();
 581 |         for (int v : g[u]) {
 582 |             if (dist[v] == INF) {
 583 |                 dist[v] = dist[u] + 1;
 584 |                 q.push(v);
 585 |             }
 586 |         }
 587 |     }
 588 |     return dist;
 589 | };
 590 | 
 591 | auto dijkstra = [&](int src) -> vector<int> {
 592 |     priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
 593 |     vector<int> dist(n, INF);
 594 |     pq.push({0, src});
 595 |     dist[src] = 0;
 596 |     while (!empty(pq)) {
 597 |         auto [d, u] = pq.top();
 598 |         pq.pop();
 599 |         if (dist[u] != d) continue;
 600 |         for (auto [v, w] : g[u]) {
 601 |             if (dist[u] + w < dist[v]) {
 602 |                 dist[v] = dist[u] + w;
 603 |                 pq.push({dist[v], v});
 604 |             }
 605 |         }
 606 |     }
 607 |     return dist;
 608 | };
 609 | 
 610 | auto bellman_ford = [&](int src) -> vector<int> {
 611 |     vector<int> dist(n, 1e9);
 612 |     dist[src] = 0;
 613 |     for (int _ = 0; _ < n - 1; _++) {
 614 |         for (auto e : edges) {
 615 |             int u = e[0], v = e[1], w = e[2];
 616 |             if (dist[u] + w < dist[v]) dist[v] = dist[u] + w;
 617 |         }
 618 |     }
 619 |     return dist;
 620 | };
 621 | 
 622 | auto floyd_warshall = [&]() -> vector<vector<int>> {
 623 |     vector<vector<int>> dist = g;
 624 |     for (int k = 0; k < n; k++) {
 625 |         for (int u = 0; u < n; u++) {
 626 |             for (int v = 0; v < n; v++) {
 627 |                 dist[u][v] = min(dist[u][v], dist[u][k] + dist[k][v]);
 628 |             }
 629 |         }
 630 |     }
 631 |     return dist;
 632 | };
 633 | 
 634 | auto topo_sort = [&]() -> vector<int> {
 635 |     vector<int> indeg(n);
 636 |     for (int u = 0; u < n; u++) {
 637 |         for (int v : g[u]) indeg[v]++;
 638 |     }
 639 |     vector<int> topo;
 640 |     queue<int> q;
 641 |     for (int i = 0; i < n; i++) if (indeg[i] == 0) q.push(i);
 642 |     while (!empty(q)) {
 643 |         int u = q.front();
 644 |         q.pop();
 645 |         topo.push_back(u);
 646 |         for (int v : g[u]) {
 647 |             indeg[v]--;
 648 |             if (indeg[v] == 0) q.push(v);
 649 |         }
 650 |     }
 651 |     return topo;
 652 | };
 653 | 
 654 | auto scc = [&]() -> vector<vector<int>> {
 655 |     vector<int> topo;
 656 |     vector<bool> vis(n);
 657 | 
 658 |     function<void(int)> dfs = [&](int u) {
 659 |         vis[u] = true;
 660 |         for (int v : g[u]) {
 661 |             if (!vis[v]) dfs(v);
 662 |         }
 663 |         topo.push_back(u);
 664 |     };
 665 | 
 666 |     for (int u = 0; u < n; u++) {
 667 |         if (!vis[u]) dfs(u);
 668 |     }
 669 | 
 670 |     reverse(begin(topo), end(topo));
 671 | 
 672 |     vector<vector<int>> revg(n);
 673 |     for (int u = 0; u < n; u++) {
 674 |         for (int v : g[u]) revg[v].push_back(u);
 675 |     }
 676 | 
 677 |     vector<int> who(n, -1);
 678 |     function<void(int, int)> revdfs = [&](int u, int p) {
 679 |         who[u] = p;
 680 |         for (int v : revg[u]) {
 681 |             if (who[v] == -1) revdfs(v, p);
 682 |         }
 683 |     };
 684 | 
 685 |     for (int u : topo) {
 686 |         if (who[u] == -1) dfsrev(u, u);
 687 |     }
 688 | 
 689 |     vector<vector<int>> compg(n);
 690 |     for (int u = 0; u < n; u++) {
 691 |         for (int v : g[u]) {
 692 |             if (who[u] != who[v]) compg[who[u]].push_back(who[v]);
 693 |         }
 694 |     }
 695 | 
 696 |     return compg;
 697 | };
 698 | 
 699 | vector<int> dep(n);
 700 | const int LOG = __lg(n) + 1;
 701 | vector<vector<int>> up(n, vector<int>(LOG));
 702 | 
 703 | function<void(int, int, int)> dfs = [&](int u, int p, int d) {
 704 |     dep[u] = d;
 705 |     up[u][0] = p;
 706 |     for (int j = 1; j < LOG; j++) up[u][j] = up[up[u][j - 1]][j - 1];
 707 |     for (int v : tree[u]) {
 708 |         if (v != p) dfs(v, u, d + 1);
 709 |     }
 710 | };
 711 | 
 712 | dfs(0, 0, 0);
 713 | 
 714 | auto anc = [&](int u, int k) -> int {
 715 |     if (k > dep[u]) return -1;
 716 |     for (int j = 0; j < LOG; j++) {
 717 |         if (k >> j & 1) u = up[u][j];
 718 |     }
 719 |     return u;
 720 | };
 721 | 
 722 | auto lca = [&](int u, int v) -> int {
 723 |     if (dep[u] < dep[v]) swap(u, v);
 724 |     u = anc(u, dep[u] - dep[v]);
 725 |     if (u == v) return u;
 726 |     for (int j = LOG - 1; j >= 0; j--) {
 727 |         if (up[u][j] != up[v][j]) u = up[u][j], v = up[v][j];
 728 |     }
 729 |     return up[u][0];
 730 | };
 731 | 
 732 | int time = -1;
 733 | vector<int> tin(n), tout(n), euler;
 734 | 
 735 | function<void(int, int)> dfs = [&](int u, int p) {
 736 |     tin[u] = ++time;
 737 |     euler.push_back(u);
 738 |     for (int v : g[u]) {
 739 |         if (v != p) {
 740 |             dfs(v, u);
 741 |             euler.push_back(u);
 742 |         }
 743 |     }
 744 |     tout[u] = ++time;
 745 | };
 746 | 
 747 | auto kruskals_mst = [&]() -> int {
 748 |     sort(begin(edges), end(edges), [](auto e1, auto e2) {return e1[2] < e2[2];});
 749 |     DSU dsu(n);
 750 |     int res = 0, cnt = 0;
 751 |     for (auto e : edges) {
 752 |         if (!dsu.same(e[0], e[1])) {
 753 |             dsu.unite(e[0], e[1]);
 754 |             cnt++;
 755 |             res += e[2];
 756 |         }
 757 |     }
 758 |     return (cnt == n - 1 ? res : -1);
 759 | };
 760 | 
 761 | auto prims_mst = [&]() -> int {
 762 |     vector<int> key(n, INF);
 763 |     key[0] = 0;
 764 |     vector<bool> vis(n);
 765 |     int res = 0;
 766 |     for (int _ = 0; _ < n; _++) {
 767 |         int u = -1;
 768 |         for (int i = 0; i < n; i++) {
 769 |             if (!vis[i] and (u == -1 or key[i] < key[u])) u = i;
 770 |         }
 771 |         if (key[u] == INF) return -1;
 772 |         vis[u] = true;
 773 |         res += key[u];
 774 |         for (int v = 0; v < n; v++) {
 775 |             if (adj[u][v] < key[v]) key[v] = adj[u][v];
 776 |         }
 777 |     }
 778 |     return res;
 779 | };
 780 | 
 781 | /* = = = = = = =
 782 | Data Structures
 783 | = = = = = = = */
 784 | 
 785 | struct SegTree {
 786 |     int n;
 787 |     vector<int> st;
 788 | 
 789 |     int merge(int x, int y) {}
 790 | 
 791 |     int lc(int u) {
 792 |         return u * 2 + 1;
 793 |     }
 794 | 
 795 |     int rc(int u) {
 796 |         return u * 2 + 2;
 797 |     }
 798 | 
 799 |     SegTree(vector<int> &a) : n(size(a)), st(n * 4) {
 800 |         build(0, 0, n - 1, a);
 801 |     }
 802 | 
 803 |     void build(int u, int l, int r, vector<int> &a) {
 804 |         if (l == r) {
 805 |             st[u] = a[l];
 806 |             return;
 807 |         }
 808 |         int m = (l + r) / 2;
 809 |         build(lc(u), l, m, a);
 810 |         build(rc(u), m + 1, r, a);
 811 |         st[u] = merge(st[lc(u)], st[rc(u)]);
 812 |     }
 813 | 
 814 |     void upd(int i, int x) {
 815 |         upd(0, 0, n - 1, i, x);
 816 |     }
 817 | 
 818 |     void upd(int u, int l, int r, int i, int x) {
 819 |         if (l == r) {
 820 |             st[u] = x;
 821 |             return;
 822 |         }
 823 |         int m = (l + r) / 2;
 824 |         if (i <= m) upd(lc(u), l, m, i, x);
 825 |         else upd(rc(u), m + 1, r, i, x);
 826 |         st[u] = merge(st[lc(u)], st[rc(u)]);
 827 |     }
 828 | 
 829 |     int query(int ql, int qr) {
 830 |         return query(0, 0, n - 1, ql, qr);
 831 |     }
 832 | 
 833 |     int query(int u, int l, int r, int ql, int qr) {
 834 |         if (qr < l or r < ql) return 0;
 835 |         if (ql <= l and r <= qr) return st[u];
 836 |         int m = (l + r) / 2;
 837 |         return merge(query(lc(u), l, m, ql, qr), query(rc(u), m + 1, r, ql, qr));
 838 |     }
 839 | };
 840 | 
 841 | struct LazySegTree {
 842 |     int n;
 843 |     vector<int> st, lazy;
 844 | 
 845 |     int merge(int x, int y) {}
 846 | 
 847 |     int lc(int u) {
 848 |         return u * 2 + 1;
 849 |     }
 850 | 
 851 |     int rc(int u) {
 852 |         return u * 2 + 2;
 853 |     }
 854 | 
 855 |     void push(int u, int l, int r) {}
 856 | 
 857 |     LazySegTree(vector<int> &a) : n(size(a)), st(n * 4), lazy(n * 4, -1) {
 858 |         build(0, 0, n - 1, a);
 859 |     }
 860 | 
 861 |     void build(int u, int l, int r, vector<int> &a) {
 862 |         if (l == r) {
 863 |             st[u] = a[l];
 864 |             return;
 865 |         }
 866 |         int m = (l + r) / 2;
 867 |         build(lc(u), l, m, a);
 868 |         build(rc(u), m + 1, r, a);
 869 |         st[u] = merge(st[lc(u)], st[rc(u)]);
 870 |     }
 871 | 
 872 |     void upd(int ql, int qr, int val) {
 873 |         upd(0, 0, n - 1, ql, qr, val);
 874 |     }
 875 | 
 876 |     void upd(int u, int l, int r, int ql, int qr, int val) {
 877 |         push(u, l, r);
 878 |         if (qr < l or r < ql) return;
 879 |         if (ql <= l and r <= qr) {
 880 |             lazy[u] += val;
 881 |             push(u, l, r);
 882 |             return;
 883 |         }
 884 |         int m = (l + r) / 2;
 885 |         upd(lc(u), l, m, ql, qr, val);
 886 |         upd(rc(u), m + 1, r, ql, qr, val);
 887 |         st[u] = merge(st[lc(u)], st[rc(u)]);
 888 |     }
 889 | 
 890 |     int query(int ql, int qr) {
 891 |         return query(0, 0, n - 1, ql, qr);
 892 |     }
 893 | 
 894 |     int query(int u, int l, int r, int ql, int qr) {
 895 |         push(u, l, r);
 896 |         int m = (l + r) / 2;
 897 |         if (qr < l or r < ql) return 0;
 898 |         if (ql <= l and r <= qr) return st[u];
 899 |         return merge(query(lc(u), l, m, ql, qr), query(rc(u), m + 1, r, ql, qr));
 900 |     }
 901 | };
 902 | 
 903 | struct FenwickTree {
 904 |     int n;
 905 |     vector<int> bit;
 906 | 
 907 |     FenwickTree(vector<int> &a) : n(size(a)), bit(n + 1) {
 908 |         for (int i = 0; i < n; i++) upd(i, a[i]);
 909 |     }
 910 | 
 911 |     void upd(int i, int del) {
 912 |         for (i++; i <= n; i += i & -i) bit[i] += del;
 913 |     }
 914 | 
 915 |     int sum(int i) {
 916 |         int s = 0;
 917 |         for (i++; i > 0; i -= i & -i) s += bit[i];
 918 |         return s;
 919 |     }
 920 | 
 921 |     int query(int l, int r) {
 922 |         return sum(r) - sum(l - 1);
 923 |     }
 924 | };
 925 | 
 926 | struct FenwickTree2D {
 927 |     int n, m;
 928 |     vector<vector<int>> bit;
 929 | 
 930 |     FenwickTree2D(vector<vector<int>> &a) : n(size(a)), m(size(a[0])), bit(n + 1, vector<int>(m + 1)) {
 931 |         for (int i = 0; i < n; i++) {
 932 |             for (int j = 0; j < m; j++) {
 933 |                 upd(i, j, a[i][j]);
 934 |             }
 935 |         }
 936 |     }
 937 | 
 938 |     void upd(int r, int c, int del) {
 939 |         for (int i = r + 1; i <= n; i += i & -i) {
 940 |             for (int j = c + 1; j <= m; j += j & -j) {
 941 |                 bit[i][j] += del;
 942 |             }
 943 |         }
 944 |     }
 945 | 
 946 |     int sum(int r, int c) {
 947 |         int s = 0;
 948 |         for (int i = r + 1; i > 0; i -= i & -i) {
 949 |             for (int j = c + 1; j > 0; j -= j & -j) {
 950 |                 s += bit[i][j];
 951 |             }
 952 |         }
 953 |         return s;
 954 |     }
 955 | 
 956 |     int query(int r1, int c1, int r2, int c2) {
 957 |         return sum(r2, c2) - sum(r1 - 1, c2) - sum(r2, c1 - 1) + sum(r1 - 1, c1 - 1);
 958 |     }
 959 | };
 960 | 
 961 | struct SparseTable {
 962 |     int n, LOG;
 963 |     vector<vector<int>> table;
 964 | 
 965 |     int merge(int x, int y) {}
 966 | 
 967 |     SparseTable(vector<int> &a) : n(size(a)), LOG(__lg(n)), table(n, vector<int>(LOG + 1, -1)) {
 968 |         for (int k = 0; k <= LOG; k++) {
 969 |             for (int i = 0; i <= n - (1 << k); i++) {
 970 |                 if (k == 0) table[i][0] = a[i];
 971 |                 else table[i][k] = merge(table[i][k - 1], table[i + (1 << (k - 1))][k - 1]);
 972 |             }
 973 |         }
 974 |     }
 975 | 
 976 |     int query(int l, int r) {
 977 |         int k = __lg(r - l + 1);
 978 |         return merge(table[l][k], table[r - (1 << k) + 1][k]);
 979 |     }
 980 | };
 981 | 
 982 | struct SparseTable2D {
 983 |     int n, m, LOGN, LOGM;
 984 |     vector<vector<vector<vector<int>>>> table;
 985 | 
 986 |     int merge(int a, int b) {
 987 |         return max(a, b);
 988 |     }
 989 | 
 990 |     int merge(int a, int b, int c, int d) {
 991 |         return max({a, b, c, d});
 992 |     }
 993 | 
 994 |     SparseTable2D(vector<vector<int>> &a) :
 995 |         n(size(a)),
 996 |         m(size(a[0])),
 997 |         LOGN(__lg(n)),
 998 |         LOGM(__lg(m)),
 999 |         table(n, vector<vector<vector<int>>>(LOGN + 1, vector<vector<int>>(m, vector<int>(LOGM + 1, -1))))
1000 |     {
1001 |         for (int kn = 0; kn <= LOGN; kn++) {
1002 |             for (int i = 0; i <= n - (1 << kn); i++) {
1003 |                 for (int km = 0; km <= LOGM; km++) {
1004 |                     for (int j = 0; j <= m - (1 << km); j++) {
1005 |                         if (kn == 0) {
1006 |                             if (km == 0) table[i][0][j][0] = a[i][j];
1007 |                             else table[i][0][j][km] = merge(table[i][0][j][km - 1], table[i][0][j + (1 << (km - 1))][km - 1]);
1008 |                         } else {
1009 |                             table[i][kn][j][km] = merge(table[i][kn - 1][j][km], table[i + (1 << (kn - 1))][kn - 1][j][km]);
1010 |                         }
1011 |                     }
1012 |                 }
1013 |             }
1014 |         }
1015 |     }
1016 | 
1017 |     int query(int r1, int c1, int r2, int c2) {
1018 |         int kn = __lg(r2 - r1 + 1);
1019 |         int km = __lg(c2 - c1 + 1);
1020 |         return merge(table[r1][kn][c1][km],
1021 |                      table[r1][kn][c2 - (1 << km) + 1][km],
1022 |                      table[r2 - (1 << kn) + 1][kn][c1][km],
1023 |                      table[r2 - (1 << kn) + 1][kn][c2 - (1 << km) + 1][km]
1024 |                     );
1025 |     }
1026 | };
1027 | 
1028 | struct DSU {
1029 |     vi par, size;
1030 |     int comps;
1031 |     stack<int> st;
1032 | 
1033 |     DSU(int n) : par(n), size(n, 1), comps(n) {
1034 |         iota(begin(par), end(par), 0);
1035 |     }
1036 | 
1037 |     void unite(int u, int v) {
1038 |         u = find(u), v = find(v);
1039 |         if (u == v) return;
1040 |         if (size[u] < size[v]) swap(u, v);
1041 |         st.push(v);
1042 |         par[v] = u;
1043 |         size[u] += size[v];
1044 |         comps--;
1045 |     }
1046 | 
1047 |     int find(int u) {
1048 |         return (par[u] == u ? u : find(par[u]));
1049 |     }
1050 | 
1051 |     bool same(int u, int v) {
1052 |         return find(u) == find(v);
1053 |     }
1054 | 
1055 |     void roll() {
1056 |         int u = st.top();
1057 |         st.pop();
1058 |         par[u] = u;
1059 |         comps++;
1060 |     }
1061 | };
1062 | 
1063 | struct LinkedList {
1064 |     struct Node {
1065 |         int data;
1066 |         Node *next;
1067 |         Node(int d) {
1068 |             data = d;
1069 |             next = nullptr;
1070 |         }
1071 |     };
1072 | 
1073 |     Node *head, *tail;
1074 | 
1075 |     LinkedList() : head(nullptr), tail(nullptr) {}
1076 | 
1077 |     void append(int d) {
1078 |         Node *new_node = new Node(d);
1079 |         if (head == nullptr) {
1080 |             head = tail = new_node;
1081 |             return;
1082 |         }
1083 |         tail->next = new_node;
1084 |         tail = new_node;
1085 |     }
1086 | 
1087 |     void prepend(int d) {
1088 |         Node *new_node = new Node(d);
1089 |         if (head == nullptr) {
1090 |             head = tail = new_node;
1091 |             return;
1092 |         }
1093 |         new_node->next = head;
1094 |         head = new_node;
1095 |     }
1096 | 
1097 |     void print() {
1098 |         Node *curr_node = head;
1099 |         while (curr_node != nullptr) {
1100 |             cout << curr_node->data << "->";
1101 |             curr_node = curr_node->next;
1102 |         }
1103 |         cout << "NULL\n";
1104 |     }
1105 | };
1106 | 
1107 | /* = = = = = = = = = =
1108 | Square Root Techniques
1109 | = = = = = = = = = = */
1110 | 
1111 | const int BLOCK = 300;
1112 | 
1113 | vector<int> b(BLOCK);
1114 | for (int i = 0; i < n; i++) b[i / BLOCK] += a[i];
1115 | 
1116 | auto query = [&](int l, int r) -> int {
1117 |     int res = 0;
1118 |     int i = l;
1119 |     while (i <= r) {
1120 |         if (i % BLOCK == 0 and i + BLOCK <= r) {
1121 |             res += b[i / BLOCK];
1122 |             i += BLOCK;
1123 |         } else {
1124 |             res += a[i++];
1125 |         }
1126 |     }
1127 |     return res;
1128 | };
1129 | 
1130 | struct Query {
1131 |     int l, r, idx;
1132 |     bool operator<(Query q2) const {
1133 |         int b1 = l / BLOCK, b2 = q2.l / BLOCK;
1134 |         return make_pair(b1, (b1 % 2 == 0 ? r : -r)) < make_pair(b2, (b2 % 2 == 0 ? q2.r : -q2.r));
1135 |     }
1136 | };
1137 | 
1138 | vector<Query> qs(q);
1139 | for (int i = 0; i < q; i++) {
1140 |     Query &q = qs[i];
1141 |     cin >> q.l >> q.r;
1142 |     q.l--, q.r--;
1143 |     q.idx = i;
1144 | }
1145 | 
1146 | auto mos = [&]() -> vector<int> {
1147 |     sort(begin(qs), end(qs));
1148 |     auto add = [&](int i) -> void {};
1149 |     auto del = [&](int i) -> void {};
1150 |     auto get_ans = [&]() -> int {};
1151 |     vector<int> ans(size(qs));
1152 |     int l = 0, r = -1;
1153 |     for (Query q : qs) {
1154 |         while (l > q.l) add(--l);
1155 |         while (r < q.r) add(++r);
1156 |         while (l < q.l) del(l++);
1157 |         while (r > q.r) del(r--);
1158 |         ans[q.idx] = get_ans();
1159 |     }
1160 |     return ans;
1161 | };
1162 | 
1163 | 
1164 | /* = = = = = =
1165 | Stacks & Queues
1166 | = = = = = = */
1167 | 
1168 | vector<int> next_greater_element(vector<int> &a) {
1169 |     int n = size(a);
1170 |     vector<int> nge(n);
1171 |     stack<int> st;
1172 |     for (int i = n - 1; i >= 0; i--) {
1173 |         while (!empty(st) and a[st.top()] <= a[i]) st.pop();
1174 |         nge[i] = (empty(st) ? -1 : st.top());
1175 |         st.push(i);
1176 |     }
1177 |     return nge;
1178 | }
1179 | 
1180 | vector<int> sliding_window_min(vector<int> &a, int k) {
1181 |     deque<int> dq;
1182 |     vector<int> mins;
1183 |     for (int i = 0; i < size(a); i++) {
1184 |         while (!empty(dq) and dq.front() <= i - k) dq.pop_front();
1185 |         while (!empty(dq) and a[dq.back()] >= a[i]) dq.pop_back();
1186 |         dq.push_back(i);
1187 |         if (i >= k - 1) mins.push_back(a[dq.front()]);
1188 |     }
1189 |     return mins;
1190 | }
1191 | 


--------------------------------------------------------------------------------