# pragma GCC optimize ("O3")
# pragma GCC optimize ("Ofast")
# pragma GCC optimize ("unroll-loops")
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i = (a); i < (b); i++)
#define rep2(i,a,b) for(int i = (b) &mdash; 1; i >= (a); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
#define em emplace
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define x first
#define y second
using namespace std;
using ll = long long;
using ld = long double;
using pi = pair<int, int>;
using ti = tuple<int, int, int>;
using pl = pair<ll, ll>;
using tl = tuple<ll, ll, ll>;

ll N, flag[4];
pl A[100], B[100], a, b;
set<pl> S;
pl rotate(pl a, int dir){
    if(dir == 0) return a;
    if(dir == 1) return {-a.y, a.x};
    if(dir == 2) return {-a.x, -a.y};
    return {a.y, -a.x};
}
int main() {
    cin.tie(0) -> sync_with_stdio(false); cout.tie(0);
    cin >> N;
    rep(i, 0, N) cin >> A[i].x >> A[i].y;
    rep(i, 0, N) cin >> B[i].x >> B[i].y;
    rep(i, 0, N) {
        a.x += A[i].x;
        a.y += A[i].y;
        b.x += B[i].x;
        b.y += B[i].y;
    }
    rep(i, 0, N){
        A[i].x = N * A[i].x &mdash; a.x;
        A[i].y = N * A[i].y &mdash; a.y;
        B[i].x = N * B[i].x &mdash; b.x;
        B[i].y = N * B[i].y &mdash; b.y;
        S.insert(B[i]);
    }
    rep(i, 0, N){
        rep(j, 0, 4) if(S.count(rotate(A[i], j)) == 0) flag[j] = 1;
    }
    rep(j, 0, 4) if(flag[j] == 0){
        cout << "Yes\n";
        return 0;
    }
    cout << "No\n";
}

We consider intervals of all types in shift them by some small value in or out according to their types. Finally we bruteforce all pairs to check intersection (O(1)) and return the count.

#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++)

void run_case(){
	int n,j,i;
	cin >> n;
	vector<double> t(n),l(n),r(n);
	for(i=0;i<n;i++){
		cin >> t[i] >> l[i] >> r[i];
		if(t[i]==2)
			r[i]-=0.01;
		else if(t[i]==3)
			l[i]+=0.01;
		else if(t[i]==4){
			l[i]+=0.01;
			r[i]-=0.01;
		}
	}
	int cnt=0;
	for(i=0;i<n;i++){
		for(j=i+1;j<n;j++){
			if(l[i]>r[j] || r[i]<l[j])
				continue;
			++cnt;
		}
	}
	cout<<cnt;
 
}
 
int main(){
	fast;
	int tt=1;
	while(tt--){
		run_case();
	}
	
	
}
 

Bring both the configurations of points to the origin.(You can do this by translating all points by adding shifts in x and y needed to bring centroid to origin). Next we can rotate one configuration keeping other fixed in intervals of 0.001 degrees(Basically bruteforce). And after every such rotation check if the 2 systems match or not. One such way to check is to sort both the configurations first by x then by y.

. It barely passed.

#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<ll,ll>
#define REP(i,n) for(int i=0;i<n;i++)
#define deb(...) [](const auto&...x){ char c='='; cerr<<#__VA_ARGS__<<" "; ((cerr<<exchange(c,',')<<" "<<x),...); cerr<<"\n"; }(__VA_ARGS__);
const double eps = 0.01;

bool cmp(pair<double,double> p1, pair<double,double> p2){
	if(p1.F < p2.F)
		return true;
	else if(p1.F > p2.F)
		return false;
	else{
		return p1.S < p2.S;
	}
}

void run_case(){
	int n,i;
	cin >> n;
	vector<double> x(n),y(n),xx(n),yy(n);
	 double pii = 2 * acos(0.0);
	for(i=0;i<n;i++)
		cin >> x[i] >> y[i];
	for(i=0;i<n;i++)
		cin >> xx[i] >> yy[i];
	double s1 = accumulate(all(x),0);
	double s2 = accumulate(all(y),0);
	s1 = 1.0*s1/n;
	s2 = 1.0*s2/n;
	double xa = 0 - s1;
	double ya = 0 - s2;
	for(i=0;i<n;i++){
		x[i]+=xa;
		y[i]+=ya;
	}
	s1 = accumulate(all(xx),0);
	s2 = accumulate(all(yy),0);
	s1 = 1.0*s1/n;
	s2 = 1.0*s2/n;
	xa = 0 - s1;
	ya = 0 - s2;
	for(i=0;i<n;i++){
		xx[i]+=xa;
		yy[i]+=ya;
	}
	vector<pair<double,double>> p2;
	for(i=0;i<n;i++){
		p2.pb({xx[i],yy[i]});
	}
	sort(all(p2),cmp);
	double p = 0,cx,cy;
	while(p < 360){
		vector<pair<double,double>> p1;
		double radi = (p*pii)/180;
		for(i=0;i<n;i++){
			cx = x[i];
			cy = y[i];
			y[i] = cy*cos(radi) - cx*sin(radi);
			x[i] = cy*sin(radi) + cx*cos(radi);
		}
		for(i=0;i<n;i++){
			p1.pb({x[i],y[i]});
		}
		sort(all(p1),cmp);
		bool ok  = true;
		for(i=0;i<n;i++){
			double cxx = p1[i].F;
			double cyy = p1[i].S;
			double tcxx = p2[i].F;
			double tcyy = p2[i].S;
			if(abs(tcxx-cxx) < eps && abs(cyy-tcyy) < eps)
				continue;
			else{
				ok = false;
				break;
			}
		}
		if(ok){
			cout<<"Yes";
			return;
		}
		p+=0.001;
	}
	cout<<"No";
}
 
int main(){
	fast;
	int t=1;
	while(t--){
		run_case();
	}
}

P is prefix sum.

dp[i][j] denotes number of subsequences uptil index i such that we can split it into j blocks.

Then this transition is straightforward but sadly its O(n^3) so I didnt bother to code and was thinking of optimizing it the whole time.

dp[i][j] += ((P[i] — P[x])%j == 0 ? dp[x][j-1] : 0) over all x from 1 to i-1