895

codeforces/895/e.cc

@@ -76,20 +76,106 @@ auto ub = [](auto... args) {
 #define rall(x) (x).rbegin(), (x).rend()
 //  }}}
 
+#include <stdexcept>
+#include <vector>
+
+template <typename T>
+class segment_tree {
+ public:
+  explicit segment_tree(std::vector<T> const& data)
+      : n(data.size()), tree(2 * n, sentinel()), lazy(n, sentinel()) {
+    for (size_t i = 0; i < n; ++i)
+      tree[i + n] = data[i];
+    for (int i = n - 1; i > 0; --i)
+      tree[i] = merge(tree[i * 2], tree[i * 2 + 1]);
+  }
+
+  void update(int l, int r, T const& t) noexcept {
+    l += n, r += n + 1;
+    push(l);
+    push(r - 1);
+    for (int L = l, R = r; L < R; L /= 2, R /= 2) {
+      if (L & 1)
+        apply(L++, t);
+      if (R & 1)
+        apply(--R, t);
+    }
+    for (l /= 2; l; l /= 2)
+      tree[l] = merge(tree[l * 2], tree[l * 2 + 1]);
+    for (r = (r - 1) / 2; r; r /= 2)
+      tree[r] = merge(tree[r * 2], tree[r * 2 + 1]);
+  }
+
+  [[nodiscard]] T query(int l, int r) noexcept {
+    l += n, r += n + 1;
+    push(l);
+    push(r - 1);
+    T left = sentinel(), right = sentinel();
+    for (; l < r; l /= 2, r /= 2) {
+      if (l & 1)
+        left = merge(left, tree[l++]);
+      if (r & 1)
+        right = merge(tree[--r], right);
+    }
+    return merge(left, right);
+  }
+
+ private:
+  int n;
+  std::vector<T> tree, lazy;
+
+  [[nodiscard]] T merge(T const& a, T const& b) const {
+    return a ^ b;
+  }
+
+  [[nodiscard]] inline T do_apply(T const& a, T const& b) const {
+    return a & b;
+  }
+
+  [[nodiscard]] T sentinel() const {
+    return 0;
+  }
+
+  void push(int i) {
+    for (int h = __builtin_clz(n) - __builtin_clz(i); h > 0; --h) {
+      int p = i >> h;
+      if (lazy[p] != sentinel()) {
+        apply(p * 2, lazy[p]);
+        apply(p * 2 + 1, lazy[p]);
+        lazy[p] = sentinel();
+      }
+    }
+  }
+
+  void apply(int i, T const& t) {
+    tree[i] = do_apply(tree[i], t);
+    if (i < n)
+      lazy[i] = do_apply(lazy[i], t);
+  }
+};
+
 void solve() {
   int n;
   cin >> n;
-  ve<ll> a(n), prefix(n);
+  ve<ll> a(n);  //, prefix(n);
   for (auto& e : a)
     cin >> e;
   string s;
   cin >> s;
-  int zeroes = 0;
+  // int zeroes = 0;
+  ve<ll> zero(n), one(n);
   for (int i = 0; i < n; ++i) {
-    prefix[i] = a[i] ^ (i ? prefix[i - 1] : 0);
-    if (s[i] == '0')
-      zeroes ^= a[i];
+    //   prefix[i] = a[i] ^ (i ? prefix[i - 1] : 0);
+    if (s[i] == '0') {
+      zero[i] = a[i];
+      one[i] = 0;
+    } else {
+      one[i] = a[i];
+      zero[i] = 0;
+    }
+    //     zeroes ^= a[i];
   }
+  segment_tree<ll> zeroes(zero), ones(one);
   int q;
   cin >> q;
   int cmd, l, r, g;
@@ -99,13 +185,17 @@ void solve() {
       cin >> l >> r;
       --l;
       --r;
-      zeroes ^= prefix[r] ^ (l ? prefix[l - 1] : 0);
+      zeroes.update(l, r);
+      //     zeroes ^= prefix[r] ^ (l ? prefix[l - 1] : 0);
     } else {
       cin >> g;
-      if (g == 0)
-        pr("{} ", zeroes);
-      else
-        pr("{} ", prefix.back() ^ zeroes);
+      if (g == 1) {
+        pr("{} ", (g == 1 ? ones : zeroes).query(0, n - 1));
+      }
+      //     if (g == 0)
+      //       pr("{} ", zeroes);
+      //     else
+      //       pr("{} ", prefix.back() ^ zeroes);
     }
   }
   prln();