Another attempt at doing the problem.

Alright, at least now I'm close...

2015/phase2/fila.cpp

@@ -80,7 +80,7 @@ struct insertion {
 
     bool operator<(insertion &i) {
         if (ind == i.ind) {
-            return pos < i.pos;
+            return ind == 0 ? pos < i.pos : pos > i.pos;
         }
         return ind < i.ind;
     }
@@ -91,11 +91,46 @@ struct query {
     int pos;
     ll val;
 
-    query(int type, int pos, int val): type(type),
+    query() : type(0), pos(0), val(0) {}
+    query(int type, int pos, ll val): type(type),
                                        pos(pos),
                                        val(val) {}
 };
 
+vl segtree;
+vl bit;
+
+ll search(int n, int l, int r, int lim, int v)
+{
+    if (segtree[n] <= v || l >= lim) {
+        return 0;
+    }
+
+    if (l == r) {
+        return l;
+    }
+
+    int mid = (l + r) / 2;
+    ll ans = segtree[n * 2 + 1] > v ? search(n * 2 + 1, mid + 1, r, lim, v) : 0;
+    return ans ?: search(n * 2, l, mid, lim, v);
+}
+
+void add(int i)
+{
+    for (; i < bit.size(); i += (i & -i)) {
+        bit[i]++;
+    }
+}
+
+ll get(int i)
+{
+    ll ans = 0;
+    for (; i >= 1; i -= (i & -i)) {
+        ans += bit[i];
+    }
+    return ans;
+}
+
 int main()
 {
     ios::sync_with_stdio(false);
@@ -113,14 +148,79 @@ int main()
     V<insertion> inserts;
 
     rep(i, q) {
-        ll t, p, v;
+        int type, pos;
-        cin >> t >> p >> v;
+        ll value;
-        queries.emplace_back(t, p, v);
+        cin >> type >> pos >> value;
-        if (t == 0) {
+        queries[i] = query(type, pos, value);
-            inserts.emplace_back(i, p, v);
+        if (type == 0) {
+            inserts.emplace_back(i, pos, value);
         }
     }
 
     reverse(queries.begin(), queries.end());
     sort(inserts.begin(), inserts.end());
+
+    vl act(n + inserts.size());
+    size_t now = 0;
+    size_t q_itr = 0;
+    size_t i_itr = 0;
+    while (now < act.size() && q_itr < queue.size() && i_itr < inserts.size()) {
+        if (q_itr + 1 < inserts[i_itr].ind) {
+            act[now] = queue[q_itr];
+            q_itr++;
+        } else {
+            act[now] = inserts[i_itr].val;
+            i_itr++;
+        }
+        now++;
+    }
+
+    for (; q_itr < queue.size(); q_itr++, now++) {
+        act[now] = queue[q_itr];
+    }
+    for (; i_itr < inserts.size(); i_itr++, now++) {
+        act[now] = inserts[i_itr].val;
+    }
+
+    size_t bef = act.size();
+    while (__builtin_popcount(act.size()) != 1) {
+        act.push_back(-1);
+    }
+    size_t actn = act.size();
+
+    segtree.resize(act.size() * 2);
+    bit.resize(act.size() + 1);
+
+    for (size_t i = actn; i < actn * 2; i++) {
+        segtree[i] = act[i - actn];
+    }
+    for (size_t i = actn - 1; i > 0; i--) {
+        segtree[i] = max(segtree[i * 2], segtree[i * 2 + 1]);
+    }
+
+    vl ans(queries.size() - inserts.size());
+    auto itr = ans.rbegin();
+    for (auto [type, pos, value] : queries) {
+        if (type == 0) {
+            int fix = get(pos + 1);
+            // cout << "Remove fix: " << fix << '\n';
+            segtree[pos + actn + fix] = -1;
+            add(pos + fix + 1);
+            for (size_t i = (pos + actn + fix) / 2; i >= 1; i /= 2) {
+                segtree[i] = max(segtree[i * 2], segtree[i * 2 + 1]);
+            }
+            continue;
+        }
+
+        int fix = get(pos);
+        // cout << "Query fix: " << fix << '\n';
+        int ans = search(1, 1, bef, pos + fix, act[pos + fix - 1] + value);
+        // cout << "Found: " << ans << " with: " << act[pos + fix - 1] << '\n';
+        *itr = ans ? ans - get(ans) : 0;
+        itr++;
+    }
+
+    for (auto i : ans) {
+        cout << i << '\n';
+    }
 }