#	User	Rating
1	tourist	3985
2	jiangly	3741
3	jqdai0815	3682
4	Benq	3529
5	orzdevinwang	3526
6	ksun48	3489
7	Radewoosh	3483
8	Kevin114514	3442
9	ecnerwala	3392
9	Um_nik	3392

#	User	Contrib.
1	cry	169
2	atcoder_official	162
2	maomao90	162
2	Um_nik	162
5	djm03178	158
6	-is-this-fft-	157
7	adamant	155
8	awoo	154
8	Dominater069	154
10	nor	150

1.Introduction

Binary grouping is a way to implent dynamic insertion.If you found that the query for a data structure constructed by inserted elements from set $$$s$$$ can be answered online and be solved by uniting querys from a set of data structures built on a partition of $$$S$$$ in $$$O(h(n,m))$$$ as $$$m$$$ is the number of subsets in the partition and you can construct a data structure in $$$O(\operatorname{f}(n))$$$,It means that you can divide the elements in groups,for $$$n = \sum 2 ^ {a_i}(a_i > a_{i + 1})$$$,We can divide $$$n$$$ elements into groups,each group has $$$2^{a_k}$$$ elements,in this way we divided elements to $$$\log_2{n}$$$ groups.Then we build a data structure for each group of insertions using the construct algorithm.

When we insert a new element,we divide it in a group,and when we found a group that its size is the same as the new group,we merge the two groups into one group and rebuild a data structure with the elements in the group.Using the method,we get a way to implent dynamic insertion and the method to construct is $$$O(\sum {f(x)})(\sum x = n \log_2 n) \approx O(f(n)\log_2 n)$$$ in total and $$$O(h(n,\log_2 n))$$$ for each query.

2.Examples

It can be used for kd-tree,but I haven't found an example on the site,so please leave a comment if you found the example.

The example of using the method on kd-tree is P4148 on luogu,in the problem,the elements is the points in the first operation and we can use kd-tree to deal with the elements and answer the query online.But we have to implent dynamic insertion,so we use this method.

code

#include<algorithm>
#include<cstdio>
using namespace std;
namespace K_D_tree{
	const int N = 300009,K = 2;
	int V = 0;
	struct node{
		int p[K],mx[K],mn[K],lc,rc,sz,sum,val;
	}a[N];
	int sro;
	int build(int l,int r,int nk,node a[]){
		if(l > r)
			return 0;
		if(l == r){
			for(int i = 0; i < K; i ++){
				a[l].mx[i] = a[l].p[i];
				a[l].mn[i] = a[l].p[i];
			}
			a[l].sz = 1;
			a[l].sum = a[l].val;
			return l;
		}
		int m = (l + r) >> 1;
		sro = nk;
		nth_element(a + l,a + m,a + r + 1,[](node x,node y){return x.p[sro] < y.p[sro];});
		a[m].lc = build(l,m - 1,(nk + 1) % K,a);
		a[m].rc = build(m + 1,r,(nk + 1) % K,a);
		for(int i = 0; i < K; i ++){
			a[m].mx[i] = max(a[m].p[i],max(a[a[m].lc].mx[i],a[a[m].rc].mx[i]));
			a[m].mn[i] = min(a[m].p[i],min(a[a[m].lc].mn[i],a[a[m].rc].mn[i]));
		}
		a[m].sz = r - l + 1;
		a[m].sum = a[a[m].lc].sum + a[a[m].rc].sum + a[m].val;
		return m;
	}
	int fnd(int k,int q[]){
	    if(k == 0)
	        return 0;
		for(int i = 0; i < K; i ++){
			if(q[i] > a[k].mx[i] || q[i] < a[k].mn[i])
				return 0;
		}
		bool flg = true;
		for(int i = 0; i < K; i ++){
			if(q[i] != a[k].p[i]){
				flg = false;
				break;
			}
		}
		if(flg)
			return k;
		else 
			return max(fnd(a[k].lc,q),fnd(a[k].rc,q));
	}
	void change(int k,int q[],int ad){
	    if(k == 0)
	        return ;
		for(int i = 0; i < K; i ++){
			if(q[i] > a[k].mx[i] || q[i] < a[k].mn[i])
				return ;
		}
		bool flg = true;
		for(int i = 0; i < K; i ++){
			if(q[i] != a[k].p[i]){
				flg = false;
				break;
			}
		}
		if(flg){
			a[k].val += ad;
			a[k].sum += ad;
			return;
		}
		else {
			change(a[k].lc,q,ad),change(a[k].rc,q,ad);
			a[k].sum = a[a[k].lc].sum + a[a[k].rc].sum + a[k].val;
		}
	}
	int query(int k,int l[],int r[]){
		if(k == 0)
		    return 0;
		for(int i = 0; i < K; i ++){
			if(l[i] > a[k].mx[i] || r[i] < a[k].mn[i])
				return 0;
		}
		bool flg = true;
		int ret = 0;
		for(int i = 0; i < K; i ++){
			if(l[i] > a[k].p[i] || r[i] < a[k].p[i]){
				flg = false;
				break;
			}
		}
		if(flg)
			ret += a[k].val;
		flg = true;
		for(int i = 0; i < K; i ++){
			if(l[i] > a[k].mn[i] || r[i] < a[k].mx[i]){
				flg = false;
				break;
			}
		}
		if(flg)
			return a[k].sum;
		else 
			return ret + query(a[k].lc,l,r) + query(a[k].rc,l,r);
	}
	int str[100009],top = 0,lf[100009],rt[100009];
};
using namespace K_D_tree;
int lans,c,o,lp[K],rp[K];
int main(){
	scanf("%*d");
	while(true){
		scanf("%d",&o);
		if(o == 1){
			scanf("%d %d %d",&lp[0],&lp[1],&c);
			lp[0] ^= lans;
			lp[1] ^= lans;
			c ^= lans;
			bool flg = false;
			for(int j = 1; j <= top; j ++){
				if(fnd(str[j],lp) != 0){
					change(str[j],lp,c);
					flg = true;
					break;
				}
			}
			if(!flg){
				V ++;
				for(int j = 0; j < K; j ++){
					a[V].mx[j] = a[V].mn[j] = a[V].p[j] = lp[j];
				}
				a[V].sum = a[V].val = c;
				a[V].sz = 1;
				int u = 1,nlf = V;
				while(a[str[top]].sz == u){
					//printf("%d\n",top);
					nlf = lf[top];
					u = (u << 1);
					top --;
				}
				top ++;
				str[top] = build(nlf,V,0,a);
				lf[top] = nlf;
			}
		}
		else if(o == 2){
			scanf("%d %d %d %d",&lp[0],&lp[1],&rp[0],&rp[1]);
			lp[0] ^= lans;
			lp[1] ^= lans;
			rp[0] ^= lans;
			rp[1] ^= lans;
			//printf("%d %d %d %d\n",lp[0],lp[1],rp[0],rp[1]);
			lans = 0;
			for(int j = 1; j <= top; j ++){
				lans += query(str[j],lp,rp);
			}
			printf("%d\n",lans);
		}
		else{
			break;
		}
	}
	return 0;
}

