How to remove all element between given indexes? - c++

Question

Briefly about the condition of the problem:
Given the numbers from 1 to n, and m stages of purification, after that follows in m lines with two numbers left and right (borders, inclusive), the range of deleting numbers (1..n), you must output all living elements after removal.
I will give an example:
n = 10, m = 3
Suppose we make an array a[1,2,3,4,5,6,7,8,9,10];
left = 1, right = 2;
After 1 deletion: a[3,4,5,6,7,8,9,10];
left = 4, right = 5;
After 2 deletion: a[3,4,5,8,9,10];
left = 3, right = 5;
After 3 deletion: a[3,4,10];
Conclusion: 3 4 10
So not everything is so simple, the restrictions are strict, namely:
n, m <= 3 * 10 ^ 5
left <= right
My attempt was as follows: I created a vector from numbers from 1 to n and deleted all elements in range [left, right], but Time Limit is coming because of the complexity.
#include <iostream>
#include <vector>
using namespace std;
#define ll uint64_t
int main() {
ll i, n, k, l, r;
cin >> n >> k;
vector <ll> a;
for (i = 1; i <= n; i++) {
a.push_back(i);
}
for (i = 1; i <= k; i++) {
cin >> l >> r;
a.erase(a.begin()+l-1,a.begin()+r);
}
cout << a.size() << endl;
for (auto i : a) {
cout << i << ' ';
}
}
How to solving this problem?

Answer 1

The problem is solvable using a segment tree with lazy propagation and order statistics in O((N + Q) * log(N)) which should pass in a second or two on most online judges given your constraints.
Brief Explanation
'Still Exists' Boolean Array
Let's imagine that we have a boolean array of size N that indicates for each item whether it still exists or removed. The array will be initialized with ones since no elements are removed yet.
Segment Tree
Info Query: Let's build a range-sum segment tree on top of this boolean array (True is mapped to 1 and false is mapped to 0). If we query for any [L, R] range, the segment tree answers with the number of still existing elements. (Note that L and R are indices in the original array -that includes removed and non-removed elements-)
Update Query: The only update query done on the segment tree is to set a range with zeros (marking a range of elements as removed). Since we update a range of elements to zeros, we need to use lazy propagation (No need for it if the problem required removing a single item).
The Final Output
After updating all ranges given to zeros, we can iterate over each index and check if it's zero or one, and print it if it's one, however the solution is not that easy since the ranges provided in the input are not ranges in the original array, it's actually indices in the updated array.
Updated Ranges Problem
To understand the problem more let's go through an example:
Let's assume we're working with an array of length 6, the array is initially: 1 2 3 4 5 6 and the boolean array is initially: 1 1 1 1 1 1
Let's assume that the first deletion is [2, 4], now the new array is: 1 5 6 and the new updated boolean array is: 1 0 0 0 1 1
At this point, if we were asked to print the array, we will simply go through the original array and print the values that only corresponds to true in the boolean array.
Now let's try to delete another range [1, 2], if we simply set the first two elements to zeros, then we will end up with: 0 0 0 0 1 1. Which means that we still have 5, 6 on in our array, while we actually have only 6 after the last deletion.
Order-Statistics to solve the updated ranges problem
To solve the problem, we need to add the order-statistics property to our segment tree. this property will answer the following question: Given X, find the index were the prefix sum of ones that ends with it is X, this will help us map the current [L, R] into new [L, R] that can be used with the original indexing.
To understand the mapping better, let's go back to the second step of our example:
The boolean array was: 1 0 0 0 1 1, Delete elements between L=1 and R=2, using the order-statistics property, L will be mapped to 1 and R will be mapped to 5, now we will update the range between the newL and the newR to zeros and the boolean array becomes 0 0 0 0 0 1.
Code
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
vector<int> seg, lazy;
int sz;
void build(int ind, int ns, int ne, const vector<int> &v) {
if (ns == ne) {
seg[ind] = v[ns];
return;
}
int mid = ns + (ne - ns) / 2;
build(ind * 2, ns, mid, v);
build(ind * 2 + 1, mid + 1, ne, v);
seg[ind] = seg[ind * 2] + seg[ind * 2 + 1];
}
void probagateLazy(int ind) {
if (lazy[ind]) {
lazy[ind] = 0, seg[ind] = 0;
if (ind * 2 + 1 < 4 * sz)
lazy[ind * 2] = lazy[ind * 2 + 1] = 1;
}
}
int query(int s, int e, int ind, int ns, int ne) {
probagateLazy(ind);
if (e < ns || s > ne)
return 0;
if (s <= ns && ne <= e)
return seg[ind];
int mid = ns + (ne - ns) / 2;
return query(s, e, ind * 2, ns, mid) + query(s, e, ind * 2 + 1, mid + 1, ne);
}
void update(int s, int e, int ind, int ns, int ne) {
probagateLazy(ind);
if (e < ns || s > ne)
return;
if (s <= ns && ne <= e) {
lazy[ind] = 1;
probagateLazy(ind);
return;
}
int mid = ns + (ne - ns) / 2;
update(s, e, ind * 2, ns, mid);
update(s, e, ind * 2 + 1, mid + 1, ne);
seg[ind] = seg[ind * 2] + seg[ind * 2 + 1];
}
int find(int pos, int ind, int ns, int ne) {
probagateLazy(ind);
if (ns == ne)
return ns;
probagateLazy(ind * 2);
probagateLazy(ind * 2 + 1);
int mid = ns + (ne - ns) / 2;
if (pos <= seg[ind * 2])
return find(pos, ind * 2, ns, mid);
return find(pos - seg[ind * 2], ind * 2 + 1, mid + 1, ne);
}
public:
SegmentTree(int sz, const vector<int> &v) {
this->sz = sz;
seg = vector<int>(sz * 4);
lazy = vector<int>(sz * 4);
build(1, 0, sz - 1, v);
}
int query(int s, int e) {
return query(s, e, 1, 0, sz - 1);
}
int update(int s, int e) {
update(s, e, 1, 0, sz - 1);
}
int find(int pos) {
return find(pos, 1, 0, sz - 1);
}
};
int main() {
int i, n, k, l, r;
scanf("%d %d", &n, &k);
vector<int> a;
for (i = 1; i <= n; i++) {
a.push_back(i);
}
vector<int> v(n, 1);
SegmentTree st(n, v);
while (k--) {
scanf("%d %d", &l, &r);
int newL = st.find(l);
int newR = st.find(r);
st.update(newL, newR);
}
vector<int> ans;
for (int i = 0; i < n; i++) {
if (st.query(i, i))
ans.push_back(a[i]);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
}
Black Boxing the Segment Tree
If you're not familiar with segment trees, then it's expected to find the code hard to understand, so I'll try to make it easier by ignoring the internal implementation of the segment tree and give you a quick look at its functionalities.
Query Method
The query method takes as an input the start and end index of the range to be queried and returns the summation of the elements inside this range.
Update Method
The update method takes as input the start and end index of the range to be updated, and set all items inside this range to zeros
Find Method
The find method takes as an input X and returns the first element Y were the sum of elements in the range [0, Y] is X
Other Solutions
The problem can also be solved using Splay Tree or Treap data structure.