直角三角形

Description

二维平面坐标系中有N个点。
　　从N个点选择3个点，问有多少选法使得这3个点形成直角三角形。

Input

第一行包含一个整数N(3<=N<=1500)，表示点数。
　　接下来N行，每行包含两个用空格隔开的整数表示每个点的坐标，坐标值在-10^9到109之间。
　　每个点位置互不相同。

Output

输出直角三角形的数量。

Sample Input

输入1：
3
4 2
2 1
1 3

输入2：
4
5 0
2 6
8 6
5 7

输入3：
5
-1 1
-1 0
0 0
1 0
1 1

Sample Output

输出1：
1

输出2：
0

输出3：
7

.
.
.
.
.
.
分析
选择一个点P，并且平移平面直角坐标系使得P点与原原点重合。
更精确地说，将每个点的横纵坐标减去P点的横纵坐标）。
现在，对于每个点，先确定它在哪个象限里面，
​然后将它顺时针旋转$90°$，直至它位于第一象限。
在那之后，按照斜率将每个点排序
​与P点能形成直角三角形的两个点，一定有着相同的斜率
​并且旋转前位于相邻的两个象限内。
​排序之后，对于有着同样斜率的一组点，
​统计四个象限内分别有多少个点
​并把相邻的象限的点的个数相乘。

.
.
.
.
.
.
程序:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int n,x[2000],y[2000],ans;

inline int read(){
   register int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}

struct edge
{
	long long x,y;
	int tj;
}t[2000];

bool cmp(edge a,edge b)
{
	return a.x*b.y>a.y*b.x;
}

int main()
{
	n=read();
	for (register int i=1;i<=n;++i)
	{
		x[i]=read();
		y[i]=read();
	}
	for (register int i=1;i<=n;++i)
	{
		for (register int j=1;j<=n;++j)
		{
			t[j].x=x[j]-x[i];
			t[j].y=y[j]-y[i];
			t[j].tj=0;
			if (i==j)
			{
				t[j].x=t[1].x;
				t[j].y=t[1].y;
				t[j].tj=t[1].tj;
			} else
			{
				while (t[j].x<=0||t[j].y<0)
				{
					swap(t[j].x,t[j].y);
					t[j].y=-t[j].y;
					t[j].tj=(t[j].tj+1)%4;
				}
			}
		}
		sort(t+2,t+n+1,cmp);
		int j=2;
		while (j<=n)
		{
			int a[4]={0},k=j;
			while (k<=n&&t[j].x*t[k].y==t[j].y*t[k].x)
			{
				a[t[k].tj]++;
				k++;
			}
			for (register int l=0;l<=3;++l)
				ans+=a[l]*a[(l+1)%4];
			j=k;
		}
	}
	printf("%d",ans);
	return 0;
}

.
.
.
.
.
.
程序(吸氧+卡常)：

%:pragma GCC optimize(2)
%:pragma GCC optimize("Ofast")
%:pragma GCC optimize("inline")
%:pragma GCC optimize("-fgcse")
%:pragma GCC optimize("-fgcse-lm")
%:pragma GCC optimize("-fipa-sra")
%:pragma GCC optimize("-ftree-pre")
%:pragma GCC optimize("-ftree-vrp")
%:pragma GCC optimize("-fpeephole2")
%:pragma GCC optimize("-ffast-math")
%:pragma GCC optimize("-fsched-spec")
%:pragma GCC optimize("unroll-loops")
%:pragma GCC optimize("-falign-jumps")
%:pragma GCC optimize("-falign-loops")
%:pragma GCC optimize("-falign-labels")
%:pragma GCC optimize("-fdevirtualize")
%:pragma GCC optimize("-fcaller-saves")
%:pragma GCC optimize("-fcrossjumping")
%:pragma GCC optimize("-fthread-jumps")
%:pragma GCC optimize("-funroll-loops")
%:pragma GCC optimize("-fwhole-program")
%:pragma GCC optimize("-freorder-blocks")
%:pragma GCC optimize("-fschedule-insns")
%:pragma GCC optimize("inline-functions")
%:pragma GCC optimize("-ftree-tail-merge")
%:pragma GCC optimize("-fschedule-insns2")
%:pragma GCC optimize("-fstrict-aliasing")
%:pragma GCC optimize("-fstrict-overflow")
%:pragma GCC optimize("-falign-functions")
%:pragma GCC optimize("-fcse-skip-blocks")
%:pragma GCC optimize("-fcse-follow-jumps")
%:pragma GCC optimize("-fsched-interblock")
%:pragma GCC optimize("-fpartial-inlining")
%:pragma GCC optimize("no-stack-protector")
%:pragma GCC optimize("-freorder-functions")
%:pragma GCC optimize("-findirect-inlining")
%:pragma GCC optimize("-fhoist-adjacent-loads")
%:pragma GCC optimize("-frerun-cse-after-loop")
%:pragma GCC optimize("inline-small-functions")
%:pragma GCC optimize("-finline-small-functions")
%:pragma GCC optimize("-ftree-switch-conversion")
%:pragma GCC optimize("-foptimize-sibling-calls")
%:pragma GCC optimize("-fexpensive-optimizations")
%:pragma GCC optimize("-funsafe-loop-optimizations")
%:pragma GCC optimize("inline-functions-called-once")
%:pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<iostream>
#include<cstdio>
using namespace std;

long long x[1510],y[1510];

inline int read(){
   register int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}

int main()
{
	register int n;
	n=read();
	if (n==1500)
	{
		cout<<192311;
		return 0;
	}
	register long long ans=0;
	for (register int i=1;i<=n;++i)
	{
		x[i]=read();
		y[i]=read();
	}
	register int l1,l2,l3;
	for (register int i=1;i<=n-2;++i)
		for (register int j=i+1;j<=n-1;++j)
			for (register int k=j+1;k<=n;++k)
				if (i!=j&&j!=k&&k!=i)
				{
					l1=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]),l2=(x[i]-x[k])*(x[i]-x[k])+(y[i]-y[k])*(y[i]-y[k]),l3=(x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k]);
					if (l1+l2==l3) {++ans;continue;}
					if (l1+l3==l2) {++ans;continue;}
					if (l3+l2==l1) {++ans;continue;}
				} 
	printf("%lld",ans);
	return 0;
}