text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
const int sq = 320;
int n, answer;
set<int> satr[MAXN], sot[MAXN];
set<pair<int, int>> ssatr, ssot;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
satr[x].insert(y);
sot[y].insert(x);
}
for (int i = 0; i < MAXN; i++) {
if (satr[i].size()) {
ssatr.insert({satr[i].size(), i});
}
}
for (int i = 0; i < MAXN; i++) {
if (sot[i].size()) {
ssot.insert({sot[i].size(), i});
}
}
while (ssatr.size()) {
if (ssatr.begin()->first <= sq) {
int ind = ssatr.begin()->second;
ssatr.erase(ssatr.begin());
for (auto i : satr[ind]) {
for (auto j : satr[ind]) {
if (j >= i) {
break;
}
int num = i - j;
if ((num + ind) < MAXN && satr[num + ind].count(i) &&
satr[num + ind].count(j)) {
answer++;
}
if ((ind - num) >= 0 && satr[ind - num].count(i) &&
satr[ind - num].count(j)) {
answer++;
}
}
}
for (auto i : satr[ind]) {
pair<int, int> me = {sot[i].size(), i};
ssot.erase(me);
me.first--;
if (me.first > 0) {
ssot.insert(me);
}
sot[i].erase(ind);
}
satr[ind].clear();
} else {
int ind = ssot.begin()->second;
ssot.erase(ssot.begin());
for (auto i : sot[ind]) {
for (auto j : sot[ind]) {
if (j >= i) {
break;
}
int num = i - j;
if ((num + ind) < MAXN && sot[num + ind].count(i) &&
sot[num + ind].count(j)) {
answer++;
}
if ((ind - num) >= 0 && sot[ind - num].count(i) &&
sot[ind - num].count(j)) {
answer++;
}
}
}
for (auto i : sot[ind]) {
pair<int, int> me = {satr[i].size(), i};
ssatr.erase(me);
me.first--;
if (me.first > 0) {
ssatr.insert(me);
}
satr[i].erase(ind);
}
sot[ind].clear();
}
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > h[100002];
vector<int> a[100002];
vector<int> xx;
vector<int> block;
bool v[100002];
bool mark[100002];
int n, bm, xn, ans;
int solveBlock(int i, int j) {
i = xx[i];
j = xx[j];
int delta = j - i, s = 0;
int q = 0, pp = 0, qq = 0;
for (int p = 0; p < a[i].size(); ++p) {
while (q < a[j].size() && a[j][q] < a[i][p]) ++q;
if (q > a[j].size()) break;
if (a[i][p] == a[j][q]) {
while (pp < a[i].size() && a[i][pp] < a[i][p] + delta) ++pp;
if (pp > a[i].size()) break;
while (qq < a[j].size() && a[j][qq] < a[j][q] + delta) ++qq;
if (qq > a[j].size()) break;
if (a[i][pp] == a[i][p] + delta && a[j][qq] == a[j][q] + delta) ++s;
}
}
return s;
}
int main() {
int i, j, x, y, p, q;
scanf("%d", &n);
bm = sqrt(n);
for (i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
xx.push_back(x);
}
sort(xx.begin(), xx.end());
xn = unique(xx.begin(), xx.end()) - xx.begin();
for (i = 0; i < xn; ++i) {
j = xx[i];
sort(a[j].begin(), a[j].end());
if (a[j].size() >= bm) {
v[i] = 1;
block.push_back(i);
}
}
for (i = 0; i < block.size(); ++i)
for (j = i + 1; j < block.size(); ++j)
ans += 2 * solveBlock(block[i], block[j]);
for (i = 0; i < xn; ++i)
if (!v[i]) {
j = xx[i];
for (p = 0; p < a[j].size(); ++p)
for (q = p + 1; q < a[j].size(); ++q) {
int delta = a[j][q] - a[j][p];
if (j - delta >= 0 && a[j - delta].size())
h[j - delta].push_back(pair<int, int>(a[j][p], a[j][q]));
if (j + delta < 100002 && a[j + delta].size())
h[j + delta].push_back(pair<int, int>(a[j][p], a[j][q]));
}
}
for (i = 0; i < xn; ++i) {
j = xx[i];
for (p = 0; p < a[j].size(); ++p) mark[a[j][p]] = 1;
for (p = 0; p < h[j].size(); ++p)
if (mark[h[j][p].first] && mark[h[j][p].second]) {
if (v[i])
ans += 2;
else
++ans;
}
for (p = 0; p < a[j].size(); ++p) mark[a[j][p]] = 0;
}
printf("%d\n", ans / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int r = 1;
x = x % p;
while (y) {
if (y & 1) r = r * x % p;
y = y >> 1;
x = x * x % p;
}
return r;
}
const int N = 1e5 + 99;
vector<pair<int, int> > Points(N);
unordered_set<int> X[N], Y[N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> Points[i].first >> Points[i].second;
X[Points[i].first].insert(Points[i].second);
Y[Points[i].second].insert(Points[i].first);
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
int x = Points[i].first, y = Points[i].second;
if (X[x].size() <= Y[y].size()) {
for (auto yy : X[x]) {
if (yy - y <= 0) continue;
int ss = yy - y;
if (Y[yy].count(x + ss) && Y[y].count(x + ss)) ans++;
}
continue;
}
for (auto xx : Y[y]) {
if (xx - x <= 0) continue;
int ss = xx - x;
if (X[xx].count(y + ss) && X[x].count(y + ss)) ans++;
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
vector<int> p[MAXN];
vector<int> q[MAXN];
vector<pair<int, int> > points;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
p[x].push_back(y);
q[y].push_back(x);
points.push_back({x, y});
}
for (int i = 0; i < MAXN; i++) {
sort(p[i].begin(), p[i].end());
sort(q[i].begin(), q[i].end());
}
long long ans = 0;
for (auto point : points) {
int x = point.first;
int y = point.second;
if (p[x].size() <= q[y].size()) {
for (auto concha : p[x]) {
if (concha == y)
break;
else if (x - y + concha < 0)
continue;
int r =
upper_bound(p[x - y + concha].begin(), p[x - y + concha].end(), y) -
lower_bound(p[x - y + concha].begin(), p[x - y + concha].end(), y);
int s = upper_bound(p[x - y + concha].begin(), p[x - y + concha].end(),
concha) -
lower_bound(p[x - y + concha].begin(), p[x - y + concha].end(),
concha);
if (r > 0 && s > 0) ans++;
}
} else {
for (auto x1 : q[y]) {
if (x1 == x)
break;
else if (y - x + x1 < 0)
continue;
int r = upper_bound(q[y - x + x1].begin(), q[y - x + x1].end(), x) -
lower_bound(q[y - x + x1].begin(), q[y - x + x1].end(), x);
int s = upper_bound(q[y - x + x1].begin(), q[y - x + x1].end(), x1) -
lower_bound(q[y - x + x1].begin(), q[y - x + x1].end(), x1);
if (r > 0 && s > 0) ans++;
}
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long hsh(long long a, long long b) { return a * 1e7 + b; }
int main() {
int n;
while (cin >> n) {
int sq = int(sqrt(n) + 1e-6);
map<int, vector<int> > x, y;
unordered_map<long long, bool> p;
for (int i = 0; i < n; i++) {
int tx, ty;
scanf("%d %d", &tx, &ty);
x[tx].push_back(ty);
y[ty].push_back(tx);
p[hsh(tx, ty)] = 1;
}
for (map<int, vector<int> >::iterator it = x.begin(); it != x.end(); it++)
sort(it->second.begin(), it->second.end());
for (map<int, vector<int> >::iterator it = y.begin(); it != y.end(); it++)
sort(it->second.begin(), it->second.end());
int res = 0;
for (map<int, vector<int> >::iterator it = x.begin(); it != x.end(); it++) {
if (it->second.size() < sq) {
for (int i = 0; i < it->second.size(); i++) {
int x1 = it->first, y1 = it->second[i];
for (int j = i + 1; j < it->second.size(); j++) {
int y2 = it->second[j], l = y2 - y1;
if (p[hsh(x1 + l, y1)] && p[hsh(x1 + l, y2)]) res++;
}
}
} else {
for (int i = 0; i < it->second.size(); i++) {
int x1 = it->first, y1 = it->second[i];
for (int j =
upper_bound(y[y1].begin(), y[y1].end(), x1) - y[y1].begin();
j < y[y1].size(); j++) {
int x2 = y[y1][j], l = x2 - x1;
if (p[hsh(x1, y1 + l)] && p[hsh(x2, y1 + l)]) res++;
}
}
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
int n;
struct Point {
int x, y;
bool operator<(const Point &rhs) const {
if (y == rhs.y)
return x < rhs.x;
else
return y < rhs.y;
}
} a[N];
set<pair<int, int> > st;
vector<int> X[N];
vector<int> Y[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
sort(a + 1, a + 1 + n);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (X[a[i].x].size() < Y[a[i].y].size()) {
for (int j = 0; j < X[a[i].x].size(); j++) {
int len = a[i].y - X[a[i].x][j];
if (st.count(make_pair(a[i].x - len, a[i].y)) &&
st.count(make_pair(a[i].x - len, a[i].y - len)))
ans++;
}
} else {
for (int j = 0; j < Y[a[i].y].size(); j++) {
int len = a[i].x - Y[a[i].y][j];
if (st.count(make_pair(a[i].x, a[i].y - len)) &&
st.count(make_pair(a[i].x - len, a[i].y - len)))
ans++;
}
}
st.insert(make_pair(a[i].x, a[i].y));
X[a[i].x].push_back(a[i].y);
Y[a[i].y].push_back(a[i].x);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int x[maxn], y[maxn];
unordered_set<int> row[maxn], col[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
row[x[i]].insert(y[i]);
col[y[i]].insert(x[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (row[x[i]].size() < col[y[i]].size()) {
for (int u : row[x[i]]) {
if ((u > y[i]) && (x[i] + u - y[i] < maxn - 5) &&
(row[x[i] + u - y[i]].find(y[i]) != row[x[i]].end()) &&
(row[x[i] + u - y[i]].find(u) != row[x[i]].end()))
ans++;
}
} else {
for (int u : col[y[i]]) {
if ((u > x[i]) && (y[i] + u - x[i] < maxn - 5) &&
(col[y[i] + u - x[i]].find(x[i]) != col[y[i]].end()) &&
(col[y[i] + u - x[i]].find(u) != col[y[i]].end()))
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int sqrtmaxn = (int)sqrt(maxn) + 1;
vector<int> v[maxn];
int ans;
inline bool find(int x, int y) {
if (x >= maxn) return false;
return binary_search(v[x].begin(), v[x].end(), y);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
}
for (int i = 0; i < maxn; i++) sort(v[i].begin(), v[i].end());
for (int x = 0; x < maxn; x++) {
if (v[x].size() < sqrtmaxn) {
for (int i = 0; i < v[x].size(); i++) {
for (int j = i + 1; j < v[x].size(); j++) {
int d = v[x][j] - v[x][i];
if (find(x + d, v[x][i]) && find(x + d, v[x][j])) ans++;
}
}
} else {
for (int xx = x + 1; xx < maxn; xx++) {
for (int i = 0; i < v[xx].size(); i++) {
int yy = v[xx][i], d = xx - x;
if (find(x, yy) && find(x, yy + d) && find(xx, yy + d)) ans++;
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans, sq = 335;
bool hv[100005];
map<int, bool> m[100005];
vector<int> v[100005], h;
bool ck(int x, int y, int dis) {
return (m[x].count(y + dis) && m[x + dis].count(y) &&
m[x + dis].count(y + dis));
}
bool Smallck(int x, int y, int dis) {
return (m[x + dis].count(y) && m[x + dis].count(y + dis));
}
bool SmallCk(int x, int y, int dis) {
return (m[x - dis].count(y) && m[x - dis].count(y + dis));
}
void BigBitch(int x) {
for (int i = 0; i < h.size(); i++) {
if (h[i] <= x) continue;
for (int j = 0; j < v[x].size(); j++) {
int poy = v[x][j];
ans += ck(x, poy, h[i] - x);
}
}
}
void SmallBitch(int x) {
for (int i = 0; i < v[x].size(); i++) {
for (int j = i + 1; j < v[x].size(); j++) {
int y1 = v[x][i], y2 = v[x][j];
int dis = abs(y2 - y1);
if (x + dis <= 1e5) ans += Smallck(x, min(y2, y1), dis);
if (x >= dis) {
if (hv[x - dis]) ans += SmallCk(x, min(y2, y1), dis);
}
}
}
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
m[x][y] = 1;
}
for (int i = 0; i <= 1e5; i++) {
if (v[i].size() >= sq) {
hv[i] = 1;
h.push_back(i);
}
}
for (int i = 0; i <= 1e5; i++) {
if (hv[i])
BigBitch(i);
else
SmallBitch(i);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
namespace std {
template <>
struct hash<pair<int, int> > {
int operator()(pair<int, int> a) const { return a.first * 100001 + a.second; }
};
} // namespace std
unordered_map<pair<int, int>, int> m1;
vector<int> b;
vector<int> a[110000];
int n, m, ans;
int main() {
int i, j, k, x, y, d;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
m1[pair<int, int>(x, y)] = 1;
}
m = sqrt(n);
for (i = 0; i <= 100000; i++)
if (a[i].size() >= m) b.push_back(i);
for (i = 0; i < b.size(); i++)
for (j = i + 1; j < b.size(); j++) {
d = b[j] - b[i];
x = b[i];
for (k = 0; k < a[x].size(); k++) {
y = a[x][k];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x, y + d)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
}
}
for (i = 0; i <= 100000; i++)
if (a[i].size() < m) {
sort(a[i].begin(), a[i].end());
x = i;
for (j = 0; j < a[x].size(); j++) {
y = a[x][j];
for (k = j + 1; k < a[x].size(); k++) {
d = a[x][k] - a[x][j];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
if (x - d >= 0 && a[x - d].size() >= m)
if (m1.count(pair<int, int>(x - d, y)) &&
m1.count(pair<int, int>(x - d, y + d)))
ans++;
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> X[100005], Y[100005];
int point[200005][2];
unordered_set<long long> all;
long long Make_pair(long long a, long long b) {
if (a < 0 || b < 0) return -1;
return a * 100005ll + b;
}
int main() {
int ans = 0, i, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &point[i][0]);
scanf("%d", &point[i][1]);
X[point[i][0]].push_back(point[i][1]);
Y[point[i][1]].push_back(point[i][0]);
all.insert(Make_pair(point[i][0], point[i][1]));
}
for (i = 0; i < 100005; i++) {
sort(X[i].begin(), X[i].end());
sort(Y[i].begin(), Y[i].end());
}
for (i = 0; i < n; i++) {
int x = point[i][0], y = point[i][1];
if (X[x].size() < Y[y].size()) {
for (int j = 0; j < X[x].size() && X[x][j] < y; j++) {
if (all.find(Make_pair(x - y + X[x][j], y)) != all.end() &&
all.find(Make_pair(x - y + X[x][j], X[x][j])) != all.end())
ans++;
}
} else {
for (int j = 0; j < Y[y].size() && Y[y][j] < x; j++) {
if (all.find(Make_pair(x, y - x + Y[y][j])) != all.end() &&
all.find(Make_pair(Y[y][j], y - x + Y[y][j])) != all.end())
ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> p[100005];
set<int> x[100005], y[100005];
bool BS(pair<int, int> t, int l, int r) {
while (l <= r) {
int mid = (l + r) >> 1;
if (t < p[mid]) {
r = mid - 1;
} else if (t > p[mid]) {
l = mid + 1;
} else {
return 1;
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
x[p[i].first].insert(p[i].second);
y[p[i].second].insert(p[i].first);
}
sort(p + 1, p + 1 + n);
int ans = 0;
for (int i = 1; i <= n; i++) {
set<int>::iterator j = y[p[i].second].upper_bound(p[i].first);
set<int>::iterator k = x[p[i].first].upper_bound(p[i].second);
while (j != y[p[i].second].end() && k != x[p[i].first].end()) {
if (*j - p[i].first < *k - p[i].second) {
j++;
} else if (*j - p[i].first > *k - p[i].second) {
k++;
} else {
if (BS(make_pair(*j, *k), 1, n)) {
ans++;
}
j++;
k++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_set<long long> s;
vector<long long> v[1000005 + 5], mult, putin;
long long n, rad, sol;
int main() {
cin >> n;
rad = sqrt(n);
for (long long i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
s.insert(x * 1000000LL + y);
}
for (long long i = 0; i <= 1000005; i++)
if (v[i].size() > 0) {
sort(v[i].begin(), v[i].end());
if (v[i].size() > rad)
mult.push_back(i);
else
putin.push_back(i);
}
for (auto it : putin)
for (long long i = 0; i < v[it].size(); i++)
for (long long j = i + 1; j < v[it].size(); j++) {
long long l = v[it][j] - v[it][i];
if (s.count((it + l) * 1000000LL + v[it][j]) &&
s.count((it + l) * 1000000LL + v[it][i]))
sol++;
if (it - l >= 0 && v[it - l].size() > rad &&
s.count((it - l) * 1000000LL + v[it][j]) &&
s.count((it - l) * 1000000LL + v[it][i]))
sol++;
}
for (long long i = 0; i < mult.size(); i++)
for (long long j = i + 1; j < mult.size(); j++) {
long long l = mult[j] - mult[i];
for (auto it : v[mult[i]])
if (s.count(mult[i] * 1000000LL + it + l) &&
s.count(mult[j] * 1000000LL + it) &&
s.count(mult[j] * 1000000LL + it + l))
sol++;
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int XX = 1e5 + 10;
const int NX = 1e5 + 10;
struct point {
int x, y;
point() {}
point(int x, int y) : x(x), y(y) {}
} P[NX];
vector<int> X[XX], Y[XX];
unordered_set<int> USX[XX];
int N;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d %d", &P[i].x, &P[i].y);
int x = P[i].x;
int y = P[i].y;
X[x].push_back(y);
Y[y].push_back(x);
USX[x].insert(y);
}
for (int i = 0; i < XX; i++) {
sort(X[i].begin(), X[i].end());
sort(Y[i].begin(), Y[i].end());
}
long long ans = 0;
for (int i = 1; i <= N; i++) {
int x = P[i].x, y = P[i].y;
int low_x = lower_bound(Y[y].begin(), Y[y].end(), x) - Y[y].begin();
int low_y = lower_bound(X[x].begin(), X[x].end(), y) - X[x].begin();
if (low_x < low_y) {
for (int i = 0; i < low_x; i++) {
int x2 = Y[y][i];
int dist = x - x2;
if (USX[x2].count(y - dist) && USX[x].count(y - dist)) ans++;
}
} else {
for (int i = 0; i < low_y; i++) {
int y2 = X[x][i];
int dist = y - y2;
if (x - dist >= 0 && USX[x - dist].count(y) &&
USX[x - dist].count(y2)) {
ans++;
}
}
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> r[2000000 + 10], c[2000000 + 10];
int n, ans = 0;
int xx[100010], yy[100010];
char buf[5000000], *pt = buf;
inline int getint() {
int x = 0, f = 1;
while ((*pt != '-') && (*pt < '0' || *pt > '9')) pt++;
if (*pt == '-') f = -1, pt++;
while (*pt >= '0' && *pt <= '9') x = x * 10 + *pt++ - 48;
return x * f;
}
int main() {
fread(buf, 1, 5000000, stdin);
n = getint();
int x, y;
int mx = 2000000 + 1, my = 2000000 + 1, maxx = 0, maxy = 0;
for (int i = 1; i <= n; i++) {
xx[i] = getint();
yy[i] = getint();
mx = min(mx, xx[i]);
my = min(my, yy[i]);
}
for (int i = 1; i <= n; i++) {
xx[i] -= mx;
yy[i] -= my;
r[xx[i]].push_back(yy[i]);
c[yy[i]].push_back(xx[i]);
maxx = max(xx[i], maxx);
maxy = max(yy[i], maxy);
}
for (int i = 0; i <= maxx; i++) sort(r[i].begin(), r[i].end());
for (int i = 0; i <= maxy; i++) sort(c[i].begin(), c[i].end());
int ix, iy, tx, ty;
for (int i = 0; i <= maxx; i++) {
for (int j = 0; j < r[i].size(); j++) {
x = i, y = r[i][j];
iy = j + 1,
ix = lower_bound(c[y].begin(), c[y].end(), x) - c[y].begin() + 1;
while (ix < c[y].size() && iy < r[x].size()) {
tx = c[y][ix], ty = r[x][iy];
if (tx - x < ty - y)
++ix;
else if (tx - x > ty - y)
++iy;
else {
if (binary_search(r[tx].begin(), r[tx].end(), ty)) ++ans;
++ix;
++iy;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 1e5 + 500;
const int mod = 1e9 + 7;
const int rad = 380;
pair<int, int> inp[maxn];
vector<int> xx[maxn];
vector<int> yy[maxn];
stack<pair<int, int> > xxx[maxn * 4];
stack<pair<int, int> > yyy[maxn * 4];
bool por[maxn * 8];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
xx[x].push_back(y);
inp[i] = make_pair(x, y);
}
int ans = 0;
for (int i = 0; i < maxn; i++) {
if (xx[i].size() < rad) {
for (int j = 0; j < xx[i].size(); j++) {
int y1 = xx[i][j];
for (int k = j + 1; k < xx[i].size(); k++) {
int yy2 = xx[i][k];
xxx[i + abs(y1 - yy2)].push(make_pair(yy2, y1));
}
}
}
for (int j = 0; j < xx[i].size(); j++) {
por[xx[i][j]] = 1;
}
while (!(xxx[i].empty())) {
if (por[xxx[i].top().first] && por[xxx[i].top().second]) {
ans++;
}
xxx[i].pop();
}
for (int j = 0; j < xx[i].size(); j++) {
por[xx[i][j]] = 0;
}
}
for (int i = maxn - 1; i >= 0; i--) {
if (xx[i].size() < rad) {
for (int j = 0; j < xx[i].size(); j++) {
int y1 = xx[i][j];
for (int k = j + 1; k < xx[i].size(); k++) {
int yy2 = xx[i][k];
if (i >= abs(y1 - yy2) && xx[i - abs(y1 - yy2)].size() >= rad) {
xxx[i - abs(y1 - yy2)].push(make_pair(yy2, y1));
}
}
}
}
for (int j = 0; j < xx[i].size(); j++) {
por[xx[i][j]] = 1;
}
while (!(xxx[i].empty())) {
if (por[xxx[i].top().first] && por[xxx[i].top().second]) {
ans++;
}
xxx[i].pop();
}
for (int j = 0; j < xx[i].size(); j++) {
por[xx[i][j]] = 0;
}
}
for (int i = 0; i < n; i++) {
if (xx[inp[i].first].size() >= rad) {
yy[inp[i].second].push_back(inp[i].first);
}
}
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < yy[i].size(); j++) {
int x1 = yy[i][j];
for (int k = j + 1; k < yy[i].size(); k++) {
int x2 = yy[i][k];
yyy[i + abs(x1 - x2)].push(make_pair(x2, x1));
}
}
for (int j = 0; j < yy[i].size(); j++) {
por[yy[i][j]] = 1;
}
while (!(yyy[i].empty())) {
if (por[yyy[i].top().first] & por[yyy[i].top().second]) {
ans++;
}
yyy[i].pop();
}
for (int j = 0; j < yy[i].size(); j++) {
por[yy[i][j]] = 0;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
set<int> xs[N], ys[N];
int x[N], y[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", x + i, y + i);
xs[y[i]].insert(x[i]);
ys[x[i]].insert(y[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
auto a = ys[x[i]].upper_bound(y[i]);
auto b = xs[y[i]].upper_bound(x[i]);
while (a != ys[x[i]].end() && b != xs[y[i]].end()) {
if (*a - y[i] > *b - x[i])
b = xs[y[i]].lower_bound(x[i] + *a - y[i]);
else if (*a - y[i] < *b - x[i])
a = ys[x[i]].lower_bound(y[i] + *b - x[i]);
else {
if (ys[*b].find(*a) != ys[*b].end()) ans++;
a++, b++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ull = unsigned long long;
template <class T>
inline T gcd(T a, T b) {
return !a ? b : gcd(b % a, a);
}
template <class T>
inline T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
mt19937 rnd(time(0));
const int N = 2e5 + 5;
unordered_set<int> lineX[N], lineY[N];
unordered_map<long long, bool> cnt;
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cnt[a[i] * 1ll * 1e6 + b[i]] = 1;
}
for (int i = 0; i < n; i++) {
lineX[b[i]].insert(a[i]);
lineY[a[i]].insert(b[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if ((int)lineX[b[i]].size() < (int)lineY[a[i]].size()) {
int curX = a[i];
for (int nextX : lineX[b[i]]) {
if (nextX - curX > 0) {
ans += (cnt[curX * 1ll * 1e6 + b[i] + (nextX - curX)] &&
cnt[nextX * 1ll * 1e6 + b[i] + (nextX - curX)]);
}
}
} else {
int curY = b[i];
for (int nextY : lineY[a[i]]) {
if (nextY - curY > 0) {
if (lineY[a[i] + (nextY - curY)].count(curY) &&
lineY[a[i] + (nextY - curY)].count(nextY)) {
ans++;
}
}
}
}
}
cout << ans << '\n';
return;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t = 1;
while (t-- > 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 10;
vector<int> hor[MN];
vector<int> ver[MN];
vector<pair<int, int> > crd;
unordered_map<int, int> t[MN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
crd.resize(n);
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
crd[i] = {x, y};
t[x][y] = 1;
hor[y].push_back(x);
ver[x].push_back(y);
}
for (int i = 0; i < MN; ++i) {
sort(hor[i].begin(), hor[i].end());
sort(ver[i].begin(), ver[i].end());
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int x = crd[i].first;
int y = crd[i].second;
vector<int>::iterator it1 = upper_bound(hor[y].begin(), hor[y].end(), x);
vector<int>::iterator it2 = upper_bound(ver[x].begin(), ver[x].end(), y);
if (distance(it1, hor[y].end()) < distance(it2, ver[x].end())) {
for (; it1 != hor[y].end(); ++it1) {
int q = *it1 - x;
if (t[x][y + q] && t[x + q][y + q]) {
++ans;
}
}
} else {
for (; it2 != ver[x].end(); ++it2) {
int q = *it2 - y;
if (t[x + q][y] && t[x + q][y + q]) ++ans;
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e5;
const int max_x = 1e5;
int n, sqn;
pair<int, int> p[max_n];
int marked[max_n];
vector<vector<int> > a;
int ans = 0;
bool is_point(int x, int y) {
if (a[x].empty()) return false;
int lf = 0, rg = a[x].size() - 1;
while (lf <= rg) {
int md = (lf + rg) >> 1;
int id = a[x][md];
if (p[id].second == y) return true;
if (p[id].second < y) {
lf = md + 1;
} else {
rg = md - 1;
}
}
return false;
}
void find_ans() {
sort(p, p + n);
memset(marked, 0, sizeof(marked));
a.clear();
a.resize(max_x + 1);
for (int i = 0; i < n; ++i) a[p[i].first].push_back(i);
sqn = sqrt(n);
for (int i = 0; i <= max_x; ++i) {
int sz = a[i].size();
if (sz <= sqn) {
for (int i1 = 0; i1 < sz; ++i1)
for (int i2 = i1 + 1; i2 < sz; ++i2) {
int id1 = a[i][i1];
int id2 = a[i][i2];
int y1 = p[id1].second;
int y2 = p[id2].second;
int d = y2 - y1;
if (i - d >= 0) {
if ((int)a[i - d].size() > sqn) {
if (is_point(i - d, y1) && is_point(i - d, y2)) ++ans;
}
}
if (i + d <= max_x) {
if (is_point(i + d, y1) && is_point(i + d, y2)) ++ans;
}
}
for (int j = 0; j < sz; ++j) marked[a[i][j]] = 1;
}
}
int nn = n;
n = 0;
for (int i = 0; i < nn; ++i)
if (!marked[i]) {
p[n] = p[i];
++n;
}
}
int main() {
scanf("%d", &n);
sqn = sqrt(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &p[i].first, &p[i].second);
}
find_ans();
for (int i = 0; i < n; ++i) swap(p[i].first, p[i].second);
find_ans();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100020;
struct point {
int x, y, z;
void init() {
scanf("%d %d", &x, &y);
z = x - y;
}
} p[MAXN];
typedef int arr32[MAXN];
arr32 X, Y, Z, xp, yp, zp;
int n, xt, yt, zt;
bool cmp(const int& a, const int& b) {
return xp[a] < xp[b] || (xp[a] == xp[b] && yp[a] < yp[b]);
}
struct Link {
int next[MAXN];
vector<int> e[MAXN];
int N;
void insert(int x, int pos) { e[x].push_back(pos); }
void build(int Sz) {
N = Sz;
for (int i = 1; i <= N; i++) {
sort(e[i].begin(), e[i].end(), cmp);
for (unsigned int j = 0; j + 1 < e[i].size(); j++)
next[e[i][j]] = e[i][j + 1];
}
}
} xk, yk, zk;
int dist(int a, int b) { return max(p[a].x - p[b].x, p[a].y - p[b].y); }
int ans;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
p[i].init(), X[i] = p[i].x, Y[i] = p[i].y, Z[i] = p[i].z;
sort(X + 1, X + n + 1);
xt = unique(X + 1, X + n + 1) - X - 1;
sort(Y + 1, Y + n + 1);
yt = unique(Y + 1, Y + n + 1) - Y - 1;
sort(Z + 1, Z + n + 1);
zt = unique(Z + 1, Z + n + 1) - Z - 1;
for (int i = 1; i <= n; i++) {
xp[i] = lower_bound(X + 1, X + xt + 1, p[i].x) - X;
yp[i] = lower_bound(Y + 1, Y + yt + 1, p[i].y) - Y;
zp[i] = lower_bound(Z + 1, Z + zt + 1, p[i].z) - Z;
xk.insert(xp[i], i);
yk.insert(yp[i], i), zk.insert(zp[i], i);
}
xk.build(xt), yk.build(yt), zk.build(zt);
for (int i = 1; i <= n; i++) {
int xv = xk.next[i], yv = yk.next[i], zv = zk.next[i];
int xd = dist(xv, i), yd = dist(yv, i), zd = dist(zv, i);
for (; xv && yv && zv;) {
if (xd == yd && yd == zd) ans++;
if (xd < yd && xd < zd)
xv = xk.next[xv], xd = dist(xv, i);
else if (yd < zd)
yv = yk.next[yv], yd = dist(yv, i);
else
zv = zk.next[zv], zd = dist(zv, i);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100001];
int b[100001], gs[100001];
bool c[501][100001];
int K = 200;
bool cx(int x, int y) {
if (x < 0 || x > 100000 || y < 0 || y > 100000) return 0;
if (g[x].size() <= K) {
vector<int>::iterator o = lower_bound(g[x].begin(), g[x].end(), y);
return o != g[x].end() && *o == y;
} else
return c[gs[x]][y];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1, x, y; i <= n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
}
int ans = 0;
for (int i = 0; i <= 100000; i++) {
sort(g[i].begin(), g[i].end());
if (g[i].size() > K) {
b[++b[0]] = i;
gs[i] = b[0];
for (int j = 0; j < g[i].size(); j++) c[b[0]][g[i][j]] = 1;
}
}
for (int i = 0; i <= 100000; i++)
if (g[i].size() <= K)
for (int j = 0; j < g[i].size(); j++)
for (int k = j + 1, l; k < g[i].size(); k++) {
l = g[i][k] - g[i][j];
if (cx(i - l, g[i][j]) && cx(i - l, g[i][k])) ans++;
}
else
for (int j = 0; j < i; j++)
for (int k = 0, l; k < g[j].size(); k++) {
l = i - j;
if (cx(i, g[j][k]) && cx(j, g[j][k] + l) && cx(i, g[j][k] + l)) ans++;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
inline string get() {
char ch[2000010];
scanf("%s", ch);
return ch;
}
inline void read(int *a, int n) {
for (int i = 0; i < n; i++) a[i] = in();
}
template <class blank>
inline void out(blank x) {
cout << x << "\n";
exit(0);
}
const int maxn = 1e5 + 10;
const int maxm = 1e6 + 10;
const int maxlg = 21;
const int base = 29;
const int mod = 1e9 + 7;
const long long INF = 1e18 + 10;
const int SQ = 317 + 5;
unordered_set<int> exist[maxn];
inline bool checkexist(int x, int y) {
return x < maxn && x >= 0 && exist[x].count(y);
}
set<int> columns[maxn], rows[maxn];
long long res;
int32_t main() {
int n = in();
int sq = sqrt(n);
for (int i = 0; i < n; i++) {
int x = in(), y = in();
rows[x].insert(y);
columns[y].insert(x);
exist[x].insert(y);
}
for (int i = 0; i < maxn; i++) {
if (rows[i].size() < sq) {
for (set<int>::iterator it = rows[i].begin(); it != rows[i].end(); it++) {
for (set<int>::iterator it2 = rows[i].begin(); it2 != rows[i].end();
it2++) {
if (*it2 <= *it) continue;
int len = *it2 - *it;
pair<int, int> A = {i, *it}, B = {i, *it2}, C = {i + len, A.second},
D = {i + len, B.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
C = {i - len, A.second}, D = {i - len, B.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
}
}
for (set<int>::iterator it = rows[i].begin(); it != rows[i].end(); it++) {
exist[i].erase(*it);
columns[*it].erase(i);
}
rows[i].clear();
}
}
for (int i = 0; i < maxn; i++) {
if (columns[i].size() < sq) {
for (set<int>::iterator it = columns[i].begin(); it != columns[i].end();
it++) {
for (set<int>::iterator it2 = columns[i].begin();
it2 != columns[i].end(); it2++) {
if (*it2 <= *it) continue;
pair<int, int> A = {*it, i}, B = {*it2, i}, C = {*it, i + *it2 - *it},
D = {*it2, C.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
C = {*it, i - (*it2 - *it)}, D = {*it2, C.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
}
}
for (set<int>::iterator it = columns[i].begin(); it != columns[i].end();
it++) {
exist[*it].erase(i);
rows[*it].erase(i);
}
columns[i].clear();
}
}
for (int i = 0; i < maxn; i++) {
for (set<int>::iterator it = rows[i].begin(); it != rows[i].end(); it++) {
for (set<int>::iterator it2 = rows[i].begin(); it2 != rows[i].end();
it2++) {
if (*it2 <= *it) continue;
int len = *it2 - *it;
pair<int, int> A = {i, *it}, B = {i, *it2}, C = {i + len, A.second},
D = {i + len, B.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
C = {i - len, A.second}, D = {i - len, B.second};
if (checkexist(C.first, C.second) && checkexist(D.first, D.second))
res++;
}
}
for (set<int>::iterator it = rows[i].begin(); it != rows[i].end(); it++) {
exist[i].erase(*it);
columns[*it].erase(i);
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int x[maxn], y[maxn];
vector<int> xs[maxn], ys[maxn];
vector<pair<int, int> > al;
inline bool isin(int p, int q) {
int pos = lower_bound(al.begin(), al.end(), make_pair(p, q)) - al.begin();
return (pos < al.size() && al[pos] == make_pair(p, q));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
xs[x[i]].push_back(y[i]);
ys[y[i]].push_back(x[i]);
al.push_back({x[i], y[i]});
}
sort(al.begin(), al.end());
for (int i = 0; i < maxn; i++)
sort(xs[i].begin(), xs[i].end()), sort(ys[i].begin(), ys[i].end());
int ans = 0;
for (int i = 0; i < n; i++) {
int p = x[i], q = y[i];
int t1 = lower_bound(xs[p].begin(), xs[p].end(), q) - xs[p].begin();
int t2 = lower_bound(ys[q].begin(), ys[q].end(), p) - ys[q].begin();
int len1 = xs[p].size() - t1;
int len2 = ys[q].size() - t2;
if (len1 < len2) {
for (int j = t1 + 1; j < xs[p].size(); j++) {
int q2 = xs[p][j];
ans += (isin(p + q2 - q, q) && isin(p + q2 - q, q2));
}
} else {
for (int j = t2 + 1; j < ys[q].size(); j++) {
int p2 = ys[q][j];
ans += (isin(p, q + p2 - p) && isin(p2, q + p2 - p));
}
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, dif;
};
struct point a[111111];
int cmp(point p1, point p2) {
if (p1.dif > p2.dif) return 1;
return 0;
}
set<int> wasX[111111];
set<int> wasY[111111];
set<int> wasD[222222];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
a[i].dif = a[i].x - a[i].y;
}
sort(a, a + n, cmp);
int ans = 0;
for (int i = 0; i < n; i++) {
int d = a[i].x + a[i].y;
for (set<int>::iterator it = wasD[d].begin(); it != wasD[d].end(); it++) {
int x1 = *it;
int y1 = d - x1;
if (wasX[x1].find(a[i].y) != wasX[x1].end() &&
wasY[y1].find(a[i].x) != wasY[y1].end())
ans++;
}
wasX[a[i].x].insert(a[i].y);
wasY[a[i].y].insert(a[i].x);
wasD[a[i].x + a[i].y].insert(a[i].x);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
struct sp {
int x, y;
bool operator<(const sp &a) const { return x < a.x || x == a.x && y < a.y; }
bool operator==(const sp &a) const { return x == a.x && y == a.y; }
};
namespace std {
template <>
struct hash<sp> {
size_t operator()(sp a) const { return a.x * 9875321 + a.y; }
};
} // namespace std
unordered_map<sp, int> m1;
vector<int> b;
vector<int> a[110000];
int n, m, ans;
int main() {
int i, j, k, x, y, d;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
m1[sp{x, y}] = 1;
}
m = sqrt(n);
for (i = 0; i <= 100000; i++)
if (a[i].size() >= m) b.push_back(i);
for (i = 0; i < b.size(); i++)
for (j = i + 1; j < b.size(); j++) {
d = b[j] - b[i];
x = b[i];
for (k = 0; k < a[x].size(); k++) {
y = a[x][k];
if (m1.count(sp{x + d, y}) && m1.count(sp{x, y + d}) &&
m1.count(sp{x + d, y + d}))
ans++;
}
}
for (i = 0; i <= 100000; i++)
if (a[i].size() < m) {
sort(a[i].begin(), a[i].end());
x = i;
for (j = 0; j < a[x].size(); j++) {
y = a[x][j];
for (k = j + 1; k < a[x].size(); k++) {
d = a[x][k] - a[x][j];
if (m1.count(sp{x + d, y}) && m1.count(sp{x + d, y + d})) ans++;
if (x - d >= 0 && a[x - d].size() >= m)
if (m1.count(sp{x - d, y}) && m1.count(sp{x - d, y + d})) ans++;
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
namespace std {
template <>
struct hash<pair<int, int> > {
long long operator()(pair<int, int> a) const {
return a.first * 100000000LL + a.second;
}
};
} // namespace std
unordered_map<pair<int, int>, int> m1;
vector<int> b;
vector<int> a[110000];
int n, m, ans;
int main() {
int i, j, k, x, y, d;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
m1[pair<int, int>(x, y)] = 1;
}
m = sqrt(n);
for (i = 0; i <= 100000; i++)
if (a[i].size() >= m) b.push_back(i);
for (i = 0; i < b.size(); i++)
for (j = i + 1; j < b.size(); j++) {
d = b[j] - b[i];
x = b[i];
for (k = 0; k < a[x].size(); k++) {
y = a[x][k];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x, y + d)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
}
}
for (i = 0; i <= 100000; i++)
if (a[i].size() < m) {
sort(a[i].begin(), a[i].end());
x = i;
for (j = 0; j < a[x].size(); j++) {
y = a[x][j];
for (k = j + 1; k < a[x].size(); k++) {
d = a[x][k] - a[x][j];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
if (x - d >= 0 && a[x - d].size() >= m)
if (m1.count(pair<int, int>(x - d, y)) &&
m1.count(pair<int, int>(x - d, y + d)))
ans++;
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> x[100100], y[100100];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
int a, b;
scanf("%d%d", &a, &b);
x[a].push_back(b);
y[b].push_back(a);
}
for (int i = 0; i <= 100000; i++) {
sort(x[i].begin(), x[i].end());
sort(y[i].begin(), y[i].end());
}
int sum = 0;
for (int i = 0; i <= 100000; i++)
for (int j = 0; j < x[i].size(); j++) {
int tx = i, ty = x[i][j], px = j + 1;
int py = upper_bound(y[ty].begin(), y[ty].end(), tx) - y[ty].begin();
while (px < x[tx].size() && py < y[ty].size()) {
if (x[tx][px] - ty < y[ty][py] - tx) {
px++;
continue;
}
if (x[tx][px] - ty > y[ty][py] - tx) {
py++;
continue;
}
sum +=
binary_search(x[y[ty][py]].begin(), x[y[ty][py]].end(), x[tx][px]);
px++;
py++;
}
}
printf("%d", sum);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x += _y;
return _x >= _mod ? _x - _mod : _x;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x -= _y;
return _x < 0 ? _x + _mod : _x;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x *= _y;
return _x >= _mod ? _x % _mod : _x;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1LL;
long long _ret = mypow(mul(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = mul(_ret, _a, _mod);
return _ret;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0LL;
long long _ret = mymul(add(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = add(_ret, _a, _mod);
return _ret;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
void sleep(double sec = 1021) {
clock_t s = clock();
while (clock() - s < CLOCKS_PER_SEC * sec)
;
}
int __ = 1, _cs;
void build() {}
int n;
vector<int> vx[100001], vy[100001];
void init() {
n = getint();
for (int i = 0, x, y; i < n; i++) {
x = getint();
y = getint();
vx[x].push_back(y);
vy[y].push_back(x);
}
for (int i = 0; i < 100001; i++) {
sort(vx[i].begin(), vx[i].end());
sort(vy[i].begin(), vy[i].end());
}
}
int ans;
inline int count(int nx, int ny) {
int x = lower_bound(vx[nx].begin(), vx[nx].end(), ny) - vx[nx].begin();
return x < (int)vx[nx].size() and vx[nx][x] == ny;
}
void solve() {
for (int x = 0; x < 100001; x++)
for (int y : vx[x]) {
size_t xptr = upper_bound(vx[x].begin(), vx[x].end(), y) - vx[x].begin();
size_t yptr = upper_bound(vy[y].begin(), vy[y].end(), x) - vy[y].begin();
while (xptr < vx[x].size() and yptr < vy[y].size()) {
if (vx[x][xptr] - y == vy[y][yptr] - x) {
ans += count(vy[y][yptr], vx[x][xptr]);
xptr++;
yptr++;
} else if (vx[x][xptr] - y < vy[y][yptr] - x)
xptr =
lower_bound(vx[x].begin(), vx[x].end(), y + (vy[y][yptr] - x)) -
vx[x].begin();
else
yptr =
lower_bound(vy[y].begin(), vy[y].end(), x + (vx[x][xptr] - y)) -
vy[y].begin();
}
}
cout << ans << endl;
}
int main() {
build();
while (__--) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int sqrtmaxn = (int)sqrt(maxn) + 1;
vector<int> v[maxn];
int ans;
inline bool find(int x, int y) {
if (x >= maxn) return false;
return binary_search(v[x].begin(), v[x].end(), y);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
}
for (int i = 0; i < maxn; i++) sort(v[i].begin(), v[i].end());
for (int x = 0; x < maxn; x++) {
if (v[x].size() <= sqrtmaxn) {
for (int i = 0; i < v[x].size(); i++) {
for (int j = i + 1; j < v[x].size(); j++) {
int d = v[x][j] - v[x][i];
if (find(x + d, v[x][i]) && find(x + d, v[x][j])) ans++;
}
}
} else {
for (int xx = x + 1; xx < maxn; xx++) {
for (int i = 0; i < v[xx].size(); i++) {
int yy = v[xx][i], d = xx - x;
if (find(x, yy) && find(x, yy + d) && find(xx, yy + d)) ans++;
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct HashMap {
vector<pair<int, int> > g[1000007];
void ins(int x, int y) {
int id = ((long long)x * 1000000007 + y) % 1000007;
g[id].push_back(make_pair(x, y));
}
bool get(int x, int y) {
int id = ((long long)x * 1000000007 + y) % 1000007;
for (int i = 0; i < g[id].size(); i++)
if (g[id][i].first == x && g[id][i].second == y) return true;
return false;
}
};
int n;
HashMap mp;
vector<int> row[100011];
vector<int> rateB;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
row[y].push_back(x);
mp.ins(x, y);
}
int di = (int)sqrt(n);
long long int ans = 0;
for (int a = 0; a <= 100000; a++) {
if (row[a].size() != 0) {
sort(row[a].begin(), row[a].end());
if (row[a].size() <= di) {
for (int i = 0; i < row[a].size(); i++) {
for (int j = i + 1; j < row[a].size(); j++) {
int x1 = row[a][i];
int x2 = row[a][j];
int dis = x2 - x1;
if (mp.get(x1, a + dis) && mp.get(x2, a + dis)) ans++;
if (a - dis >= 0 && row[a - dis].size() > di &&
(mp.get(x1, a - dis) && mp.get(x2, a - dis)))
ans++;
}
}
} else
rateB.push_back(a);
}
}
for (int i = 0; i < rateB.size(); i++) {
for (int j = i + 1; j < rateB.size(); j++) {
int a = rateB[i];
int b = rateB[j];
int u = 0, p = 0;
int dis = b - a;
while (u < row[a].size() && p < row[b].size()) {
if (row[a][u] < row[b][p])
u++;
else if (row[a][u] > row[b][p])
p++;
else {
int x1 = row[a][u];
if (mp.get(x1 + dis, a) && mp.get(x1 + dis, b)) ans++;
u++;
p++;
}
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 2 * 1e5 + 1;
vector<vector<int> > g, g1;
vector<vector<pair<int, int> > > need;
int sqrtn, ans;
vector<int> was;
void Do(vector<vector<int> > &g) {
need.clear();
need.resize(MAXK);
for (int i = 0; i < MAXK; i++) {
if (g[i].size() <= sqrtn && g[i].size() > 1) {
for (int j = 0; j < g[i].size() - 1; j++)
for (int k = j + 1; k < g[i].size(); k++) {
need[i + abs(g[i][j] - g[i][k])].push_back(
make_pair(g[i][j], g[i][k]));
if ((i - abs(g[i][j] - g[i][k]) >= 0) &&
(g[i - abs(g[i][j] - g[i][k])].size() > sqrtn))
need[i - abs(g[i][j] - g[i][k])].push_back(
make_pair(g[i][j], g[i][k]));
}
}
}
was.assign(MAXK, 0);
for (int i = 0; i < MAXK; i++) {
for (int j = 0; j < g[i].size(); j++) was[g[i][j]] = i + 1;
for (int j = 0; j < need[i].size(); j++)
if (was[need[i][j].first] == i + 1 && was[need[i][j].second] == i + 1)
ans++;
if (g[i].size() <= sqrtn) g[i].clear();
}
}
int main() {
int n;
scanf("%i", &n);
sqrtn = sqrt(17.0 + n) + 11;
g.resize(MAXK);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%i%i", &x, &y);
g[x].push_back(y);
}
Do(g);
g1.resize(MAXK);
for (int i = 0; i < MAXK; i++)
for (int j = 0; j < g[i].size(); j++) g1[g[i][j]].push_back(i);
Do(g1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int maximize(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline int minimize(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const int N = 100001, M = 1e7 + 7;
int n, x, y;
long long ans;
vector<int> Vx[N], Vy[N];
int check(int x, int y) {
if (x >= N || y >= N) return 0;
int l = 0, r = Vx[x].size() - 1;
while (l <= r) {
int m = l + r >> 1;
if (Vx[x][m] == y)
return 1;
else if (Vx[x][m] < y)
r = m - 1;
else
l = m + 1;
}
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
Vx[x].push_back(y);
Vy[y].push_back(x);
}
for (int i = 0; i < N; ++i) {
sort(Vx[i].begin(), Vx[i].end(), greater<int>());
sort(Vy[i].begin(), Vy[i].end(), greater<int>());
}
for (int i = 0; i < N; ++i) {
while (Vy[i].size()) {
int x = Vy[i][Vy[i].size() - 1], y = i;
if (Vy[y].size() > Vx[x].size()) {
for (int j = 0; j < Vx[x].size() - 1; ++j) {
int d = Vx[x][j] - y;
if (check(x + d, y) && check(x + d, y + d)) ++ans;
}
} else {
for (int j = 0; j < Vy[y].size() - 1; ++j) {
int d = Vy[y][j] - x;
if (check(x, y + d) && check(x + d, y + d)) ++ans;
}
}
Vy[y].erase(Vy[y].end() - 1);
Vx[x].erase(Vx[x].end() - 1);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> X[N];
vector<int> Y[N];
int main() {
int n;
cin >> n;
vector<pair<int, int>> points;
set<pair<int, int>> s;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
X[x].push_back(y);
Y[y].push_back(x);
points.push_back({x, y});
s.insert({x, y});
}
for (int i = 0; i < N; i++) {
sort(X[i].begin(), X[i].end());
sort(Y[i].begin(), Y[i].end());
}
long long res = 0;
for (auto p : points) {
int x = upper_bound(Y[p.second].begin(), Y[p.second].end(), p.first) -
Y[p.second].begin();
int y = upper_bound(X[p.first].begin(), X[p.first].end(), p.second) -
X[p.first].begin();
while (x < ((int)Y[p.second].size()) && y < ((int)X[p.first].size())) {
if (Y[p.second][x] - p.first == X[p.first][y] - p.second) {
res += s.count({Y[p.second][x], X[p.first][y]});
x++, y++;
} else if (Y[p.second][x] - p.first > X[p.first][y] - p.second) {
y++;
} else {
x++;
}
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
set<int> X[N], Y[N];
bool check(int x, int y) {
if (x < 0 || x >= N || y < 0 || y >= N) return 0;
return X[x].count(y);
}
void erase(int x, int y) {
X[x].erase(y);
Y[y].erase(x);
}
ll ans = 0;
void solvex(int x) {
while (!X[x].empty()) {
int y = *X[x].begin();
erase(x, y);
for (auto y2 : X[x]) {
int len = y2 - y;
if (check(x + len, y) && check(x + len, y + len)) {
ans++;
}
if (check(x - len, y) && check(x - len, y + len)) {
ans++;
}
}
}
}
void solvey(int y) {
while (!Y[y].empty()) {
int x = *Y[y].begin();
erase(x, y);
for (auto x2 : Y[y]) {
int len = x2 - x;
if (check(x, y + len) && check(x + len, y + len)) {
ans++;
}
if (check(x, y - len) && check(x + len, y - len)) {
ans++;
}
}
}
}
int main() {
int n;
scanf("%d", &n);
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i < n; ++i) {
X[x[i]].insert(y[i]);
Y[y[i]].insert(x[i]);
}
for (int i = 0; i < N; ++i) {
if (X[i].size() * X[i].size() <= n) {
solvex(i);
}
}
for (int i = 0; i < N; ++i) {
solvey(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A>
string to_string(A* ptr) {
stringstream ss;
ss << "0x" << std::setw(16) << std::setfill('0') << std::hex
<< (uint64_t)(uintptr_t)ptr;
return ss.str();
}
string to_string(char c) { return ((string) "'" + c) + "'"; }
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int MX = 1e5 + 99;
int n;
int x[MX], y[MX];
bool have(vector<pair<int, int>>& S, int x, int y) {
pair<int, int> xy = {x, y};
return binary_search(S.begin(), S.end(), xy);
}
int solve() {
vector<vector<int>> M_hor(MX), M_ver(MX);
vector<pair<int, int>> S;
S.reserve(n);
for (int i = 0; i < n; i++) {
M_hor[y[i]].push_back(x[i]);
M_ver[x[i]].push_back(y[i]);
S.push_back({x[i], y[i]});
}
for (auto& v : M_hor) sort(v.begin(), v.end());
for (auto& v : M_ver) sort(v.begin(), v.end());
sort(S.begin(), S.end());
int result = 0;
for (int i = 0; i < n; i++) {
int first = x[i], second = y[i];
auto& VHOR = M_hor[second];
auto& VVER = M_ver[first];
auto it_hor = upper_bound(VHOR.begin(), VHOR.end(), first);
auto it_ver = upper_bound(VVER.begin(), VVER.end(), second);
int cnt_hor = (int)(VHOR.end() - it_hor);
int cnt_ver = (int)(VVER.end() - it_ver);
if (cnt_hor <= cnt_ver) {
for (auto it = it_hor; it != VHOR.end(); it++) {
int dx = *it - first;
if (have(S, first, second + dx) && have(S, first + dx, second + dx))
result++;
}
} else {
for (auto it = it_ver; it != VVER.end(); it++) {
int dy = *it - second;
if (have(S, first + dy, second) && have(S, first + dy, second + dy))
result++;
}
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int TTT = 1;
for (int ttt = 0; ttt < TTT; ttt++) {
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
cout << solve() << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, res = 0;
vector<vector<int>> xy, yx;
vector<unordered_set<int>> xyh, yxh;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
xy.assign(1e5 + 1, vector<int>());
yx.assign(1e5 + 1, vector<int>());
xyh.assign(1e5 + 1, unordered_set<int>());
yxh.assign(1e5 + 1, unordered_set<int>());
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
xy[x].push_back(y);
yx[y].push_back(x);
xyh[x].insert(y);
yxh[y].insert(x);
}
for (int i = 0; i <= 1e5; ++i) {
sort(xy[i].begin(), xy[i].end());
sort(yx[i].begin(), yx[i].end());
}
for (int i = 0; i <= 1e5; ++i) {
for (int j = 0; j < (int)xy[i].size(); ++j) {
auto it = upper_bound(yx[xy[i][j]].begin(), yx[xy[i][j]].end(), i);
if ((int)xy[i].size() - i - 1 < yx[xy[i][j]].end() - it) {
for (int k = j + 1; k < (int)xy[i].size(); ++k) {
int sz = xy[i][k] - xy[i][j];
assert(sz > 0);
if (yxh[xy[i][j]].find(i + sz) != yxh[xy[i][j]].end() &&
yxh[xy[i][k]].find(i + sz) != yxh[xy[i][k]].end()) {
res++;
}
}
} else {
for (int k = (it - yx[xy[i][j]].begin()); k < (int)yx[xy[i][j]].size();
++k) {
int sz = yx[xy[i][j]][k] - i;
assert(sz > 0);
if (xyh[i].find(xy[i][j] + sz) != xyh[i].end() &&
xyh[yx[xy[i][j]][k]].find(xy[i][j] + sz) !=
xyh[yx[xy[i][j]][k]].end()) {
res++;
}
}
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000000")
using namespace std;
const long long int INF = 2e9 + 1;
unordered_set<int> isy[100100];
vector<int> yx[100100];
int main() {
int n;
cin >> n;
for (int i = 0; i < (n); i++) {
int x, y;
cin >> x >> y;
yx[y].push_back(x);
isy[x].insert(y);
}
for (int i = 0; i < (100100); i++) {
sort(yx[i].begin(), yx[i].end());
}
long long int ans = 0;
for (int x = 0; x < (100100); x++) {
for (auto it : isy[x]) {
int y = it;
if ((int)(isy[x]).size() < (int)(yx[y]).size()) {
for (auto it2 : isy[x]) {
int d = it2 - y;
if (d > 0) ans += isy[x + d].count(y) && isy[x + d].count(y + d);
}
} else {
for (int j = 0; j < ((int)(yx[y]).size()); j++) {
int d = yx[y][j] - x;
if (d > 0) {
ans += isy[x].count(y + d) && isy[x + d].count(y + d);
}
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
vector<int> row[MAXN], col[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > v(n);
for (int i = 0, ThxDem = n; i < ThxDem; ++i) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
set<pair<int, int> > mp;
for (auto x : v) mp.insert(x);
int ans = 0;
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int x = v[i].first, y = v[i].second;
int p1 = int(row[y].size()) - 1;
int p2 = int(col[x].size()) - 1;
while (p1 >= 0 && p2 >= 0) {
int dx = x - row[y][p1];
int dy = y - col[x][p2];
if (dx < dy)
p1--;
else if (dx > dy)
p2--;
else
ans += mp.count({x - dx, y - dy}), p1--, p2--;
}
row[y].push_back(x);
col[x].push_back(y);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1e5 + 10;
const int N = 2e6 + 10;
unordered_set<int> cx[N], cy[N];
pair<int, int> a[md];
long long res;
int n;
inline int readchar() {
const int N = 1048576;
static char buf[N];
static char *p = buf, *end = buf;
if (p == end) {
if ((end = buf + fread(buf, 1, N, stdin)) == buf) return EOF;
p = buf;
}
return *p++;
}
inline int ReadInt(int *x) {
static char c, neg;
while ((c = readchar()) < '-') {
if (c == EOF) return 0;
}
neg = (c == '-') ? -1 : 1;
*x = (neg == 1) ? c - '0' : 0;
while ((c = readchar()) >= '0') *x = (*x << 3) + (*x << 1) + c - '0';
*x *= neg;
return 1;
}
int main() {
ReadInt(&n);
for (int i = 1; i <= n; i++) {
int x, y;
ReadInt(&x);
ReadInt(&y);
a[i].first = x + 1000000;
a[i].second = y + 1000000;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int x = a[i].first;
int y = a[i].second;
if (cx[x].size() < cy[y].size()) {
unordered_set<int>::iterator it;
for (it = cx[x].begin(); it != cx[x].end(); it++) {
int yy = *it;
int dis = y - yy;
if (x - dis >= 0 && cx[x - dis].count(y) && cx[x - dis].count(yy))
res++;
}
} else {
unordered_set<int>::iterator it;
for (it = cy[y].begin(); it != cy[y].end(); it++) {
int xx = *it;
int dis = x - xx;
if (y - dis >= 0 && cy[y - dis].count(x) && cy[y - dis].count(xx))
res++;
}
}
cx[x].insert(y);
cy[y].insert(x);
}
printf("%I64d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_set<int> st[100007];
bool check(int x1, int x2, int y1, int y2) {
return st[y1].count(x1) && st[y1].count(x2) && st[y2].count(x1) &&
st[y2].count(x2);
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
st[x].insert(y);
}
vector<int> large;
vector<int> small;
long long ans = 0LL;
int s = (int)sqrt(n);
for (int i = (0); i <= (100000); ++i) {
if ((int)st[i].size() > s)
large.emplace_back(i);
else
small.emplace_back(i);
}
for (int i = (0); i <= ((int)large.size() - 1); ++i) {
for (int j = (i + 1); j <= ((int)large.size() - 1); ++j) {
int y1 = large[i];
int y2 = large[j];
if (st[y1].size() > st[y2].size()) swap(y1, y2);
for (__typeof(st[y1].begin()) it = st[y1].begin(); it != st[y1].end();
++it) {
int x1 = *it;
int x2 = x1 - max(y2 - y1, y1 - y2);
if (x2 >= 0) ans += check(x1, x2, y1, y2);
}
}
}
for (int i = (0); i <= ((int)small.size() - 1); ++i) {
int y1 = small[i];
for (__typeof(st[y1].begin()) _x1 = st[y1].begin(); _x1 != st[y1].end();
++_x1) {
for (__typeof(st[y1].begin()) _x2 = st[y1].begin(); _x2 != st[y1].end();
++_x2) {
int x1 = *_x1;
int x2 = *_x2;
if (x1 >= x2) continue;
int y2 = y1 + max(x1 - x2, x2 - x1);
if (y2 >= 0 && y2 < 100007) ans += check(x1, x2, y1, y2);
y2 = y1 - max(x1 - x2, x2 - x1);
if (y2 >= 0 && st[y2].size() > s) ans += check(x1, x2, y1, y2);
}
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int(i) = 0; (i) < (((int)((t).size()))); ++(i)) s << t[i] << " ";
return s;
}
vector<int> p[100007], q[100007];
long long ha(int x, int y) { return 100005LL * (x + 1) + y; }
int main() {
int res = 0;
int(n);
scanf("%d", &(n));
unordered_set<long long> pts;
for (int(i) = 0; (i) < (n); ++(i)) {
int(x), (y);
scanf("%d %d", &(x), &(y));
pts.insert(ha(x, y));
p[x].push_back(y);
}
const int SQ = sqrt(n);
for (int(x) = (0); (x) <= (100000); ++x) {
sort(p[x].begin(), p[x].end());
if (((int)((p[x]).size())) > SQ) {
for (__typeof(p[x].begin()) y = p[x].begin(); y != p[x].end(); y++)
q[*y].push_back(x);
} else {
for (int(i) = 0; (i) < (((int)((p[x]).size()))); ++(i))
for (int(j) = (i + 1); (j) <= (((int)((p[x]).size())) - 1); ++j) {
int y1 = p[x][i], y2 = p[x][j];
int d = y2 - y1;
if (pts.count(ha(x - d, y1)) && pts.count(ha(x - d, y2))) ++res;
if (pts.count(ha(x + d, y1)) && pts.count(ha(x + d, y2))) ++res;
}
for (__typeof(p[x].begin()) y = p[x].begin(); y != p[x].end(); y++)
pts.erase(ha(x, *y));
}
}
for (int(y) = (0); (y) <= (100000); ++y) {
sort(q[y].begin(), q[y].end());
for (int(i) = 0; (i) < (((int)((q[y]).size()))); ++(i))
for (int(j) = (i + 1); (j) <= (((int)((q[y]).size())) - 1); ++j) {
int x1 = q[y][i], x2 = q[y][j];
int d = x2 - x1;
if (pts.count(ha(x1, y - d)) && pts.count(ha(x2, y - d))) ++res;
if (pts.count(ha(x1, y + d)) && pts.count(ha(x2, y + d))) ++res;
}
for (__typeof(q[y].begin()) x = q[y].begin(); x != q[y].end(); x++)
pts.erase(ha(*x, y));
}
pisz(res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long ccn = 1e5 + 1;
vector<long long> byx[ccn];
vector<long long> byy[ccn];
signed main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long long y, x;
cin >> y >> x;
byy[y].push_back(x);
byx[x].push_back(y);
}
for (long long i = 0; i < ccn; i++) {
sort(byx[i].begin(), byx[i].end());
sort(byy[i].begin(), byy[i].end());
}
auto check = [&](long long y, long long x, long long s) {
if (y + s >= ccn) return false;
return binary_search(byy[y].begin(), byy[y].end(), x + s) &&
binary_search(byy[y + s].begin(), byy[y + s].end(), x) &&
binary_search(byy[y + s].begin(), byy[y + s].end(), x + s);
};
long long res = 0;
for (long long y = 0; y < ccn; y++) {
for (auto x : byy[y]) {
long long ly =
byy[y].end() - upper_bound(byy[y].begin(), byy[y].end(), x);
long long lx =
byx[x].end() - upper_bound(byx[x].begin(), byx[x].end(), y);
if (ly < lx) {
for (auto j = upper_bound(byy[y].begin(), byy[y].end(), x);
j != byy[y].end(); j++) {
if (check(y, x, *j - x)) res++;
}
} else {
for (auto j = upper_bound(byx[x].begin(), byx[x].end(), y);
j != byx[x].end(); j++) {
if (check(y, x, *j - y)) res++;
}
}
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
pair<int, int> pt[N];
vector<int> vx[N], vy[N];
set<pair<int, int> > st;
void GetData() {
scanf("%d", &n);
for (int x, y, i = 0; i < n; ++i) {
scanf("%d%d", &x, &y);
vx[x].push_back(y);
vy[y].push_back(x);
st.insert(make_pair(x, y));
pt[i] = make_pair(x, y);
}
}
void Solve() {
int i, j, k, p, q, x, y, ans = 0;
for (i = 0; i < N; ++i) {
if ((int)vx[i].size() > 0) {
sort(vx[i].begin(), vx[i].end());
vx[i].erase(unique(vx[i].begin(), vx[i].end()), vx[i].end());
}
if ((int)vy[i].size() > 0) {
sort(vy[i].begin(), vy[i].end());
vy[i].erase(unique(vy[i].begin(), vy[i].end()), vy[i].end());
}
}
for (i = 0; i < n; ++i) {
x = pt[i].first;
y = pt[i].second;
p = lower_bound(vy[y].begin(), vy[y].end(), x) - vy[y].begin();
q = lower_bound(vx[x].begin(), vx[x].end(), y) - vx[x].begin();
for (j = p - 1, k = q - 1; j >= 0 && k >= 0;) {
if (x - vy[y][j] < y - vx[x][k])
--j;
else if (x - vy[y][j] > y - vx[x][k])
--k;
else {
if (st.find(make_pair(vy[y][j], vx[x][k])) != st.end()) ans++;
--j;
--k;
}
}
}
printf("%d\n", ans);
}
int main() {
GetData();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 0xfffffff;
const long long INF = 1ll << 61;
using namespace std;
vector<int> G[100000 + 55];
int n;
int ans;
void init() {
for (int i = 0; i < 100000 + 55; i++) G[i].clear();
}
bool input() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
G[x].push_back(y);
}
return false;
}
return true;
}
bool find(int x, int y) {
if (x >= 100000 + 55) return false;
return binary_search(G[x].begin(), G[x].end(), y);
}
void cal() {
for (int i = 0; i < 100000 + 55; i++) sort(G[i].begin(), G[i].end());
int sq = sqrt(n * 1.00);
ans = 0;
for (int i = 0; i < 100000 + 55; i++) {
int len = G[i].size();
if (!len) continue;
if (len < sq) {
for (int j = 0; j < len; j++) {
for (int k = j + 1; k < len; k++) {
int d = G[i][k] - G[i][j];
if (find(i + d, G[i][j]) && find(i + d, G[i][k])) ans++;
}
}
} else {
for (int j = i + 1; j < 100000 + 55; j++) {
for (int k = 0; k < G[j].size(); k++) {
int d = j - i;
if (find(i, G[j][k]) && find(j, G[j][k] + d) && find(i, G[j][k] + d))
ans++;
}
}
}
}
}
void output() { printf("%d\n", ans); }
int main() {
while (true) {
init();
if (input()) return 0;
cal();
output();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
struct Point {
int x, y;
Point() {}
Point(int _x, int _y) : x(_x), y(_y) {}
} a[maxn];
int srt;
vector<int> ver[maxn];
int has(vector<int> &a, int b) {
auto it = lower_bound(a.begin(), a.end(), b);
return it != a.end() && *it == b;
}
int work(int &n) {
for (int i = 0; i <= 100000; i++) ver[i].clear();
for (int i = 0; i < n; i++) ver[a[i].x].push_back(a[i].y);
for (int i = 0; i <= 100000; i++) sort(ver[i].begin(), ver[i].end());
int res = 0;
for (int i = 0; i <= 100000; i++)
if (ver[i].size() <= srt) {
for (int u = 0; u < ver[i].size(); u++)
for (int v = u + 1; v < ver[i].size(); v++) {
int y0 = ver[i][u];
int y1 = ver[i][v];
int x0 = i - (y1 - y0);
int x1 = i + (y1 - y0);
if (x0 >= 0) res += has(ver[x0], y0) && has(ver[x0], y1);
if (x1 <= 100000 && ver[x1].size() > srt)
res += has(ver[x1], y0) && has(ver[x1], y1);
}
}
n = 0;
for (int x = 0; x <= 100000; x++)
if (ver[x].size() > srt)
for (auto y : ver[x]) a[n++] = Point(x, y);
return res;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].x >> a[i].y;
srt = (int)(sqrt(n) + 1e-9);
int res = work(n);
for (int i = 0; i < n; i++) swap(a[i].x, a[i].y);
res += work(n);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2> &pair) const {
return ((int)(pair.first * 2654435761ll) << 6) ^
(int)(pair.second * 2654435761ll);
}
};
unordered_set<pair<int, int>, pair_hash> BS;
vector<vector<pair<int, int>>> stupci(100001);
vector<vector<pair<int, int>>> retci(100001);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int LIM = 300;
vector<pair<int, int>> svi;
int n;
cin >> n;
for (int i = 0; i < (n); i++) {
int x, y;
cin >> x >> y;
BS.insert({x, y});
stupci[x].push_back({x, y});
retci[y].push_back({x, y});
svi.push_back({x, y});
}
for (int i = 0; i < (100001); i++) sort(stupci[i].begin(), stupci[i].end());
for (int i = 0; i < (100001); i++) sort(retci[i].begin(), retci[i].end());
long long cnt = 0;
for (pair<int, int> curr : svi) {
if (retci[curr.second].size() <= LIM) {
for (pair<int, int> myPair : retci[curr.second]) {
if (myPair.first > curr.first) {
int dist = myPair.first - curr.first;
if (BS.count({curr.first, curr.second + dist}) &&
BS.count({myPair.first, curr.second + dist}))
cnt++;
}
}
} else {
for (pair<int, int> myPair : stupci[curr.first]) {
if (myPair.second > curr.second) {
int dist = myPair.second - curr.second;
if (BS.count({curr.first + dist, curr.second}) &&
BS.count({myPair.first + dist, myPair.second}))
cnt++;
}
}
}
}
cout << cnt;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int n, x, y, ans, mv, markx[N];
map<pair<int, int>, bool> mark;
pair<int, int> point[N];
vector<int> bx[N], by[N], bxy[N * 2];
bool check_is(pair<int, int> p) {
int l = 0, r = mv, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (point[mid] <= p)
l = mid;
else
r = mid;
}
return (point[l] == p);
}
bool calc(int x, int y, int an) {
int t = max(x - point[an].first, y - point[an].second);
return (check_is(make_pair(x - t, y)) && check_is(make_pair(x, y - t)) &&
check_is(make_pair(x - t, y - t)));
}
void solve(int x, int y, int an) {
int xy = x - y + N;
mv = an;
int mn = min(bxy[xy].size(), min(bx[x].size(), by[y].size()));
if (mn == bx[x].size()) {
for (int i = 0; i < bx[x].size(); i++) ans += calc(x, y, bx[x][i]);
} else if (mn == by[y].size()) {
for (int i = 0; i < by[y].size(); i++) ans += calc(x, y, by[y][i]);
} else {
for (int i = 0; i < bxy[xy].size(); i++) ans += calc(x, y, bxy[xy][i]);
}
bx[x].push_back(an);
by[y].push_back(an);
bxy[xy].push_back(an);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
;
mark[make_pair(x, y)] = 1;
point[i] = make_pair(x, y);
}
sort(point, point + n);
for (int i = 0; i < n; i++) solve(point[i].first, point[i].second, i);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
struct data {
int x, y;
int xi, yi;
} a[100000 + 5];
vector<int> vx[100005], vy[100005];
long long sum;
map<pair<int, int>, bool> mp;
void process() {
for (int i = 1; i <= n; i++) {
int k = a[i].xi;
for (int j = a[i].yi; j < vy[a[i].y].size(); j++) {
while (k < vx[a[i].x].size() &&
vx[a[i].x][k] - a[i].y < vy[a[i].y][j] - a[i].x)
k++;
if (k >= vx[a[i].x].size()) break;
if (vx[a[i].x][k] - a[i].y == vy[a[i].y][j] - a[i].x)
sum += mp[make_pair(vy[a[i].y][j], vx[a[i].x][k])];
}
}
printf("%I64d", sum);
}
bool compare(data x, data y) { return (x.y < y.y || x.y == y.y && x.x < y.x); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].x, &a[i].y);
mp[make_pair(a[i].x, a[i].y)] = 1;
}
sort(a + 1, a + n + 1, compare);
for (int i = 1; i <= n; i++) {
vx[a[i].x].push_back(a[i].y);
a[i].xi = vx[a[i].x].size();
vy[a[i].y].push_back(a[i].x);
a[i].yi = vy[a[i].y].size();
}
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, i, x, y, t1, t2, b, k, t3, t4, ans, j;
pair<int, int> a[N];
vector<int> sat[N], sut[N];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
sat[y].push_back(x);
sut[x].push_back(y);
a[i] = make_pair(x, y);
}
for (i = 0; i <= N - 5; i++)
sort(sat[i].begin(), sat[i].end()), sort(sut[i].begin(), sut[i].end());
for (i = 1; i <= n; i++) {
x = a[i].first;
y = a[i].second;
t1 = lower_bound(sat[y].begin(), sat[y].end(), x) - sat[y].begin();
t2 = lower_bound(sut[x].begin(), sut[x].end(), y) - sut[x].begin();
if (sat[y].size() - t1 <= sut[x].size() - t2) {
for (j = t1 + 1; j < sat[y].size(); j++) {
b = sat[y][j];
k = b - x;
t3 = lower_bound(sut[x].begin(), sut[x].end(), y + k) - sut[x].begin();
t4 = lower_bound(sut[b].begin(), sut[b].end(), y + k) - sut[b].begin();
if (t3 < sut[x].size() and t4 < sut[b].size() and
sut[x][t3] == y + k and sut[b][t4] == y + k)
ans++;
}
} else {
for (j = t2 + 1; j < sut[x].size(); j++) {
b = sut[x][j];
k = b - y;
t3 = lower_bound(sat[y].begin(), sat[y].end(), x + k) - sat[y].begin();
t4 = lower_bound(sat[b].begin(), sat[b].end(), x + k) - sat[b].begin();
if (t3 < sat[y].size() and t4 < sat[b].size() and
sat[y][t3] == x + k and sat[b][t4] == x + k)
ans++;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = ((int)3e5) + 5;
unordered_set<int> byX[maxn], byY[maxn];
vector<pair<int, int>> points;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
long long int t = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x = rand() % 100000, y = rand() % 100000;
cin >> x >> y;
points.push_back(make_pair(x, y));
byX[x].insert(y);
byY[y].insert(x);
}
long long int ans = 0;
for (int i = 0; i < maxn; i++) {
int x = i;
if (byX[i].size() < 300) {
for (int y1 : byX[x]) {
for (int y2 : byX[x]) {
t++;
if (y1 < y2) {
int dist = y2 - y1;
if (byX[x + dist].find(y1) != byX[x + dist].end() &&
byX[x + dist].find(y2) != byX[x + dist].end()) {
ans++;
}
}
}
}
} else {
for (int y : byX[x]) {
for (int x2 : byY[y]) {
if (x2 > x) {
t++;
int dist = x2 - x;
if (byX[x].find(y - dist) != byX[x].end() &&
byX[x2].find(y - dist) != byX[x2].end()) {
ans++;
}
}
}
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200005;
using namespace std;
int n, blo, h[N], g[N];
struct poi {
int x, y;
} a[N];
vector<int> P[N];
bool cmp(poi a, poi b) { return (a.x < b.x || (a.x == b.x && a.y < b.y)); }
bool find(int x, int y) {
int l = 0, r = (int)P[x].size() - 1;
for (; l <= r;) {
int mid = (l + r) / 2;
if (P[x][mid] == y) return true;
if (y < P[x][mid])
r = mid - 1;
else
l = mid + 1;
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &a[i].x, &a[i].y);
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) P[a[i].x].push_back(a[i].y);
blo = 200;
long long ans = 0;
for (int i = 0; i <= (N - 5) / 2; ++i)
if ((int)P[i].size() >= blo) {
for (int k = 0; k <= (int)P[i].size() - 1; ++k) ++g[P[i][k]];
for (int j = i + 1; j <= (N - 5) / 2; ++j) {
for (int k = 0; k <= (int)P[j].size() - 1; ++k) ++h[P[j][k]];
for (int k = 0; k <= (int)P[j].size() - 1; ++k)
if (g[P[j][k]] && h[P[j][k] + j - i] && g[P[j][k] + j - i]) ++ans;
for (int k = 0; k <= (int)P[j].size() - 1; ++k) --h[P[j][k]];
}
for (int k = 0; k <= (int)P[i].size() - 1; ++k) --g[P[i][k]];
}
for (int i = 0; i <= (N - 5) / 2; ++i)
if (P[i].size() < blo) {
for (int j = 0; j <= (int)P[i].size() - 1; ++j)
for (int k = j + 1; k <= (int)P[i].size() - 1; ++k) {
int x = P[i][j], y = P[i][k], L = y - x;
if (find(i + L, x) && find(i + L, y)) ++ans;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
const int maxn = 1e5 + 5;
pair<int, int> node[maxn];
vector<int> V[maxn];
int n;
set<pair<int, int> > Snode;
int xx[maxn], xcnt;
bool find(int x, int y) {
if (x < maxn)
return binary_search(V[x].begin(), V[x].end(), y);
else
return false;
}
int main() {
scanf("%d", &n);
int x, y;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
node[i] = {x, y};
xx[++xcnt] = x;
}
sort(node + 1, node + 1 + n);
for (int i = 1; i <= n; i++) {
V[node[i].first].push_back(node[i].second);
}
sort(xx + 1, xx + 1 + xcnt);
xcnt = unique(xx + 1, xx + 1 + xcnt) - xx - 1;
42;
int sz = sqrt(maxn);
int res = 0;
for (int i = 1; i <= xcnt; i++) {
x = xx[i];
if (V[x].size() <= sz) {
for (int j = 0; j < V[x].size(); j++) {
for (int k = j + 1; k < V[x].size(); k++) {
int tmp = V[x][k] - V[x][j];
if (find(x + tmp, V[x][j]) && find(x + tmp, V[x][k])) res++;
}
}
} else {
for (int j = i + 1; j <= xcnt; j++) {
int x2 = xx[j];
if (V[x2].size() <= 1) continue;
for (int k = 0; k < V[x2].size(); k++) {
int tmp = x2 - x;
if (find(x, V[x2][k]) && find(x, V[x2][k] + tmp) &&
find(x2, V[x2][k] + tmp))
res++;
}
}
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
unordered_set<int> Y[N];
set<int> X;
vector<int> pts[N];
const int MAGIC = 505;
int A[N], B[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d %d", &x, &y);
Y[x].insert(y);
pts[x].push_back(y);
X.insert(x);
}
int cnt = 0;
long long ans = 0;
for (int x : X) {
sort(pts[x].begin(), pts[x].end());
if (Y[x].size() < MAGIC) {
for (int i = 0; i < pts[x].size(); i++) {
for (int j = 0; j < i; j++) {
int y1 = pts[x][j], y2 = pts[x][i];
int len = y2 - y1;
if (x >= len && Y[x - len].count(y1) && Y[x - len].count(y2)) ans++;
}
}
} else {
for (int i = 0; i < cnt; i++) {
int x1 = A[i], y1 = B[i];
int len = x - x1;
if (Y[x].count(y1) && Y[x1].count(y1 - len) && Y[x].count(y1 - len)) {
ans++;
}
}
}
for (int y : pts[x]) {
A[cnt++] = x;
B[cnt - 1] = y;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> s[1 << 20];
vector<int> A[1 << 20];
vector<int> B[1 << 20];
unordered_set<int> S[1 << 20];
int main(void) {
srand(time(0));
int n;
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> s[i].first >> s[i].second, A[s[i].first].push_back(s[i].second),
B[s[i].second].push_back(s[i].first);
for (int i = 0; i <= 1e5; ++i)
sort(A[i].begin(), A[i].end()), sort(B[i].begin(), B[i].end());
for (int i = 1; i <= n; ++i) S[s[i].first].insert(s[i].second);
long long ans = 0;
sort(s + 1, s + 1 + n);
for (int i = 1; i <= n; ++i) {
int cntx = lower_bound(A[s[i].first].begin(), A[s[i].first].end(),
s[i].second + 1) -
A[s[i].first].begin();
int cnty = lower_bound(B[s[i].second].begin(), B[s[i].second].end(),
s[i].first + 1) -
B[s[i].second].begin();
int szA = A[s[i].first].size(), szB = B[s[i].second].size();
int D = 0;
if (szA - cntx < szB - cnty) {
for (int j = cntx; j < szA; ++j)
D = A[s[i].first][j] - s[i].second,
ans += S[D + s[i].first].count(s[i].second) &&
S[D + s[i].first].count(D + s[i].second);
} else {
for (int j = cnty; j < szB; ++j)
D = B[s[i].second][j] - s[i].first,
ans += S[s[i].first].count(D + s[i].second) &&
S[D + s[i].first].count(D + s[i].second);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 1;
vector<int> gx[maxn + 7];
vector<int> gy[maxn + 7];
long long g[maxn + 7];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[i] = maxn * x + y;
gx[x].push_back(y);
gy[y].push_back(x);
}
for (int i = 0; i <= maxn; i++) {
sort(gx[i].begin(), gx[i].end());
sort(gy[i].begin(), gy[i].end());
}
sort(g, g + n);
long long ans = 0;
for (int i = 0; i < n; i++) {
int x, y;
x = (int)(g[i] / maxn);
y = (int)(g[i] % maxn);
int idx, idy;
idx = lower_bound(gy[y].begin(), gy[y].end(), x + 1) - gy[y].begin();
idy = lower_bound(gx[x].begin(), gx[x].end(), y + 1) - gx[x].begin();
while (idx < gy[y].size() && idy < gx[x].size()) {
int nowx = gy[y][idx];
int nowy = gx[x][idy];
if (nowx - x == nowy - y) {
int pos = lower_bound(g, g + n, nowx * maxn + (long long)nowy) - g;
if (g[pos] == nowx * maxn + (long long)nowy) ans++;
idx++;
idy++;
} else if (nowx - x > nowy - y)
idy = lower_bound(gx[x].begin(), gx[x].end(), y + nowx - x) -
gx[x].begin();
else
idx = lower_bound(gy[y].begin(), gy[y].end(), x + nowy - y) -
gy[y].begin();
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
vector<int> xx[N], yy[N];
int n;
unordered_set<int> M[N * 2];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int x, y, i = 0; i < n; ++i) {
cin >> x >> y;
M[x].insert(y);
xx[x].push_back(y);
yy[y].push_back(x);
}
for (int i = 0; i < N; ++i) {
sort(xx[i].begin(), xx[i].end());
sort(yy[i].begin(), yy[i].end());
}
long long rr = 0;
vector<int>::iterator itx, ity;
for (int lx, ly, x = 0; x < N; ++x) {
for (int y : xx[x]) {
itx = upper_bound(yy[y].begin(), yy[y].end(), x);
lx = yy[y].end() - itx;
ity = upper_bound(xx[x].begin(), xx[x].end(), y);
ly = xx[x].end() - ity;
if (lx < ly) {
for (int l; itx != yy[y].end(); ++itx) {
l = (*itx) - x;
rr += M[x].count(y + l) * M[x + l].count(y + l);
}
} else {
for (int l; ity != xx[x].end(); ++ity) {
l = (*ity) - y;
rr += M[x + l].count(y) * M[x + l].count(y + l);
}
}
}
}
cout << rr;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ull = unsigned long long;
template <class T>
inline T gcd(T a, T b) {
return !a ? b : gcd(b % a, a);
}
template <class T>
inline T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
mt19937 rnd(time(0));
const int N = 2e5 + 5;
unordered_set<int> lineX[N], lineY[N];
unordered_map<long long, bool> cnt;
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cnt[a[i] * 1ll * 1e6 + b[i]] = 1;
}
for (int i = 0; i < n; i++) {
lineX[b[i]].insert(a[i]);
lineY[a[i]].insert(b[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if ((int)lineX[b[i]].size() < (int)lineY[a[i]].size()) {
int curX = a[i];
for (int nextX : lineX[b[i]]) {
if (nextX - curX > 0) {
ans += (cnt[curX * 1ll * 1e6 + b[i] + (nextX - curX)] &&
cnt[nextX * 1ll * 1e6 + b[i] + (nextX - curX)]);
}
}
} else {
int curY = b[i];
for (int nextY : lineY[a[i]]) {
if (nextY - curY > 0) {
ans += (cnt[(a[i] + (nextY - curY)) * 1ll * 1e6 + curY] &&
cnt[(a[i] + (nextY - curY)) * 1ll * 1e6 + nextY]);
}
}
}
}
cout << ans << '\n';
return;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t = 1;
while (t-- > 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
set<long long> xs[1000005], ys[1000005];
long long x[1000005], y[1000005];
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> x[i] >> y[i];
for (long long i = 1; i <= n; i++) {
xs[x[i]].insert(y[i]);
ys[y[i]].insert(x[i]);
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
set<long long>::iterator a = xs[x[i]].upper_bound(y[i]);
set<long long>::iterator b = ys[y[i]].upper_bound(x[i]);
while (a != xs[x[i]].end() && b != ys[y[i]].end()) {
if (*a - y[i] > *b - x[i])
b = ys[y[i]].lower_bound(x[i] + *a - y[i]);
else if (*a - y[i] < *b - x[i])
a = xs[x[i]].lower_bound(y[i] + *b - x[i]);
else {
if (xs[*b].count(*a)) ans++;
a++, b++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned MAXN = (1 << 20);
void Read(unsigned &x);
unsigned n;
unsigned x[MAXN], y[MAXN];
void read() {
Read(n);
for (unsigned i = 0; i < n; i++) {
Read(x[i]);
Read(y[i]);
}
}
set<unsigned> l[MAXN], r[MAXN];
vector<unsigned> row[MAXN], col[MAXN];
unordered_map<unsigned, bool> has[MAXN];
void solve() {
for (unsigned i = 0; i < n; i++) {
l[x[i]].insert(y[i]);
r[y[i]].insert(x[i]);
has[x[i]][y[i]] = true;
}
for (unsigned i = 0; i <= 1000000; i++)
for (auto it : l[i]) row[i].push_back(it);
for (unsigned j = 0; j <= 1000000; j++)
for (auto it : r[j]) col[j].push_back(it);
unsigned ans = 0, len = 0;
for (unsigned i = 0; i < n; i++) {
auto byx = upper_bound(row[x[i]].begin(), row[x[i]].end(), y[i]);
auto byy = upper_bound(col[y[i]].begin(), col[y[i]].end(), x[i]);
if (distance(byx, row[x[i]].end()) > distance(byy, col[y[i]].end())) {
for (; byy != col[y[i]].end(); ++byy) {
len = *byy - x[i];
ans += (has[*byy].count(y[i] + len) && has[x[i]].count(y[i] + len));
}
} else {
for (; byx != row[x[i]].end(); ++byx) {
len = *byx - y[i];
ans += (has[x[i] + len].count(*byx) && has[x[i] + len].count(y[i]));
}
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
char sir[800000];
unsigned pos_ind = 0;
void Next() {
if (++pos_ind == 800000) fread(sir, 1, 800000, stdin), pos_ind = 0;
}
void Read(unsigned &x) {
for (; sir[pos_ind] < '0' || sir[pos_ind] > '9'; Next())
;
for (x = 0; sir[pos_ind] >= '0' && sir[pos_ind] <= '9'; Next())
x = x * 10 + sir[pos_ind] - '0';
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const int inf = INT_MAX;
const int N = 1e5;
int n, qi;
pair<int, int> a[N];
vector<int> coord_x[N + 1], coord_y[N + 1];
vector<pair<int, int>> queries[N + 1];
void addQuery(int x, int y) {
if (x >= 0) {
queries[x].emplace_back(y, qi++);
}
}
vector<bool> ans;
void processQueries() {
ans.assign(qi, false);
for (int x = 0; x <= N; x++) {
sort(queries[x].begin(), queries[x].end());
int ptr = 0;
for (auto& [y, idx] : queries[x]) {
while (ptr < coord_x[x].size() and coord_x[x][ptr] < y) {
ptr++;
}
if (ptr < coord_x[x].size() and coord_x[x][ptr] == y) {
ans[idx] = true;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
coord_x[a[i].first].push_back(a[i].second);
coord_y[a[i].second].push_back(a[i].first);
}
for (int i = 0; i <= N; i++) {
sort(coord_x[i].begin(), coord_x[i].end());
sort(coord_y[i].begin(), coord_y[i].end());
}
for (int i = 0; i < n; i++) {
auto [x0, y0] = a[i];
int idx_x = lower_bound(coord_x[x0].begin(), coord_x[x0].end(), y0) -
coord_x[x0].begin();
int idx_y = lower_bound(coord_y[y0].begin(), coord_y[y0].end(), x0) -
coord_y[y0].begin();
if (idx_x <= idx_y) {
for (int j = 0; j < idx_x; j++) {
int d = y0 - coord_x[x0][j];
addQuery(x0 - d, y0);
addQuery(x0 - d, y0 - d);
}
} else {
for (int j = 0; j < idx_y; j++) {
int d = x0 - coord_y[y0][j];
addQuery(x0, y0 - d);
addQuery(x0 - d, y0 - d);
}
}
}
processQueries();
int cnt = 0;
for (int i = 1; i < qi; i += 2) {
cnt += ans[i - 1] && ans[i];
}
cout << cnt << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
constexpr int N = 100001;
int n;
vector<int> xs[N], ys[N];
pair<int, int> pts[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d", &pts[i].first, &pts[i].second);
xs[pts[i].first].push_back(pts[i].second);
ys[pts[i].second].push_back(pts[i].first);
}
for (int i = 0; i < N; ++i) {
sort(xs[i].begin(), xs[i].end());
sort(ys[i].begin(), ys[i].end());
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
const int &x = pts[i].first, &y = pts[i].second;
if (xs[x].size() < ys[y].size()) {
for (int ny : xs[x]) {
if (ny <= y) continue;
int l = abs(ny - y);
ans += (binary_search(ys[y].begin(), ys[y].end(), x + l) &&
binary_search(ys[ny].begin(), ys[ny].end(), x + l));
}
} else {
for (int nx : ys[y]) {
if (nx <= x) continue;
int l = abs(nx - x);
ans += (binary_search(xs[x].begin(), xs[x].end(), y + l) &&
binary_search(xs[nx].begin(), xs[nx].end(), y + l));
}
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v[100010 * 2];
unordered_set<long long> occ;
int contC[100010], contL[100010];
int main() {
occ.reserve(1024);
occ.max_load_factor(0.25);
ios::sync_with_stdio(0);
cin >> n;
int xi, yi;
for (int i = 0; i < n; i++) {
cin >> xi >> yi;
occ.insert(yi * (1LL << 20) + xi);
contC[xi]++;
contL[yi]++;
v[xi - yi + 100010].push_back({xi, yi});
}
int ans = 0;
for (int i = 0; i < 100010 * 2; i++) {
for (int l = 0; l < v[i].size(); l++) {
if (contC[v[i][l].first] == 1 || contL[v[i][l].second] == 1)
swap(v[i][l], v[i][v[i].size() - 1]), v[i].pop_back(), l--;
}
sort(v[i].begin(), v[i].end());
for (int l = 0; l < v[i].size(); l++) {
for (int j = l + 1; j < v[i].size(); j++) {
if (occ.count(v[i][l].first + (1LL << 20) * v[i][j].second) &&
occ.count(v[i][j].first + (1LL << 20) * v[i][l].second)) {
ans++;
}
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
namespace std {
template <>
struct hash<pair<int, int> > {
size_t operator()(pair<int, int> a) const {
return a.first * 9875321 + a.second;
}
};
} // namespace std
unordered_map<pair<int, int>, int> m1;
vector<int> b;
vector<int> a[110000];
int n, m, ans;
int main() {
int i, j, k, x, y, d;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
m1[pair<int, int>(x, y)] = 1;
}
m = sqrt(n);
for (i = 0; i <= 100000; i++)
if (a[i].size() >= m) b.push_back(i);
for (i = 0; i < b.size(); i++)
for (j = i + 1; j < b.size(); j++) {
d = b[j] - b[i];
x = b[i];
for (k = 0; k < a[x].size(); k++) {
y = a[x][k];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x, y + d)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
}
}
for (i = 0; i <= 100000; i++)
if (a[i].size() < m) {
sort(a[i].begin(), a[i].end());
x = i;
for (j = 0; j < a[x].size(); j++) {
y = a[x][j];
for (k = j + 1; k < a[x].size(); k++) {
d = a[x][k] - a[x][j];
if (m1.count(pair<int, int>(x + d, y)) &&
m1.count(pair<int, int>(x + d, y + d)))
ans++;
if (x - d >= 0 && a[x - d].size() >= m)
if (m1.count(pair<int, int>(x - d, y)) &&
m1.count(pair<int, int>(x - d, y + d)))
ans++;
}
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using LL = long long;
using namespace std;
const int N = (int)1e5 + 10, L = 320;
int n;
vector<int> xps[N], yps[N];
unordered_set<int> xhs[N], yhs[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
xps[x].push_back(y);
xhs[x].insert(y);
}
for (int i = 0; i < N; i++) sort(xps[i].begin(), xps[i].end());
LL ans = 0;
for (int i = 0; i < N; i++) {
int l = xps[i].size();
if (l <= L) {
for (int j = 0; j < l; j++) {
int y2 = xps[i][j];
for (int k = 0; k < j; k++) {
int y1 = xps[i][k], d = y2 - y1;
if (i - d >= 0 && xps[i - d].size() > L) {
ans += xhs[i - d].count(y1) && xhs[i - d].count(y2);
}
if (i + d < N) ans += xhs[i + d].count(y1) && xhs[i + d].count(y2);
}
}
} else {
for (int y : xps[i]) {
yps[y].push_back(i);
yhs[y].insert(i);
}
}
}
for (int i = 0; i < N; i++) {
int l = yps[i].size();
for (int j = 0; j < l; j++) {
int x2 = yps[i][j];
for (int k = 0; k < j; k++) {
int x1 = yps[i][k], d = x2 - x1;
if (i - d >= 0 && yps[i - d].size() > L) {
ans += yhs[i - d].count(x1) && yhs[i - d].count(x2);
}
if (i + d < N) ans += yhs[i + d].count(x1) && yhs[i + d].count(x2);
}
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
int n, x[mx], y[mx], sol;
vector<int> X[mx], Y[mx];
set<int> point[mx];
int exist(int x, int y) { return point[x].count(y); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
point[x[i]].insert(y[i]);
X[x[i]].push_back(y[i]);
Y[y[i]].push_back(x[i]);
}
for (int i = 0; i < mx; i++) {
sort(X[i].begin(), X[i].end());
sort(Y[i].begin(), Y[i].end());
}
for (int i = 1; i <= n; i++) {
if (X[x[i]].size() < Y[y[i]].size()) {
int it = find(X[x[i]].begin(), X[x[i]].end(), y[i]) - X[x[i]].begin() + 1;
for (int j = it; j < X[x[i]].size(); j++) {
int d = X[x[i]][j] - y[i];
sol += exist(x[i] + d, y[i]) && exist(x[i] + d, y[i] + d);
}
} else {
int it = find(Y[y[i]].begin(), Y[y[i]].end(), x[i]) - Y[y[i]].begin() + 1;
for (int j = it; j < Y[y[i]].size(); j++) {
int d = Y[y[i]][j] - x[i];
sol += exist(x[i], y[i] + d) && exist(x[i] + d, y[i] + d);
}
}
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int mod = 3174511;
vector<int> v[N];
struct edge {
int x, y, next, type;
} e[N];
int head[mod + 10], cnt;
void addedge(int x, int y, int type) {
long long u = (1314517LL * x + y) % mod;
e[cnt].x = x;
e[cnt].y = y;
e[cnt].type = type;
e[cnt].next = head[u];
head[u] = cnt++;
}
bool find(int x, int y, int &type) {
if (!(x >= 0 && x < N && y >= 0 && y < N)) return false;
long long u = (1314517LL * x + y) % mod;
for (int i = head[u]; i != -1; i = e[i].next)
if (e[i].x == x && e[i].y == y) {
type = e[i].type;
return true;
}
return false;
}
int main() {
memset(head, -1, sizeof(head));
int n, x, y;
scanf("%d", &n);
bool flag = false;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
}
for (int i = 0; i < N; i++) v[i].push_back(10000000);
for (int i = 0; i < N; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i < N; i++)
for (int j = 0; j < v[i].size() - 1; j++)
if (v[i].size() >= 320)
addedge(i, v[i][j], 2);
else
addedge(i, v[i][j], 1);
int ans = 0;
for (int i = 0; i <= 100000; i++)
if (v[i].size() >= 320) {
for (int j = i + 1; j <= 100000; j++) {
if (v[j].size() < 320) continue;
int len = j - i;
int pt1 = 0, pt2 = 0, pt3 = 0;
for (int k = 0; k < v[i].size() - 1; k++) {
while (v[i][pt1] < v[i][k] + len) pt1++;
if (v[i][k] + len != v[i][pt1]) continue;
while (v[j][pt2] < v[i][k]) pt2++;
while (v[j][pt3] < v[i][k] + len) pt3++;
if (v[j][pt2] == v[i][k] && v[j][pt3] == v[i][k] + len) ans += 2;
}
}
}
for (int i = 0; i <= 100000; i++) {
if (v[i].size() >= 320) continue;
for (int j = 0; j < v[i].size() - 1; j++) {
for (int k = j + 1; k < v[i].size() - 1; k++) {
int len = v[i][k] - v[i][j];
int type;
if (find(i + len, v[i][j], type) && find(i + len, v[i][k], type))
ans += type;
if (find(i - len, v[i][j], type) && find(i - len, v[i][k], type))
ans += type;
}
}
}
cout << (ans >> 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans;
vector<int> v1[100005];
vector<int> v2[100005];
bool isexist(int sign, int x, int y) {
vector<int> *v;
if (sign == 0)
v = &v1[x];
else
v = &v2[x];
if (x < 0 || x > 100000) return false;
return binary_search((*v).begin(), (*v).end(), y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d%d", &a, &b);
v1[a].push_back(b);
}
for (int i = 0; i <= 100000; i++) sort(v1[i].begin(), v1[i].end());
for (int i = 0; i <= 100000; i++) {
if (v1[i].size() <= 400) {
for (int p1 = 0; p1 < v1[i].size(); p1++) {
for (int p2 = p1 + 1; p2 < v1[i].size(); p2++) {
if (isexist(0, i - (v1[i][p2] - v1[i][p1]), v1[i][p1]) &&
isexist(0, i - (v1[i][p2] - v1[i][p1]), v1[i][p2]))
ans++;
if (isexist(0, i + (v1[i][p2] - v1[i][p1]), v1[i][p1]) &&
isexist(0, i + (v1[i][p2] - v1[i][p1]), v1[i][p2]))
ans++;
}
}
v1[i].clear();
}
}
for (int i = 0; i <= 100000; i++) {
for (auto j : v1[i]) {
v2[j].push_back(i);
}
}
for (int i = 0; i <= 100000; i++) sort(v2[i].begin(), v2[i].end());
for (int i = 0; i <= 100000; i++) {
if (v2[i].size() <= 400) {
for (int p1 = 0; p1 < v2[i].size(); p1++) {
for (int p2 = p1 + 1; p2 < v2[i].size(); p2++) {
if (isexist(1, i - (v2[i][p2] - v2[i][p1]), v2[i][p1]) &&
isexist(1, i - (v2[i][p2] - v2[i][p1]), v2[i][p2]))
ans++;
if (isexist(1, i + (v2[i][p2] - v2[i][p1]), v2[i][p1]) &&
isexist(1, i + (v2[i][p2] - v2[i][p1]), v2[i][p2]))
ans++;
}
}
v2[i].clear();
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long n;
vector<long long> cordX[N], cordY[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; ++i) {
long long x, y;
cin >> x >> y;
cordX[x].push_back(y);
cordY[y].push_back(x);
}
for (long long i = 0; i <= 100000; ++i) {
sort(cordX[i].begin(), cordX[i].end());
sort(cordY[i].begin(), cordY[i].end());
}
long long ans = 0;
for (long long i = 0; i <= 100000; ++i) {
for (long long j = 0; j < (long long)cordX[i].size(); ++j) {
long long x = i, y = cordX[i][j];
long long idx1 = j + 1;
long long idx2 =
upper_bound(cordY[y].begin(), cordY[y].end(), x) - cordY[y].begin();
while (idx1 < (long long)cordX[x].size() &&
idx2 < (long long)cordY[y].size()) {
long long y1 = cordX[x][idx1];
long long x1 = cordY[y][idx2];
if (y1 - y > x1 - x) {
++idx2;
} else if (y1 - y < x1 - x) {
++idx1;
} else {
ans += binary_search(cordX[x1].begin(), cordX[x1].end(), y1);
++idx1;
++idx2;
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return a > val ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int MAXN = 7654321;
const int NOTFOUND = -1;
struct HashMap {
int cur, head[MAXN], next[MAXN];
long long l[MAXN];
int x[MAXN];
HashMap() {
cur = 0;
fill_n(head, MAXN, 0);
fill_n(next, MAXN, 0);
}
int find(long long key) {
for (int i = head[key % MAXN]; i; i = next[i]) {
if (l[i] == key) {
return x[i];
}
}
return NOTFOUND;
}
void erase(long long key) {
for (int i = head[key % MAXN]; i; i = next[i]) {
if (l[i] == key) {
x[i] = NOTFOUND;
}
}
}
void insert(long long key, int val) {
if (find(key) != NOTFOUND) return;
l[++cur] = key;
x[cur] = val;
next[cur] = head[key % MAXN];
head[key % MAXN] = cur;
}
} hm;
long long phash(int u, int v) { return (((long long)u) << 20) + v; }
const int maxn = 100010;
const int magic = 320;
int n;
vector<int> ax[maxn];
vector<int> ay[maxn];
void solve() {
cin >> n;
for (int i = (0); i < (n); i++) {
int u, v;
cin >> u >> v;
ax[u].push_back(v);
hm.insert(phash(u, v), 1);
}
int ans = 0;
for (int i = (0); i < (maxn); i++) {
if (int((ax[i]).size()) < magic) {
for (int j = (0); j < (int((ax[i]).size())); j++) {
for (int k = (j + 1); k < (int((ax[i]).size())); k++) {
int p = abs(ax[i][j] - ax[i][k]);
if (i - p >= 0 && hm.find(phash(i - p, ax[i][j])) != NOTFOUND &&
hm.find(phash(i - p, ax[i][k])) != NOTFOUND) {
ans++;
}
if (i + p < maxn && hm.find(phash(i + p, ax[i][j])) != NOTFOUND &&
hm.find(phash(i + p, ax[i][k])) != NOTFOUND) {
ans++;
}
}
hm.erase(phash(i, ax[i][j]));
}
} else {
for (int j = (0); j < (int((ax[i]).size())); j++) {
ay[ax[i][j]].push_back(i);
}
}
}
for (int i = (0); i < (maxn); i++) {
for (int j = (0); j < (int((ay[i]).size())); j++) {
for (int k = (j + 1); k < (int((ay[i]).size())); k++) {
int p = abs(ay[i][j] - ay[i][k]);
if (i - p >= 0 && hm.find(phash(ay[i][j], i - p)) != NOTFOUND &&
hm.find(phash(ay[i][k], i - p)) != NOTFOUND) {
ans++;
}
if (i + p < maxn && hm.find(phash(ay[i][j], i + p)) != NOTFOUND &&
hm.find(phash(ay[i][k], i + p)) != NOTFOUND) {
ans++;
}
}
hm.erase(phash(ay[i][j], i));
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
unordered_set<int> X[N], Y[N];
bool check(int x, int y) {
if (x < 0 || x >= N || y < 0 || y >= N) return 0;
return X[x].count(y);
}
void erase(int x, int y) {
X[x].erase(y);
Y[y].erase(x);
}
ll ans = 0;
void solvex(int x) {
while (!X[x].empty()) {
int y = *X[x].begin();
erase(x, y);
for (auto y2 : X[x]) {
int len = y2 - y;
if (check(x + len, y) && check(x + len, y + len)) {
ans++;
}
if (check(x - len, y) && check(x - len, y + len)) {
ans++;
}
}
}
}
void solvey(int y) {
while (!Y[y].empty()) {
int x = *Y[y].begin();
erase(x, y);
for (auto x2 : Y[y]) {
int len = x2 - x;
if (check(x, y + len) && check(x + len, y + len)) {
ans++;
}
if (check(x, y - len) && check(x + len, y - len)) {
ans++;
}
}
}
}
int main() {
int n;
scanf("%d", &n);
vector<int> x(n), y(n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i < n; ++i) {
X[x[i]].insert(y[i]);
Y[y[i]].insert(x[i]);
}
for (int i = 0; i < N; ++i) {
if (X[i].size() * X[i].size() <= n) {
solvex(i);
}
}
for (int i = 0; i < N; ++i) {
solvey(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 1e2;
pair<int, int> P[MAX];
int mxY[MAX], n;
vector<int> Y[MAX];
int vis[MAX];
bool find(int x, int y) {
if (x >= MAX) return 0;
return binary_search(Y[x].begin(), Y[x].end(), y);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (n); i++) scanf("%d %d", &P[i].first, &P[i].second);
for (int i = 0; i < (n); i++) Y[P[i].first].push_back(P[i].second);
for (int x = 0; x < (MAX); x++) sort(Y[x].begin(), Y[x].end());
long long ans = 0;
for (int x = 0; x < MAX; x++) {
if (((int)Y[x].size()) * 1LL * ((int)Y[x].size()) <= n) {
for (int i = 0; i < (((int)Y[x].size())); i++)
for (int j = 0; j < (i); j++) {
int len = Y[x][i] - Y[x][j];
ans += find(x + len, Y[x][i]) && find(x + len, Y[x][j]);
}
} else {
for (int len = 1; x + len < MAX; len++) {
for (int y : Y[x + len]) {
ans += find(x, y + len) && find(x, y) && find(x + len, y + len);
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int INF = 1e9 + 7;
struct point {
int x, y;
point() {}
point(int kx, int ky) {
x = kx;
y = ky;
}
};
point mas[N];
vector<int> setX[N], setY[N];
map<pair<int, int>, bool> mp;
bool cmp(point a, point b) {
if (a.x == b.x) return a.y < b.y;
return a.x < b.x;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int kx, ky;
cin >> kx >> ky;
mas[i] = point(kx, ky);
setX[ky].push_back(kx);
setY[kx].push_back(ky);
mp[make_pair(kx, ky)] = 1;
}
sort(mas + 1, mas + n + 1, cmp);
for (int i = 0; i <= 1e5; i++) {
sort(setX[i].begin(), setX[i].end());
sort(setY[i].begin(), setY[i].end());
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int X = mas[i].x, Y = mas[i].y;
if (setX[Y].size() <= setY[X].size()) {
int pos = 0;
while (pos < setX[Y].size() && setX[Y][pos] <= X) pos++;
int posY = 0;
while (posY < setY[X].size() && setY[X][posY] <= Y) posY++;
if (pos < setX[Y].size() && posY < setY[X].size()) {
for (int id = pos; id < setX[Y].size(); id++) {
int z = setX[Y][id] - X;
int t = posY;
while (t < setY[X].size() - 1 && setY[X][t] - Y < z) t++;
if (setY[X][t] - Y == z && mp[make_pair(setX[Y][id], setY[X][t])])
ans++;
posY = t;
}
}
} else {
int pos = 0;
while (pos < setY[X].size() && setY[X][pos] <= Y) pos++;
int posX = 0;
while (posX < setX[Y].size() && setX[Y][posX] <= X) posX++;
if (posX < setX[Y].size() && pos < setY[X].size()) {
for (int id = pos; id < setY[X].size(); id++) {
int z = setY[X][id] - Y;
int t = posX;
while (t < setX[Y].size() - 1 && setX[Y][t] - X < z) t++;
if (setX[Y][t] - X == z && mp[make_pair(setX[Y][t], setY[X][id])])
ans++;
posX = t;
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 4;
vector<long long> vx[MAXN];
vector<long long> vy[MAXN];
long long hash1(long long x, long long y) { return x + y * MAXN; }
unordered_set<long long> s;
long long n, x, y;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
if (vx[x].size() < vy[y].size()) {
for (long long j = 0; j < vx[x].size(); j++) {
long long t = abs(vx[x][j] - y);
if (s.find(hash1(x + t, y)) != s.end() &&
s.find(hash1(x + t, vx[x][j])) != s.end())
cnt++;
if (s.find(hash1(x - t, y)) != s.end() &&
s.find(hash1(x - t, vx[x][j])) != s.end())
cnt++;
}
} else {
for (long long j = 0; j < vy[y].size(); j++) {
long long t = abs(vy[y][j] - x);
if (s.find(hash1(x, y + t)) != s.end() &&
s.find(hash1(vy[y][j], y + t)) != s.end())
cnt++;
if (s.find(hash1(x, y - t)) != s.end() &&
s.find(hash1(vy[y][j], y - t)) != s.end())
cnt++;
}
}
s.insert(hash1(x, y));
vx[x].push_back(y);
vy[y].push_back(x);
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct HashMap {
vector<pair<int, int> > g[1000007];
void ins(int x, int y) {
int id = ((long long)(x)*1000000007 + y) % 1000007;
g[id].push_back(make_pair(x, y));
}
bool get(int x, int y) {
int id = ((long long)(x)*1000000007 + y) % 1000007;
for (int i = 0; i < g[id].size(); i++) {
if (g[id][i].first == x && g[id][i].second == y) return true;
}
return false;
}
};
HashMap mp;
struct Point {
int x, y;
} pt[100010];
vector<int> Row[100010];
int big[100010];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d%d", &pt[i].x, &pt[i].y);
Row[pt[i].y].push_back(pt[i].x);
mp.ins(pt[i].x, pt[i].y);
}
int ans = 0;
int sz = sqrt(n) + 1;
int bigcnt = 0;
for (int i = 0; i < 100010; i++) {
sort(Row[i].begin(), Row[i].end());
if (Row[i].size() > sz) {
big[bigcnt++] = i;
} else {
int len = Row[i].size();
for (int j = 0; j < len; j++) {
for (int k = j + 1; k < len; k++) {
int d = Row[i][k] - Row[i][j];
if (mp.get(Row[i][j] + d, i + d) && mp.get(Row[i][j], i + d)) {
ans++;
}
if (mp.get(Row[i][j] + d, i - d) && mp.get(Row[i][j], i - d)) {
if (i - d >= 0 && Row[i - d].size() > sz) {
ans++;
}
}
}
}
}
}
for (int i = 0; i < bigcnt; i++) {
for (int j = i + 1; j < bigcnt; j++) {
int d = big[j] - big[i];
int p1 = 0, p2 = 0;
int len1, len2;
len1 = Row[big[i]].size();
len2 = Row[big[j]].size();
while (p1 < len1) {
while (p2 < len2 && Row[big[j]][p2] < Row[big[i]][p1]) {
p2++;
}
if (p1 < len1 && p2 < len2 && Row[big[i]][p1] == Row[big[j]][p2]) {
if (mp.get(Row[big[i]][p1] + d, big[i]) &&
mp.get(Row[big[j]][p2] + d, big[j])) {
ans++;
}
}
p1++;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5;
const int Q = 1e9 + 7;
const int T = 302;
vector<pair<int, int> > sp;
vector<int> d1;
vector<int> g[M + 10];
map<pair<int, int>, bool> ma;
inline bool is(int i, int j) {
if (i < 0 || i > M) return false;
if ((int)g[i].size() == 0) return false;
int tmp = lower_bound(g[i].begin(), g[i].end(), j) - g[i].begin();
if (tmp < (int)g[i].size() && g[i][tmp] == j) return true;
return false;
}
int main() {
srand(time(NULL));
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
}
for (int i = 0; i <= M; i++) sort(g[i].begin(), g[i].end());
for (int i = 0; i <= M; i++) {
if (g[i].size() == 0) continue;
if ((int)g[i].size() < T) {
for (int j = 0; j < (int)g[i].size(); j++)
for (int k = j + 1; k < (int)g[i].size(); k++) {
int d = g[i][k] - g[i][j];
if (is(i + d, g[i][j]) && is(i + d, g[i][k])) ans++;
if (is(i - d, g[i][j]) && is(i - d, g[i][k])) ans++;
}
g[i].resize(0);
} else {
for (int j = 0; j < (int)g[i].size(); j++) {
sp.push_back(make_pair(i, g[i][j]));
}
d1.push_back(i);
}
}
assert((int)d1.size() <= 100000 / 300);
for (int i = 0; i < (int)sp.size(); i++) {
for (int j = 0; j < (int)d1.size(); j++) {
if (sp[i].first >= d1[j]) continue;
int d = abs(d1[j] - sp[i].first);
if (is(sp[i].first + d, sp[i].second) &&
is(sp[i].first, sp[i].second + d) &&
is(sp[i].first + d, sp[i].second + d))
ans++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, kk;
int x[211111], y[211111];
vector<int> vx[211111], vy[211111];
long long yy[211111];
int pp[211111], xx[1222000];
void add(int x, int y) {
long long e = (x + 1) * 100111ll + (y + 1);
int o = e % 1000007;
yy[++kk] = e;
pp[kk] = xx[o];
xx[o] = kk;
}
bool fin(int x, int y) {
if (x < 0 || x > 100000) return 0;
if (y < 0 || y > 100000) return 0;
long long e = (x + 1) * 100111ll + (y + 1);
int o = e % 1000007;
for (int w = xx[o]; w; w = pp[w])
if (yy[w] == e) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
vx[x[i]].push_back(y[i]);
vy[y[i]].push_back(x[i]);
add(x[i], y[i]);
}
for (int i = 0; i <= 100000; i++) {
sort(vx[i].begin(), vx[i].end());
sort(vy[i].begin(), vy[i].end());
}
int ans = 0;
for (int i = 0; i < n; i++) {
int xx = x[i];
int yy = y[i];
int d;
if (vx[xx].size() < vy[yy].size()) {
for (int j = 0; j < vx[xx].size(); j++) {
if (vx[xx][j] == yy) break;
d = yy - vx[xx][j];
if (fin(xx - d, yy) && fin(xx - d, yy - d)) ans++;
}
} else {
for (int j = 0; j < vy[yy].size(); j++) {
if (vy[yy][j] == xx) break;
d = xx - vy[yy][j];
if (fin(xx, yy - d) && fin(xx - d, yy - d)) ans++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct HashMap {
vector<pair<int, int> > g[1000007];
void ins(int x, int y) {
int id = ((long long)(x)*1000000007 + y) % 1000007;
g[id].push_back(make_pair(x, y));
}
bool get(int x, int y) {
int id = ((long long)(x)*1000000007 + y) % 1000007;
for (int i = 0; i < g[id].size(); i++) {
if (g[id][i].first == x && g[id][i].second == y) return true;
}
return false;
}
};
HashMap mp;
vector<int> g[100010];
int x[100010], y[100010], id[100010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
g[x[i]].push_back(y[i]);
mp.ins(x[i], y[i]);
}
int sz, cnt = 0, ans = 0;
sz = (int)(sqrt(n * 1.0));
for (int i = 0; i <= 100000; i++) {
sort(g[i].begin(), g[i].end());
if (g[i].size() >= sz) {
id[cnt++] = i;
} else {
int m = g[i].size();
for (int j = 0; j < m; j++) {
for (int k = j + 1; k < m; k++) {
int dx = g[i][k] - g[i][j];
if (i - dx >= 0 && mp.get(i - dx, g[i][j]) &&
mp.get(i - dx, g[i][k])) {
ans++;
}
if (i + dx <= 100000 && g[i + dx].size() >= sz) {
if (mp.get(i + dx, g[i][j]) && mp.get(i + dx, g[i][k])) {
ans++;
}
}
}
}
}
}
for (int ii = 0; ii < cnt; ii++) {
for (int jj = ii + 1; jj < cnt; jj++) {
int i = id[ii], j = id[jj];
int p1 = 0, p2 = 0;
while (p1 < g[i].size() && p2 < g[j].size()) {
if (g[i][p1] < g[j][p2])
p1++;
else if (g[i][p1] > g[j][p2])
p2++;
else {
int dx = j - i, y = g[i][p1];
if (mp.get(i, y + dx) && mp.get(j, y + dx)) ans++;
p1++;
p2++;
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
using namespace std;
const int MAX_N = 100000 + 7;
unordered_set<long long> bst;
vector<int> rx[MAX_N], ry[MAX_N];
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int> > ps;
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
rx[y].push_back(x);
ry[x].push_back(y);
ps.emplace_back(x, y);
bst.insert(x * MAX_N + y);
}
for (int i = 0; i < MAX_N; i++) {
sort(rx[i].begin(), rx[i].end());
sort(ry[i].begin(), ry[i].end());
}
sort(ps.begin(), ps.end());
int ans = 0;
for (pair<int, int> p : ps) {
int ptr_rx =
lower_bound(rx[p.second].begin(), rx[p.second].end(), p.first) -
rx[p.second].begin();
int ptr_ry = lower_bound(ry[p.first].begin(), ry[p.first].end(), p.second) -
ry[p.first].begin();
if (ptr_rx <= ptr_ry) {
for (int i = 0; i < ptr_rx; i++) {
int d = p.first - rx[p.second][i];
if (bst.count(p.first * MAX_N + (p.second - d)) &&
bst.count((p.first - d) * MAX_N + (p.second - d)))
ans++;
}
} else {
for (int i = 0; i < ptr_ry; i++) {
int d = p.second - ry[p.first][i];
if (bst.count(((p.first - d) * MAX_N + p.second)) &&
bst.count((p.first - d) * MAX_N + (p.second - d)))
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x += _y;
return _x >= _mod ? _x - _mod : _x;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x -= _y;
return _x < 0 ? _x + _mod : _x;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x *= _y;
return _x >= _mod ? _x % _mod : _x;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1LL;
long long _ret = mypow(mul(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = mul(_ret, _a, _mod);
return _ret;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0LL;
long long _ret = mymul(add(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = add(_ret, _a, _mod);
return _ret;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
void sleep(double sec = 1021) {
clock_t s = clock();
while (clock() - s < CLOCKS_PER_SEC * sec)
;
}
int __ = 1, _cs;
void build() {}
int n;
vector<int> vx[100001], vy[100001];
void init() {
n = getint();
for (int i = 0, x, y; i < n; i++) {
x = getint();
y = getint();
vx[x].push_back(y);
vy[y].push_back(x);
}
for (int i = 0; i < 100001; i++) {
sort(vx[i].begin(), vx[i].end());
sort(vy[i].begin(), vy[i].end());
}
}
int ans;
vector<int> cand[100001];
void solve() {
for (int x = 0; x < 100001; x++)
for (int y : vx[x]) {
size_t xptr = upper_bound(vx[x].begin(), vx[x].end(), y) - vx[x].begin();
size_t yptr = upper_bound(vy[y].begin(), vy[y].end(), x) - vy[y].begin();
while (xptr < vx[x].size() and yptr < vy[y].size()) {
if (vx[x][xptr] - y == vy[y][yptr] - x) {
if (not vx[vy[y][yptr]].empty())
cand[vy[y][yptr]].push_back(vx[x][xptr]);
xptr++;
yptr++;
} else if (vx[x][xptr] - y < vy[y][yptr] - x)
xptr =
lower_bound(vx[x].begin(), vx[x].end(), y + (vy[y][yptr] - x)) -
vx[x].begin();
else
yptr =
lower_bound(vy[y].begin(), vy[y].end(), x + (vx[x][xptr] - y)) -
vy[y].begin();
}
}
for (int x = 0; x < 100001; x++) {
sort(cand[x].begin(), cand[x].end());
size_t ptr = 0;
for (int y : cand[x]) {
while (ptr < vx[x].size() and vx[x][ptr] < y) ptr++;
if (ptr == vx[x].size()) break;
ans += (vx[x][ptr] == y);
}
}
cout << ans << endl;
}
int main() {
build();
while (__--) {
init();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long myHash(long long x, long long y) { return (x << 20) + y; }
unordered_set<long long> have;
struct point {
int x, y;
point *nextSameX, *nextSameY;
int nNextX, nNextY;
point() {
nextSameX = nextSameY = NULL;
nNextX = nNextY = 0;
}
} * P[100001];
bool byX(point *a, point *b) {
if (a->x != b->x) return a->x < b->x;
return a->y < b->y;
}
bool byY(point *a, point *b) {
if (a->y != b->y) return a->y < b->y;
return a->x < b->x;
}
int n;
inline bool check(int x, int y, int x2, int y2) {
int a = x2 + y2 - x - y;
if (have.count(myHash(x + a, y + a)))
if (have.count(myHash(x + a, y)))
if (have.count(myHash(x, y + a))) return true;
return false;
}
int MAIN() {
cin >> n;
for (int i = 1; i <= n; i++) {
P[i] = new point();
cin >> P[i]->x >> P[i]->y;
have.insert(myHash(P[i]->x, P[i]->y));
}
sort(P + 1, P + 1 + n, byX);
for (int i = n - 1; i >= 1; i--)
if (P[i]->x == P[i + 1]->x) {
P[i]->nextSameX = P[i + 1];
P[i]->nNextX = P[i + 1]->nNextX + 1;
}
sort(P + 1, P + 1 + n, byY);
for (int i = n - 1; i >= 1; i--)
if (P[i]->y == P[i + 1]->y) {
P[i]->nextSameY = P[i + 1];
P[i]->nNextY = P[i + 1]->nNextY + 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (P[i]->nNextX < P[i]->nNextY) {
point *p = P[i];
for (int j = 1; j <= P[i]->nNextX; j++) {
p = p->nextSameX;
ans += check(P[i]->x, P[i]->y, p->x, p->y);
}
} else {
point *p = P[i];
for (int j = 1; j <= P[i]->nNextY; j++) {
p = p->nextSameY;
ans += check(P[i]->x, P[i]->y, p->x, p->y);
}
}
}
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
set<pair<int, int> > st;
struct PP {
int x, y;
bool operator<(const PP& a) const {
if (y == a.y) return x < a.x;
return y < a.y;
}
} a[N];
vector<int> vx[N], vy[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
}
sort(a, a + n);
int ans = 0;
for (int i = 0; i < n; i++) {
if (vx[a[i].x].size() < vy[a[i].y].size()) {
for (int j = 0; j < vx[a[i].x].size(); j++) {
int len = a[i].y - vx[a[i].x][j];
if (st.count(pair<int, int>(a[i].x - len, a[i].y)) &&
st.count(pair<int, int>(a[i].x - len, a[i].y - len)))
ans++;
}
} else {
for (int j = 0; j < vy[a[i].y].size(); j++) {
int len = a[i].x - vy[a[i].y][j];
if (st.count(pair<int, int>(a[i].x, a[i].y - len)) &&
st.count(pair<int, int>(a[i].x - len, a[i].y - len)))
ans++;
}
}
st.insert(pair<int, int>(a[i].x, a[i].y));
vx[a[i].x].push_back(a[i].y);
vy[a[i].y].push_back(a[i].x);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int S = 1e5 + 1;
int n;
vector<pair<int, int> > arr;
vector<int> atx[S], aty[S];
int stx[S], sty[S];
bool exists(int x, int y) {
int lo = 0, hi = n, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (arr[mid].first <= x && (arr[mid].first < x || arr[mid].second < y))
lo = mid + 1;
else
hi = mid;
}
if (arr[lo].first == x && arr[lo].second == y) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 0; i < S; ++i) stx[i] = sty[i] = 1;
cin >> n;
arr.resize(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i].first >> arr[i].second;
atx[arr[i].first].push_back(arr[i].second);
aty[arr[i].second].push_back(arr[i].first);
}
sort(arr.begin(), arr.end());
for (int i = 0; i < S; ++i) {
sort(atx[i].begin(), atx[i].end());
sort(aty[i].begin(), aty[i].end());
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int x = arr[i].first, y = arr[i].second;
int q = min(atx[x].size() - stx[x], aty[y].size() - sty[y]);
int ix = stx[x], iy = sty[y];
while (ix < atx[x].size() && iy < aty[y].size()) {
if (atx[x][ix] - y < aty[y][iy] - x)
ix++;
else if (atx[x][ix] - y > aty[y][iy] - x)
iy++;
else {
if (exists(aty[y][iy], atx[x][ix])) {
ans++;
}
ix++;
iy++;
}
}
stx[x]++;
sty[y]++;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Get() {
int res = 0, q = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') q = -1, ch = getchar();
while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0', ch = getchar();
return res * q;
}
const double eps = 1e-12, pi = M_PI;
const int oo = (int)2e9;
const long long INF = (long long)1e17;
const int N = (int)1e5, mod = (int)5e6 + 7, BS = 1234567, TS = 3333331;
typedef int arr[N + 10];
arr up, rt, tup, trt, X, Y, ord;
int n;
int ls[mod], nt[N + 10], to[N + 10];
bool cmp1(const int &a, const int &b) {
return X[a] < X[b] || (X[a] == X[b] && Y[a] > Y[b]);
}
bool cmp2(const int &a, const int &b) {
return Y[a] < Y[b] || (Y[a] == Y[b] && X[a] > X[b]);
}
int Hash(int x, int y) {
return ((long long)x * (long long)BS % mod +
(long long)y * (long long)TS % mod) %
mod;
}
void Insert(int x, int y) {
to[y] = 0;
if (!ls[x])
ls[x] = y;
else {
int k = ls[x];
for (; to[k]; k = to[k])
;
to[k] = y;
}
}
bool Find(int x, int y) {
int ht = Hash(x, y);
for (int k = ls[ht]; k; k = to[k]) {
if (X[k] == x && Y[k] == y) return 1;
}
return 0;
}
int main() {
scanf(
"%d"
"\n",
&n);
for (int i = (1), end = (n); i <= end; ++i)
scanf(
"%d"
"%d"
"\n",
X + i, Y + i),
Insert(Hash(X[i], Y[i]), i), ord[i] = i;
X[0] = Y[0] = oo;
sort(ord + 1, ord + n + 1, cmp1);
for (int i = (1), end = (n); i <= end; ++i)
if (X[ord[i]] == X[ord[i - 1]])
up[ord[i]] = ord[i - 1], tup[ord[i]] = tup[ord[i - 1]] + 1;
sort(ord + 1, ord + n + 1, cmp2);
for (int i = (1), end = (n); i <= end; ++i)
if (Y[ord[i]] == Y[ord[i - 1]])
rt[ord[i]] = ord[i - 1], trt[ord[i]] = trt[ord[i - 1]] + 1;
int ans = 0;
for (int i = (1), end = (n); i <= end; ++i) {
if (tup[i] < trt[i]) {
for (int k = up[i]; k; k = up[k]) {
int l = Y[k] - Y[i];
if (Find(X[i] + l, Y[i]) && Find(X[i] + l, Y[i] + l)) ++ans;
}
} else {
for (int k = rt[i]; k; k = rt[k]) {
int l = X[k] - X[i];
if (Find(X[i], Y[i] + l) && Find(X[i] + l, Y[i] + l)) ++ans;
}
}
}
printf(
"%d"
"\n",
ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
map<pair<int, int>, bool> m;
vector<int> x[100009];
vector<int> y[100009];
for (int f = 0; f < n; f++) {
scanf("%d %d", &a, &b);
x[b].push_back(a);
y[a].push_back(b);
m[make_pair(a, b)] = 1;
}
for (int f = 0; f < 100009; f++) sort(y[f].begin(), y[f].end());
for (int f = 0; f < 100009; f++) sort(x[f].begin(), x[f].end());
long long ans = 0, sq = 314;
for (int f = 0; f < 100009; f++) {
if (x[f].size() > sq) {
for (int f1 = 0; f1 < x[f].size(); f1++) {
for (int f2 = 0; f2 < y[x[f][f1]].size() && y[x[f][f1]][f2] < f; f2++) {
if (x[f][f1] + f - y[x[f][f1]][f2] >= 0 &&
x[f][f1] + f - y[x[f][f1]][f2] < 100009 &&
binary_search(y[x[f][f1] + f - y[x[f][f1]][f2]].begin(),
y[x[f][f1] + f - y[x[f][f1]][f2]].end(), f) &&
x[f][f1] + f - y[x[f][f1]][f2] >= 0 &&
x[f][f1] + f - y[x[f][f1]][f2] < 100009 &&
binary_search(y[x[f][f1] + f - y[x[f][f1]][f2]].begin(),
y[x[f][f1] + f - y[x[f][f1]][f2]].end(),
y[x[f][f1]][f2]))
ans++;
}
}
} else {
for (int f1 = 0; f1 < x[f].size(); f1++) {
for (int f2 = f1 + 1; f2 < x[f].size(); f2++) {
if (x[f][f1] >= 0 && x[f][f1] < 100009 &&
binary_search(y[x[f][f1]].begin(), y[x[f][f1]].end(),
f - x[f][f2] + x[f][f1]) &&
x[f][f2] >= 0 && x[f][f2] < 100009 &&
binary_search(y[x[f][f2]].begin(), y[x[f][f2]].end(),
f - x[f][f2] + x[f][f1]))
ans++;
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxq = 100001;
const int bord = 500;
vector<int> xs[maxq];
bool exists(int x, int y) {
if (x >= maxq) return false;
return binary_search((xs[x]).begin(), (xs[x]).end(), y);
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < (int)(N); ++i) {
int x, y;
scanf("%d%d", &x, &y);
xs[x].push_back(y);
}
for (int i = 0; i < (int)(maxq); ++i) {
sort((xs[i]).begin(), (xs[i]).end());
}
long long ans = 0;
for (int x = 0; x < (int)(maxq); ++x) {
if (xs[x].size() < bord) {
for (int i = 0; i < (int)(xs[x].size()); ++i) {
for (int j = i + 1; j < xs[x].size(); ++j) {
int d = xs[x][j] - xs[x][i];
if (exists(x + d, xs[x][i]) && exists(x + d, xs[x][j])) {
++ans;
}
}
}
} else {
for (int xx = x + 1; xx < maxq; ++xx) {
for (int i = 0; i < (int)(xs[xx].size()); ++i) {
int yy = xs[xx][i];
int d = xx - x;
if (exists(x, yy) && exists(x, yy + d) && exists(xx, yy + d)) {
++ans;
}
}
}
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> x[100002];
vector<int> y[100002];
vector<pair<int, int> > vv;
unordered_set<int> mp[100002];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
x[a].push_back(b);
y[b].push_back(a);
vv.push_back(make_pair(a, b));
mp[a].insert(b);
}
int ans = 0;
for (int i = 0; i < vv.size(); i++) {
int xx = vv[i].first;
int yy = vv[i].second;
if (x[xx].size() > y[yy].size()) {
for (int j = 0; j < y[yy].size(); j++) {
int len = y[yy][j] - xx;
if (len <= 0) continue;
if (yy + len >= 0 && yy + len < 100002 && mp[xx].count(yy + len)) {
if (mp[xx + len].count(yy + len)) {
ans++;
}
}
}
} else {
for (int j = 0; j < x[xx].size(); j++) {
int len = x[xx][j] - yy;
if (len <= 0) continue;
if (xx + len >= 0 && xx + len < 100002 && mp[xx + len].count(yy)) {
if (mp[xx + len].count(yy + len)) {
ans++;
}
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long func(int x, int y) { return 100000 * (long long)x + y; }
vector<pair<pair<int, int>, int> > diag[200100], xaxis[200100], yaxis[200100];
int main() {
int i, j, k, n, X, Y;
cin >> n;
int x[n], y[n], first[n], second[n], third[n];
fill(first, first + n, -1);
fill(second, second + n, -1);
fill(third, third + n, -1);
unordered_map<long long, int> H;
vector<pair<pair<int, int>, int> > v, u;
for (i = 0; i < n; i++) {
scanf("%d %d", &x[i], &y[i]);
H[func(x[i], y[i])] = 1;
v.push_back(make_pair(make_pair(x[i], y[i]), i));
u.push_back(make_pair(make_pair(y[i], x[i]), i));
}
sort(v.begin(), v.end());
sort(u.begin(), u.end());
for (i = 0; i < v.size(); i++) {
X = v[i].first.first;
Y = v[i].first.second;
diag[X - Y + 100050].push_back(v[i]);
xaxis[Y + 100050].push_back(v[i]);
}
for (i = 0; i < u.size(); i++) {
X = u[i].first.second;
Y = u[i].first.first;
yaxis[X + 100050].push_back(u[i]);
}
for (i = 0; i < 200099; i++) {
for (j = diag[i].size() - 1; j >= 0; j--) {
first[diag[i][j].second] = j;
}
for (j = xaxis[i].size() - 1; j >= 0; j--) {
second[xaxis[i][j].second] = j;
}
for (j = yaxis[i].size() - 1; j >= 0; j--) {
third[yaxis[i][j].second] = j;
}
}
int val, x1, y1, cnt = 0;
for (i = 0; i < n; i++) {
if (first[i] < second[i] && first[i] < third[i]) {
val = x[i] - y[i] + 100050;
for (j = 0; j < first[i]; j++) {
x1 = diag[val][j].first.first;
y1 = diag[val][j].first.second;
if (H[func(x1, y[i])]) {
if (H[func(x[i], y1)]) cnt++;
}
}
} else if (second[i] < third[i]) {
val = y[i] + 100050;
for (j = 0; j < second[i]; j++) {
x1 = xaxis[val][j].first.first;
y1 = y[i] + x1 - x[i];
if (H[func(x[i], y1)]) {
if (H[func(x1, y1)]) cnt++;
}
}
} else {
val = x[i] + 100050;
for (j = 0; j < third[i]; j++) {
y1 = yaxis[val][j].first.first;
x1 = x[i] + y1 - y[i];
if (H[func(x1, y[i])]) {
if (H[func(x1, y1)]) cnt++;
}
}
}
}
cout << cnt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100100];
int n;
int kx[100100], ky[100100];
vector<int> first[100100], second[100100];
void read(void) {
cin >> n;
for (int i = 0, x1, y1; i < n; ++i) {
cin >> x1 >> y1;
a[i] = make_pair(x1, y1);
first[x1].push_back(y1);
second[y1].push_back(x1);
}
sort(a, a + n);
for (int i = 0; i < 100100; ++i) {
sort(first[i].begin(), first[i].end());
sort(second[i].begin(), second[i].end());
}
}
void kill(void) {
int ans = 0;
for (int i = 0; i < n; ++i) {
int x1 = a[i].first;
int y1 = a[i].second;
++kx[x1];
++ky[y1];
int d;
if (first[x1].size() < second[y1].size())
for (int j = kx[x1]; j < (int)first[x1].size(); ++j) {
d = first[x1][j] - y1;
if (binary_search(second[y1].begin(), second[y1].end(), x1 + d) &&
binary_search(second[y1 + d].begin(), second[y1 + d].end(), x1 + d))
++ans;
}
else
for (int j = ky[y1]; j < (int)second[y1].size(); ++j) {
d = second[y1][j] - x1;
if (binary_search(first[x1].begin(), first[x1].end(), y1 + d) &&
binary_search(first[x1 + d].begin(), first[x1 + d].end(), y1 + d))
++ans;
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
read();
kill();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long INF = std::numeric_limits<long long>::max();
const int MX = 100101;
const long double PI =
3.14159265358979323846264338327950288419716939937510582097494L;
template <typename T>
pair<T, T> operator+(const pair<T, T> &a, const pair<T, T> &b) {
return pair<T, T>(a.first + b.first, a.second + b.second);
}
template <typename T>
pair<T, T> operator-(const pair<T, T> &a, const pair<T, T> &b) {
return pair<T, T>(a.first - b.first, a.second - b.second);
}
template <typename T>
T operator*(const pair<T, T> &a, const pair<T, T> &b) {
return (a.first * b.first + a.second * b.second);
}
template <typename T>
T operator^(const pair<T, T> &a, const pair<T, T> &b) {
return (a.first * b.second - a.second * b.first);
}
template <typename T>
void print(vector<T> vec, string name = "") {
cout << name;
for (auto u : vec) cout << u << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N;
cin >> N;
vector<pair<int, int>> sk(N);
vector<vector<pair<int, int>>> X(MX), Y(MX);
vector<unordered_set<int>> exists(MX);
for (int i = 0; i < N; ++i) {
cin >> sk[i].first >> sk[i].second;
X[sk[i].first].emplace_back(sk[i].second, i);
Y[sk[i].second].emplace_back(sk[i].first, i);
exists[sk[i].first].insert(sk[i].second);
}
for (auto &&u : X) sort(u.begin(), u.end());
for (auto &&u : Y) sort(u.begin(), u.end());
vector<int> posX(N);
vector<int> posY(N);
for (auto &&mas : X) {
for (int i = 0; i < (int)mas.size(); ++i) posX[mas[i].second] = i;
}
for (auto &&mas : Y) {
for (int i = 0; i < (int)mas.size(); ++i) posY[mas[i].second] = i;
}
int ats = 0;
auto pridekLeft = [&](pair<int, int> prad, pair<int, int> left) -> void {
int len = prad.first - left.first;
ats += int(exists[prad.first].count(prad.second - len) +
exists[left.first].count(left.second - len) ==
2);
};
auto pridekDown = [&](pair<int, int> prad, pair<int, int> down) -> void {
int len = prad.second - down.second;
if (prad.first - len >= 0 and down.first - len >= 0)
ats += int(exists[prad.first - len].count(prad.second) +
exists[down.first - len].count(down.second) ==
2);
};
for (int i = 0; i < N; ++i) {
if (posX[i] < posY[i]) {
for (int j = 0; j < posX[i]; ++j) {
pridekDown(sk[i], {sk[i].first, X[sk[i].first][j].first});
}
} else {
for (int j = 0; j < posY[i]; ++j) {
pridekLeft(sk[i], {Y[sk[i].second][j].first, sk[i].second});
}
}
}
printf("%d\n", ats);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const int N = 100010;
const int D = 500;
const int de = 100010;
int n, i, j, k, l, p, k1, k2, d, g, x, y, z;
long long ans;
pair<int, int> a[N], b[N], c[N];
bool cmp(pair<int, int> a, pair<int, int> b) {
return make_pair(a.second, a.first) < make_pair(b.second, b.first);
}
bool vis[N * 4];
bool find(int x, int y) {
int p = lower_bound(a + 1, a + 1 + n, make_pair(x, y)) - a;
return (a[p] == make_pair(x, y));
}
int main() {
read(n);
for (i = 1; i <= n; i++) read(a[i].first, a[i].second);
sort(a + 1, a + 1 + n);
for (i = 1; i <= n; i = j + 1) {
for (j = i; j <= n && a[j].first == a[i].first; j++)
;
j--;
if (j - i + 1 > D) vis[a[j].first + de] = 1;
}
for (i = 1; i <= n; i = j + 1) {
for (j = i; j <= n && a[j].first == a[i].first; j++)
;
j--;
if (j - i + 1 <= D) {
for (k1 = i; k1 <= j; k1++)
for (k2 = k1 + 1; k2 <= j; k2++) {
d = a[k2].second - a[k1].second;
if (vis[a[k1].first - d + de])
if (find(a[k1].first - d, a[k1].second) &&
find(a[k2].first - d, a[k2].second))
ans++;
if (find(a[k1].first + d, a[k1].second) &&
find(a[k2].first + d, a[k2].second))
ans++;
}
} else {
for (k = i; k <= j; k++) b[++g] = a[k], c[g] = a[k];
}
}
sort(b + 1, b + 1 + g, cmp);
for (i = 1; i <= g; i = j + 1) {
for (j = i; j <= g && b[j].second == b[i].second; j++)
;
j--;
for (k1 = i; k1 <= j; k1++)
for (k2 = k1 + 1; k2 <= j; k2++) {
d = b[k2].first - b[k1].first;
if (find(b[k1].first, b[k1].second + d) &&
find(b[k2].first, b[k2].second + d))
ans++;
}
}
cout << ans << endl;
scanf("\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("-Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int N = 1e5 + 5;
int n, x, y, ans, px[N], py[N];
vector<int> sx[N], sy[N];
unordered_map<int, bool> Mx[N], My[N];
struct Point {
int x, y;
bool operator<(const Point& p) const {
if (this->x + this->y != p.x + p.y) return (this->x + this->y < p.x + p.y);
return this->x < p.x;
}
};
vector<Point> p;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x >> y, sx[x].push_back(y), sy[y].push_back(x), Mx[x][y] = true,
My[y][x] = true;
Point pp;
pp.x = x, pp.y = y;
p.push_back(pp);
}
for (int i = 0; i < N; i++)
sort(sx[i].begin(), sx[i].end()), sort(sy[i].begin(), sy[i].end());
sort(p.begin(), p.end());
for (int i = 0; i < p.size(); i++) {
Point pp = p[i];
x = pp.x, y = pp.y;
px[x]++, py[y]++;
if (sx[x].size() < sy[y].size()) {
for (int i = px[x]; i < sx[x].size(); i++) {
int y2 = sx[x][i];
int x2 = x + y2 - y;
if (x2 < N and Mx[x2][y] and Mx[x2][y2]) ans++;
}
} else {
for (int i = py[y]; i < sy[y].size(); i++) {
int x2 = sy[y][i];
int y2 = y + x2 - x;
if (y2 < N and My[y2][x] and My[y2][x2]) ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long hashval(const pair<int, int> &v) {
return v.first * 239017LL + v.second;
}
int main() {
unordered_map<int, vector<int> > by_x, by_y;
unordered_set<long long> Hashes;
int x, y, n;
cin >> n;
vector<pair<int, int> > pts(n);
for (int i = 0; i < n; i++) {
cin >> x >> y;
by_x[x].push_back(y);
by_y[y].push_back(x);
pts[i] = make_pair(x, y);
Hashes.insert(hashval(make_pair(x, y)));
}
int ans = 0;
for (int i = 0; i < n; i++) {
x = pts[i].first;
y = pts[i].second;
const vector<int> &xc = by_x[x];
const vector<int> &yc = by_y[y];
if (xc.size() < yc.size()) {
for (int other_y : xc)
if (other_y > y) {
int len = other_y - y;
if (Hashes.count(hashval(make_pair(x + len, y))) &&
Hashes.count(hashval(make_pair(x + len, y + len))))
ans++;
}
} else {
for (int other_x : yc)
if (other_x > x) {
int len = other_x - x;
if (Hashes.count(hashval(make_pair(x, y + len))) &&
Hashes.count(hashval(make_pair(x + len, y + len))))
ans++;
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 100005;
set<int> X;
vector<int> pts[N];
unordered_set<int> Y[N];
vector<pair<int, int> > store;
const int MAGIC = 350;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
X.insert(x);
Y[x].insert(y);
pts[x].push_back(y);
}
long long ans = 0;
for (int x : X) {
if (pts[x].size() < MAGIC) {
sort(pts[x].begin(), pts[x].end());
for (int i = 0; i < pts[x].size(); i++) {
for (int j = i + 1; j < pts[x].size(); j++) {
int y1 = pts[x][i], y2 = pts[x][j];
int len = y2 - y1;
if (x >= len and Y[x - len].count(y1) and Y[x - len].count(y2)) {
ans++;
}
}
}
} else {
for (int i = 0; i < store.size(); i++) {
int x1 = store[i].first;
int y1 = store[i].second;
int len = x - x1;
if (Y[x].count(y1) and Y[x].count(y1 - len) and Y[x1].count(y1 - len)) {
ans++;
}
}
}
for (int y : pts[x]) {
store.push_back(make_pair(x, y));
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int sqrtmaxn = (int)sqrt(maxn + .0) + 1;
vector<int> vec[maxn];
inline bool find(int x, int y) {
if (x >= maxn) return false;
return binary_search(vec[x].begin(), vec[x].end(), y);
}
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
vec[x].push_back(y);
}
for (int i = 0; i < maxn; ++i) sort(vec[i].begin(), vec[i].end());
long long ans = 0;
for (int x = 0; x < maxn; ++x) {
if (vec[x].size() < sqrtmaxn) {
for (int i = 0; i < vec[x].size(); ++i) {
for (int j = i + 1; j < vec[x].size(); ++j) {
int d = vec[x][j] - vec[x][i];
if (find(x + d, vec[x][i]) && find(x + d, vec[x][j])) ++ans;
}
}
} else {
for (int xx = x + 1; xx < maxn; ++xx) {
for (int i = 0; i < vec[xx].size(); ++i) {
int yy = vec[xx][i], d = xx - x;
if (find(x, yy) && find(x, yy + d) && find(xx, yy + d)) ++ans;
}
}
}
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void Min(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void Max(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T euclide(T a, T b, T &x, T &y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
const int mod = (int)1e9 + 7;
const int inf = 0x7fffffff;
int n, x, y;
vector<int> ve[200001];
bool exist(int index, int xx) {
return binary_search(ve[index].begin(), ve[index].end(), xx);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
ve[y].push_back(x);
}
for (int i = 0; i <= 100000; i++)
if ((int)ve[i].size() > 0) sort(ve[i].begin(), ve[i].end());
int tmp = sqrt((double)n);
int ans = 0;
for (int i = 0; i <= 100000; i++) {
if ((int)ve[i].size() > tmp) {
for (int j = i + 1; j <= 100000; j++) {
int d = j - i;
for (int k = 0; k < ve[j].size(); k++)
if (exist(i, ve[j][k]) && exist(j, ve[j][k] + d) &&
exist(i, ve[j][k] + d))
ans++;
}
} else {
for (int j = 0; j < ve[i].size(); j++)
for (int k = j + 1; k < ve[i].size(); k++) {
int d = ve[i][k] - ve[i][j];
if (exist(i + d, ve[i][k]) && exist(i + d, ve[i][j])) ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> g[N], g2[N];
int n;
long long ret;
int main() {
scanf("%d", &n);
for (int i = 0, x, y; i < n; ++i) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g2[y].push_back(x);
}
for (int i = 0; i < N; ++i) {
sort(g[i].begin(), g[i].end());
sort(g2[i].begin(), g2[i].end());
}
for (int x = 0; x < N; ++x) {
for (auto y : g[x]) {
int l = upper_bound(g[x].begin(), g[x].end(), y) - g[x].begin();
int r = upper_bound(g2[y].begin(), g2[y].end(), x) - g2[y].begin();
while (l < (int)g[x].size() && r < (int)g2[y].size()) {
int yy = g[x][l], xx = g2[y][r];
if (xx - x < yy - y)
++r;
else if (xx - x > yy - y)
++l;
else {
ret += binary_search(g[xx].begin(), g[xx].end(), yy);
++l, ++r;
}
}
}
}
printf("%lld\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, a, b;
map<pair<long, long>, long> have;
vector<long> x[200000], y[200000];
long ans;
long p1, p2, pos[200000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
x[a].push_back(b);
y[b].push_back(a);
have[make_pair(a, b)] = 1;
}
for (int i = 0; i <= 100000; i++)
sort(x[i].begin(), x[i].end()), sort(y[i].begin(), y[i].end());
for (int tx = 0; tx <= 100000; tx++) {
for (int i = 0; i < x[tx].size(); i++) {
long ty = x[tx][i];
p1 = i + 1;
p2 = pos[ty] + 1;
while (p1 < x[tx].size() && p2 < y[ty].size()) {
if (x[tx][p1] - ty == y[ty][p2] - tx &&
have[make_pair(y[ty][p2], x[tx][p1])] == 1)
++ans;
if (x[tx][p1] - ty < y[ty][p2] - tx)
++p1;
else
++p2;
}
++pos[ty];
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double n;
int a, b, c, ans = 0;
cin >> n >> a >> b >> c;
for (int i = min(int(n / 2), c); i >= 0; i--) {
for (int j = min(int(n - 2 * i), b); j >= 0; j--) {
if (a / 2 + j + i * 2 >= n) {
ans++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, num = 0;
while (cin >> n >> a >> b >> c) {
for (int i = 0; i <= a; i++) {
for (int j = 0; j <= b; j++) {
if ((n - i / 2 - j) >= 0 && ((n - i / 2 - j) / 2) <= c &&
(2 * n - i - 2 * j) % 4 == 0) {
num++;
}
}
}
cout << num << endl;
num = 0;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.