Are there any easy problems as well? These looks like out of reach.

Knowing Mo's Algorithm finishes P2 and P3.

Also see this nice Atcoder problem.

Good problem: 1580C - Train Maintenance

Coolest sqrt decomposition ive seen so far: https://codeforces.me/problemset/problem/13/E

Few good problems based on the Heavy set — Light set based SQRT Decomposition:

1. https://www.hackerrank.com/contests/worldcupsemifinals/challenges/wccity/problem

2. https://www.codechef.com/problems/KOL15C

Few good problems based on SQRT Decomposition on Queries:

1. https://codeforces.me/contest/342/problem/E (Standard Centroid Decomposition Problem, but can also be solved using Query SQRT Decomposition)

2. https://www.codechef.com/problems/COW3E

Few good problems based on Mo's

1. https://codeforces.me/contest/86/problem/D

2. https://codeforces.me/problemset/problem/940/F (Mo's with Updates)

3. https://www.spoj.com/problems/XXXXXXXX/ (Mo's with Updates)

4. https://codeforces.me/contest/576/problem/C

Some really cool problems:

• https://toph.co/p/fabby-and-her-wedding-dress (Heavy — Light trick)
• Problem — F — Frank Sinatra (Mo on trees + SQRT decomposition)
• https://codeforces.me/problemset/problem/348/C (Heavy — Light trick)

plug

heavy/light example too: 1545F - AquaMoon and Potatoes

Strings — if the sum of lengths is S then there are at most sqrt(S) distinct lengths

i think it is wrong, for example:

S = 15 the strings can be of length: 1, 2, 3, 4, 5

there are 5 distinct lengths but $$$\sqrt 15$$$ is less than 4

Another problem about diving block technique.

problem on square root heuristic, (not sure if is under square root decomposition, but we do decompose into square root buckets)
https://www.codechef.com/JAN19A/problems/PARRTY
codeforces(2100 rated): Time to Raid Cowavans
codeforces(2400 rated): Mr. Kitayuta's Colorful Graph

Update : I managed to find the bug and remove WA(was overcounting) but now I am getting TLE on test 63. I also tried various block sizes from 300-700 and it gave TLE on various tests. I am sure that my add,delete and update functions work in O(B) time. I don't know how to remove TLE now. Also changed set to unordered set but that too failed :(. Errichto if you can shed some light on how to select B and comment on if I have applied heavy/light trick correctly or not..then that would be helpful :) Thanks and sorry for tagging.

#include <bits/stdc++.h>
using namespace std;
#define fast ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll  long long
#define all(v) v.begin(),v.end()
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define pi pair<int,int>
#define pii pair<int,pi>
#define REP(i,n) for(int i=0;i<n;i++)
#define ar array
const int B = 500;

vector<int> H(50005,0),on(50005,0);
unordered_set<int> edges[50005],heavy[50005];

int deg(int x){
	return (int)(edges[x].size());
}
void upd(int u){
	on[u]=1-on[u];
	//D1 + D2 + D3 + ..... + DN = 2*M (sum of degrees is twice the number of edges)
	//So number of Di>=sqrt(2*M) is of O(sqrt(2*M)).
	//Hence there can be atmost sqrt(2*M) heavy vertices.
	for(int x : heavy[u]){
			H[x]+=(on[u]>0 ? 1 : -1);
	}
}
void add(int u,int v){

	edges[u].insert(v);
	edges[v].insert(u);


	if(deg(u)==B){
		for(int x : edges[u]){
			H[u]+=on[x];
			heavy[x].insert(u);
			if(deg(x) >= B){
				heavy[u].insert(x);
			}
		}
	}
	if(deg(v) > B){
		heavy[u].insert(v);
		H[v]+=on[u];
	}

	if(deg(v)==B){
		for(int x : edges[v]){
			H[v]+=on[x];
			heavy[x].insert(v);
			if(deg(x) >= B){
				heavy[v].insert(x);
			}
		}
	}
	if(deg(u) > B){
		heavy[v].insert(u);
		H[u]+=on[v];
	}

}
void del(int u,int v){
	if(deg(u)==B){
		for(int x : edges[u]){
			heavy[x].erase(u);
		}
		H[u]=0;
	}
	if(deg(v)==B){
		for(int x : edges[v]){
			heavy[x].erase(v);
		}
		H[v]=0;
	}
	if(deg(u) > B){
		heavy[v].erase(u);
		H[u]-=on[v];
	}
	if(deg(v) > B){
		heavy[u].erase(v);
		H[v]-=on[u];
	}
	
	edges[u].erase(v);
	edges[v].erase(u);

}
int calc(int u){
	if(deg(u)>=B)
		return H[u];
	int sum = 0;
	//calculate answer for light nodes.
	for(int x : edges[u])
		sum+=on[x];
	return sum;
}
void run_case(){
	int n,m,q,o,u,v,i;
	cin >> n >> m >> q >> o;
	for(i=0;i<o;++i){
		cin >> u;
		--u;
		on[u]=1;
	}
	for(i=0;i<m;i++){
		cin >> u >> v;
		--u,--v;
		add(u,v);
	}
	
	while(q--){
		char op;
		cin >> op;
		if(op=='O'){
			cin >> u;
			upd(u-1);
		}
		if(op=='F'){
			cin >> u;
			upd(u-1);
		}
		if(op=='A'){
			cin >> u >> v;
			add(u-1,v-1);
		}
		if(op=='D'){
			cin >> u >> v;
			del(u-1,v-1);
		}
		if(op=='C'){
			cin >> u;
			cout<<calc(u-1)<<"\n";
		}
	}

}
int main(){
	fast;
	int t=1;
	while(t--){
		run_case();

	}
}

Is there a place to submit P9?

Another one ：

896E Welcome home, Chtholly

https://codeforces.me/problemset/problem/1491/H

A problem that uses the P6

https://www.codechef.com/problems/GERALD07

Anyone getting TLE on P1? I'm updating light and heavy nodes and getting TLE on test 32

My submission — 135313235

Is there any place I can submit P4 (and other problems without an attached question)

A really nice recent problem directly based on this blog: 1619H - Permutation and Queries

Errichto when is the second stream coming out? Also, can you provide hints to P9

Another one:

Magical Subsequence

For 1580C — Train Maintenance, I read the editorial but cannot quite understand how handling the trains satisfying $$$x_i + y_i \le \sqrt{m}$$$ can be done in $$$O(\sqrt{m})$$$. If we create an array of length $$$a$$$ for each $$$a \le \sqrt{m}$$$, I agree that updating for each array across each day takes $$$O(a)$$$ but when you sum over the arrays $$$1+2+\dots+\sqrt{m} = O(m)$$$. Am I understanding the arrays to create wrongly?

Can someone explain in more detail what each array contains and how all arrays get updated (or how information is extracted) on each day?

Why am I getting TLE on P2 ? 241207393

Edit : Solved it by using block size = 700. Also realized that the bounds are tight so no stupid things should be done that might slow down your code.