这是最快的一个

#include<iostream>
#include<cstdio>
#include<bitset>

using namespace std;

int n,g[102][2],cnt;
bitset<1000006> f;

int main(){
	scanf("%d",&n);
	for (int i=1;i<=n;i++){
		scanf("%d%d",&g[i][0],&g[i][1]);
		g[i][0]=g[i][0]*g[i][0];
		g[i][1]=g[i][1]*g[i][1];
	}
	f[0]=1;
	for (int i=1;i<=n;i++){
		f=(f<<g[i][0])|(f<<g[i][1]);
	}
	printf("%d",f.count());
	return 0;
}

没什么好讲的，这里放一个bitset的做法

const ll N = 1e6+10;
ll n, x, y;
bitset <N> f(1);
void work()
{
  cin>>n;
  for (ll i=1; i<=n; i++) {
    cin>>x>>y;
    f = (f<<(x*x))|(f<<(y*y));
  }
  cout<<f.count();
}

思路比较好想，就是去判每个数能否得到

$f[i][j]$为前$i$个格子是否能得到$j$

$f[0][0] = 1$

$f[i][j] = f[i-1][j-a[i][1]*a[i][1]) | f[i-1][j-a[i][2]*a[i][2])$

然后发现这个东西可以用bitset 优化

第一维可以空间优化掉

然后就做完了

#include <bits/stdc++.h>
using namespace std;

const int N = 101;

int n;

int a[N][3];

bitset<N*N*N> f;

void read() {
	cin >> n;
	for(int i = 1; i <= n; i++) {
		cin >> a[i][1] >> a[i][2];
		a[i][1] *= a[i][1];
		a[i][2] *= a[i][2];
	}
}

void compute() {
	f[0] = 1;
	for(int i = 1; i <= n; i++) f = ((f<<a[i][1]) | (f<<a[i][2]));
	cout << f.count();
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	read();
	compute();
	return 0;
}