...

In CF710F,we use the method on AC-Automation.In the task,we use a group to deal with the inserted string and an another group for deleted strings.In both of the groups,we devide the strings into groups and deal with insertions using the method and make ACAM for each group. When we insert a string,we insert it to the group of inserted strings and insert it to the group of deleted string when we delete it.For querys,if $$$x_i$$$ means that How many string is concluded if we arrive index $$$i$$$ while running the ACAM,$$$y_i$$$ is how many string ends here in the trie,we get $$$x_i = y_i + x_{fail_i}$$$,and the way to get answer is:

Run all the ACAMs in the group of inserted strings and add $$$x_i$$$ to answer while arriving index $$$i$$$.
Run all the ACAMs in the group of deleted strings and minus answer by $$$x_i$$$ while arriving index $$$i$$$.

Here is the Accepted submission.

written at the end of the blog

We would like to thank:

Masters who invent the method;
zhengqingyuan edit the blog;
unalive to give advice and make the blog better.
adamant suggest a good problem as an example of using the trick.

Comments (24)

Write comment?

zhengqingyuan

3 months ago, # |

Auto comment: topic has been updated by zhengqingyuan (previous revision, new revision, compare).

→ Reply

unalive

Can you explain in more detail?

3 months ago, # ^ |

Recent comment is deleted,and which part needs more detail?

← Rev. 2 →

+26

Maybe I have skill issue, but I like very detailed explanations. I wrote the following in my notes after understanding it.

This trick requires a data structure which satisfies the following:

It can be constructed in $$$O(f(n))$$$ offline by inserting $$$n$$$ elements.
It can be queried online.
The query for a data structure constructed by inserting elements from set $$$S$$$ can be found by uniting queries from a set of data structures built on a partition of $$$S$$$ in $$$O(g(n, m))$$$ time where $$$m$$$ is number of subsets in partition (associativity).

Now, using this trick we can maintain a set of data structures built on a partition of set $$$S$$$ while processing online queries and also insertions to $$$S$$$. The total amortized time taken for processing insertions will be $$$O(\sum{f(x)}) \; ( \sum{x} = n\log{n})$$$ and the time taken to answer each query will be $$$O(g(n, \log{n}))$$$ (where $$$n$$$ is the total number of elements we insert).

The trick works as follows:

At every step we maintain the partition of $$$S$$$ such that all the subsets in the partition have sizes equal to different powers of two. For every subset, we will also have a data structure built on elements contained in it.
To handle an element's insertion, we create a singleton set containing this element, insert this set into our partition, and then merge sets with equal sizes until no two sets have equal sizes anymore. Every time we merge two sets with equal sizes, we delete the data structure corresponding to them and create a data structure for the newly created set. It is easy to see that this process works like "carries" in binary addition and our invariant in 1. is maintained.
To process queries, we simply query every currently alive data structure and unite the returned values of these queries.

Thank you

upvoted

+10

zhengqingyuan's blog

1.Introduction

2.Examples

written at the end of the blog