A 2D Fenwick tree can solve this in $O(log^2 N)$ time and $O(N^2)$ space for both update and query, when your coordinates are integers and $N$ is the size of the maximum coordinate.
Fenwick trees are nice for competitive programming because they have a really compact implementation, for example in C++:
typedef unsigned long long uw;
uw lsb(uw x) { return x & -x; }
uw up(uw x) { return x + lsb(x); }
uw dn(uw x) { return x - lsb(x); }
template<class T> struct Fenwick2D {
uw n; std::vector<std::vector<T>> b;
Fenwick2D(uw n) : n(n), b(n+1, std::vector<T>(n+1)) { }
void increase(uw x, uw y_, T v) {
for (; x <= n; x = up(x))
for (uw y = y_; y <= n; y = up(y))
b(x)(y) += v;
}
T prefix_sum(uw x, uw y_) {
T s = 0;
for (; x >= 1; x = dn(x))
for (uw y = y_; y >= 1; y = dn(y))
s += b(x)(y);
return s;
}
};
And this shows your example from the question:
int main(int argc, char** argv) {
Fenwick2D<int> fw(4);
fw.increase(1, 1, 1);
fw.increase(2, 2, 1);
fw.increase(1, 2, 1);
fw.increase(3, 2, 1);
std::cout << fw.prefix_sum(1, 1) << "n";
std::cout << fw.prefix_sum(2, 2) << "n";
std::cout << fw.prefix_sum(3, 3) << "n";
return 0;
}
This data structure is more general than your problem as well. In general it can increase any grid element $g_{x,y}$ by value $v$ (which decreases for negative $v$), and ask the value of the lower quadrant prefix sum $sum_{ileq x}sum_{jleq y} g_{i,j}$ for any $x, y$. Note that this means you can get area sums as well using 4 queries by the inclusion-exclusion principle.
Alex from ServerStrong recently presented his first offer to us. We thought the offers seemed pretty attractive to KVM, so here they are. They offer SSV KVM VPS based in Los Angeles and have three exclusive exclusive plans for the LEB community. Since everything works with SSD storage, we hope that these plans provide a very high disk performance, the ideal scene for those looking for something powerful 🙂 As always, we want to hear your comments, so if you decide to buy a ServerStrong plan! Please be sure to share your experience below!