label
stringlengths 1
2
| index
stringlengths 1
5
| code
stringlengths 87
8.24k
|
|---|---|---|
64 | 31500 | int main()
{
struct point
{
int x,y,z;
};
struct point p[10];
struct distance
{
struct point p1;
struct point p2;
float dis;
};
struct distance d[45];
struct distance temp;
int i,n,j,k;
float pf;
scanf("%d",&n);
k=0;
for(i=0;i<n;i++)
{
scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
}
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
d[k].p1=p[i];
d[k].p2=p[j];
pf=(float)(p[i].x-p[j].x)*(p[i].x-p[j].x)+(p[i].y-p[j].y)*(p[i].y-p[j].y)+(p[i].z-p[j].z)*(p[i].z-p[j].z);
d[k].dis=sqrt(pf);
k++;
}
}
for(i=0;i<n*(n-1)/2-1;i++)
{
for(j=0;j<n*(n-1)/2-i;j++)
{
if(d[j].dis<d[j+1].dis)
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}
}
for(i=0;i<n*(n-1)/2;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",d[i].p1.x,d[i].p1.y,d[i].p1.z,d[i].p2.x,d[i].p2.y,d[i].p2.z,d[i].dis);
}
return 0;
}
|
64 | 31501 | struct Line
{
int n1;
int n2;
double dis;
};
int main()
{
double distance(double a[3],double b[3]);
struct Line l[55];
double num[10][3],td;
int n,i,j,k,p,q,t,num1[10][3];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%lf%lf%lf",&num[i][0],&num[i][1],&num[i][2]);
}
k=0;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
l[k].dis=distance(num[i],num[j]);
l[k].n1=i;
l[k].n2=j;
k++;
}
}
for(q=1;q<k;q++)
{
for(p=0;p<k-q;p++)
{
if(l[p].dis<l[p+1].dis)
{
t=l[p].n1;l[p].n1=l[p+1].n1;l[p+1].n1=t;
t=l[p].n2;l[p].n2=l[p+1].n2;l[p+1].n2=t;
td=l[p].dis;l[p].dis=l[p+1].dis;l[p+1].dis=td;
}
}
}
for(i=0;i<n;i++)
{
num1[i][0]=(int)num[i][0];
num1[i][1]=(int)num[i][1];
num1[i][2]=(int)num[i][2];
}
for(i=0;i<k;i++)
{
p=l[i].n1;
q=l[i].n2;
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",num1[p][0],num1[p][1],num1[p][2],num1[q][0],num1[q][1],num1[q][2],l[i].dis);
}
return 0;
}
double distance(double a[3],double b[3])
{
double m;
m=sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])+(a[2]-b[2])*(a[2]-b[2]));
return m;
}
|
64 | 31502 | struct distance
{
double length;
int start;
int end;
};
main()
{
int n;
scanf("%d",&n);
int point[10][4];
int i,j;
struct distance dist[45];
for (i=0;i<n;i++)
scanf("%d %d %d",&point[i][1],&point[i][2],&point[i][3]);
int k=0;
for (i=0;i<n-1;i++)
for (j=i+1;j<n;j++)
{
dist[k].length=sqrt((point[i][1]-point[j][1])*(point[i][1]-point[j][1])+(point[i][2]-point[j][2])*(point[i][2]-point[j][2])+(point[i][3]-point[j][3])*(point[i][3]-point[j][3]));
dist[k].start=i;
dist[k].end=j;
k++;
}
double temp;
int temp1;
for (i=0;i<k-1;i++)
for (j=0;j<k-1-i;j++)
if (dist[j].length<dist[j+1].length)
{
temp=dist[j].length;
dist[j].length=dist[j+1].length;
dist[j+1].length=temp;
temp1=dist[j].start;
dist[j].start=dist[j+1].start;
dist[j+1].start=temp1;
temp1=dist[j].end;
dist[j].end=dist[j+1].end;
dist[j+1].end=temp1;
}
for (i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",point[dist[i].start][1],point[dist[i].start][2],point[dist[i].start][3],point[dist[i].end][1],point[dist[i].end][2],point[dist[i].end][3],dist[i].length);
}
getchar();getchar();
}
|
64 | 31503 | struct dian
{
int z[6];
double d;
};
double ju(int x[3],int y[3])
{
double d;
d=sqrt((x[0]-y[0])*(x[0]-y[0])+(x[1]-y[1])*(x[1]-y[1])+(x[2]-y[2])*(x[2]-y[2]));
return d;
}
int main()
{
int n,i,j,a[20][3],x=0;
struct dian num[50];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&a[i][0],&a[i][1],&a[i][2]);
}
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
num[x].z[0]=a[i][0];
num[x].z[1]=a[i][1];
num[x].z[2]=a[i][2];
num[x].z[3]=a[j][0];
num[x].z[4]=a[j][1];
num[x].z[5]=a[j][2];
num[x].d=ju(a[i],a[j]);
x++;
}
}
n=n*(n-1)/2;
for(i=0;i<n-1;i++)
{
for(j=0;j<n-i-1;j++)
{
if(num[j].d<num[j+1].d)
{
num[49]=num[j+1];
num[j+1]=num[j];
num[j]=num[49];
}
}
}
for(i=0;i<n;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",num[i].z[0],num[i].z[1],num[i].z[2],num[i].z[3],num[i].z[4],num[i].z[5],num[i].d);
}
return 0;
} |
64 | 31504 | //
// main.cpp
// ????
//
// Created by ???? on 13-11-6.
// Copyright (c) 2013? ????. All rights reserved.
//
int main()
{
int a[11][4];
int k=1;
float b[100][3];
//input
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i][1]>>a[i][2]>>a[i][3];
}
//end of input
//the distence into b
for(int i=1;i<n;i++)
{
for(int j=i+1;j<=n;j++)
{
double dis= (a[i][1]-a[j][1])*(a[i][1]-a[j][1])
+(a[i][2]-a[j][2])*(a[i][2]-a[j][2])
+(a[i][3]-a[j][3])*(a[i][3]-a[j][3]);
b[k][0]=sqrt(dis);
b[k][1]=i;
b[k][2]=j;
k++;
}
}
//sort
for(int i=1;i<=k-1;i++)
{
for(int j=k-1;j>=i+1;j--)
{
if(b[j][0]>b[j-1][0])
{
float t0=b[j][0];
b[j][0]=b[j-1][0];
b[j-1][0]=t0;
int t1=b[j][1];
b[j][1]=b[j-1][1];
b[j-1][1]=t1;
int t2=b[j][2];
b[j][2]=b[j-1][2];
b[j-1][2]=t2;
}
}
}
//cout<<b[1][0]<<' '<<b[2][0]<<endl;
//cout
for(int j=1;j<=k-1;j++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[ (int)b[j][1] ][1],a[ (int)b[j][1] ][2],a[ (int)b[j][1] ][3],
a[ (int)b[j][2] ][1],a[ (int)b[j][2] ][2],a[ (int)b[j][2] ][3],
b[j][0]);
}
return 0;
}
|
64 | 31505 | int main()
{
struct jl
{int a1;int b1;int c1;int a2;int b2;int c2;float d;}hz[100],t;
int n,i,j,a[10],b[10],c[10],k=0;
double w;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&a[i],&b[i],&c[i]);
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
w=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
hz[k].a1=a[i];hz[k].b1=b[i];hz[k].c1=c[i];
hz[k].a2=a[j];hz[k].b2=b[j];hz[k].c2=c[j];
hz[k].d=w;
k++;
}
}
if(k==1)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[0],b[0],c[0],a[1],b[1],c[1],w);
else
{
for(i=0;i<k-1;i++)
for(j=0;j<k-i-1;j++)
{
if(hz[j].d<hz[j+1].d)
{
t=hz[j];
hz[j]=hz[j+1];
hz[j+1]=t;
}
}
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",hz[i].a1,hz[i].b1,hz[i].c1,hz[i].a2,hz[i].b2,hz[i].c2,hz[i].d);
}
return 0;
} |
64 | 31506 | /*
* julipaixu.cpp
* ??:??????????n??????
* Created on: 2012-11-7
* Author: ???
*/
int main()
{
int n,i=0,j=0,k=0; //????,n??????
double t1,d; //????????
int t2,t3; //????????
cin>>n; //??n
int point[3][n], num[2][n*(n-1)/2];//??????point,num??????????
double distance [n*(n-1)/2];//??????distance,??????
for(i=0;i<n;i++) //??????
cin>>point[0][i]>>point[1][i]>>point[2][i];
for(i=0;i<n-1;i++) //????,????????,????????
for(j=i+1;j<n;j++)
{
d=(point[0][i]-point[0][j])*(point[0][i]-point[0][j])
+(point[1][i]-point[1][j])*(point[1][i]-point[1][j])
+(point[2][i]-point[2][j])*(point[2][i]-point[2][j]);
distance[k]=sqrt(d);
num[0][k]=i;
num[1][k]=j;
k++;
}
for(j=1;j<n*(n-1)/2;j++) //????????????,?????num?????
for(i=0;i<(n*(n-1)/2)-j;i++)
if(distance[i]<distance[i+1])
{
t1=distance[i+1];
distance[i+1]=distance[i];
distance[i]=t1;
t2=num[0][i+1];
num[0][i+1]=num[0][i];
num[0][i]=t2;
t3=num[1][i+1];
num[1][i+1]=num[1][i];
num[1][i]=t3;
}
for(k=0;k<n*(n-1)/2;k++) //?????????
{
i=num[0][k];
j=num[1][k];
cout<<'('<<point[0][i]<<','<<point[1][i]<<','<<point[2][i]<<")-("
<<point[0][j]<<','<<point[1][j]<<','<<point[2][j]<<")="
<<fixed<<setprecision(2)<<distance[k]<<endl;
}
return 0;
} |
64 | 31507 |
int main(){
int n,i,j,k=0,Nline,dx,dy,dz;
scanf("%d",&n); //??????
struct Dot{
int x,y,z;
} dots[n]; //????,????????
Nline=n*(n-1)/2; //??????(????????)
for(i=0;i<n;i++)
{
scanf("%d %d %d",&dots[i].x,&dots[i].y,&dots[i].z); //??????
}
struct Line{
int x1,y1,z1;
int x2,y2,z2;
float dist;
} lines[Nline],temp; //???????????-???????????
for(i=0;i<n;i++){ //??????
for(j=(i+1);j<n;j++)
{
lines[k].x1=dots[i].x;
lines[k].y1=dots[i].y;
lines[k].z1=dots[i].z;
lines[k].x2=dots[j].x;
lines[k].y2=dots[j].y;
lines[k].z2=dots[j].z;
dx=lines[k].x1-lines[k].x2;
dy=lines[k].y1-lines[k].y2;
dz=lines[k].z1-lines[k].z2;
lines[k].dist=sqrt(dx*dx+dy*dy+dz*dz);
k++;
}
}
for(i=0;i<Nline-1;i++)//??Nline?
{
for(j=0;j<Nline-i;j++)
{
if(lines[j].dist<lines[j+1].dist)
{
temp=lines[j];
lines[j]=lines[j+1];
lines[j+1]=temp;
}
}
}
for(i=0;i<Nline;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",lines[i].x1,lines[i].y1,lines[i].z1,lines[i].x2,lines[i].y2,lines[i].z2,lines[i].dist);
// printf("%d",i);
}
return 0;
}
|
64 | 31508 | struct dot{
int x;
int y;
int z;
}dots[10];
struct dist{
int d1;
int d2;
float dis;
}dists[45];
int cmp(const void *p1,const void *p2)
{
struct dist l1,l2;
l1=*(struct dist *)p1;
l2=*(struct dist *)p2;
if(l1.dis>l2.dis)
{
return -1;
}else if(l1.dis<l2.dis)
{
return 1;
}else{
if(l1.d1!=l2.d1)
{
return l1.d1-l2.d1;
}else{
return l1.d2-l2.d2;
}
}
return 0;
}
int main()
{
int n,i,j,t=0;
scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d%d%d",&dots[i].x,&dots[i].y,&dots[i].z);
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
dists[t].d1=i;
dists[t].d2=j;
dists[t].dis=sqrt((dots[i].x-dots[j].x)*(dots[i].x-dots[j].x)+(dots[i].y-dots[j].y)*(dots[i].y-dots[j].y)+(dots[i].z-dots[j].z)*(dots[i].z-dots[j].z));
t++;
}
}
qsort(&dists[0],t,sizeof(struct dist),cmp);
for(i=0;i<t;i++)printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",dots[dists[i].d1].x,dots[dists[i].d1].y,dots[dists[i].d1].z,dots[dists[i].d2].x,dots[dists[i].d2].y,dots[dists[i].d2].z,dists[i].dis);
return 0;
}
|
64 | 31509 | struct zuhe {
int a[3];
int b[3];
double m;
};
int main()
{ struct zuhe z[50];
struct zuhe b;
int l,i,j,n,m,k=0;
int s[100][4];
scanf("%d",&n);
for(i=0;i<n;i++){
for(j=0;j<3;j++)
scanf("%d",&s[i][j]);
}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
for(l=0;l<3;l++){
z[k].a[l]=s[i][l];
z[k].b[l]=s[j][l];
}
z[k].m=pow((s[i][0]-s[j][0])*(s[i][0]-s[j][0])+(s[i][1]-s[j][1])*(s[i][1]-s[j][1])+(s[i][2]-s[j][2])*(s[i][2]-s[j][2]),0.5);
k=k+1;
}
}
for(i=1;i<n*(n-1)/2;i++){
for(j=0;j<n*(n-1)/2-i;j++){
if(z[j].m<z[j+1].m){
b=z[j];
z[j]=z[j+1];
z[j+1]=b;
}
}
}
for(i=0;i<n*(n-1)/2;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",z[i].a[0],z[i].a[1],z[i].a[2],z[i].b[0],z[i].b[1],z[i].b[2],z[i].m);
return 0;
} |
64 | 31510 |
const double EPS=1e-6;
int main()
{
int a[10][3],c[50],n,z=0;
cin>>n;
for(int i=0;i<50;++i)
{c[i]=i;}
for(int i=0;i<n;++i)
{cin>>a[i][0]>>a[i][1]>>a[i][2];}
struct MyStruct
{
double d;
int x;
int y;
}b[50];
for(int i=0;i<n;++i)
for(int j=i+1;j<n;++j)
{
b[z].d =floor((100*sqrt( (a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2])))+0.5)/100;
b[z].x=i;
b[z].y=j;
++z;
}
for(int i=0;i<n*(n-1)/2;++i)
for(int j=0;i+j<n*(n-1)/2-1;++j)
{
if((b[c[j+1]].d - b[c[j]].d)> EPS)
{
int temp=c[j];
c[j]=c[j+1];
c[j+1]=temp;
}
else if((fabs(b[c[j+1]].d - b[c[j]].d)<EPS))
{
if(b[c[j+1]].x<b[c[j]].x)
{
int temp=c[j];
c[j]=c[j+1];
c[j+1]=temp;
}
}
}
for(int i=0;i<n*(n-1)/2;++i)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[b[c[i]].x][0],a[b[c[i]].x][1],a[b[c[i]].x][2],a[b[c[i]].y][0],a[b[c[i]].y][1],a[b[c[i]].y][2],b[c[i]].d);
}
return 0;
}
|
64 | 31511 | int main(){
int a[10][3],n;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
for(int j=0;j<3;j++)
{
scanf("%d",&a[i][j]);
}
}
struct{
int x1,x2,y1,y2,z1,z2;
double d;
}dis[45],mid;
int m=0;
for(int k=0;k<n-1;k++)
{
for(int l=k+1;l<n;l++)
{
dis[m].x1=a[k][0];
dis[m].x2=a[l][0];
dis[m].y1=a[k][1];
dis[m].y2=a[l][1];
dis[m].z1=a[k][2];
dis[m].z2=a[l][2];
dis[m].d=sqrt((dis[m].x1-dis[m].x2)*(dis[m].x1-dis[m].x2)+(dis[m].y1-dis[m].y2)*(dis[m].y1-dis[m].y2)+(dis[m].z1-dis[m].z2)*(dis[m].z1-dis[m].z2));
m++;
}
}
for(int j = 1 ; j <= m ; j++){
for(int p=0; p<m-j; p++){
if(dis[p].d < dis[p+1].d){
mid= dis[p+1];
dis[p+1]=dis[p];
dis[p]=mid;
}
}
}
for(int w=0;w<m;w++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dis[w].x1,dis[w].y1,dis[w].z1,dis[w].x2,dis[w].y2,dis[w].z2,dis[w].d);
}
return 0;
}
|
64 | 31512 |
int main()
{
int n,i,j,k,p,l;
double x[10],y[10],z[10],m;
double d[100],c[100];
int a[100],b[100];
scanf("%d",&n);
for(i=0;i<=n-1;++i)
{
scanf("%lf%lf%lf",&x[i],&y[i],&z[i]);
}
k=0;
for(i=0;i<=n-2;++i)
{
for(j=i+1;j<=n-1;++j)
{
d[k]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*
(z[i]-z[j]));
a[k]=i;
b[k]=j;
c[k]=d[k];
k++;
}
}
for(i=0;i<=k-2;++i)
{
for(j=i+1;j<=k-1;++j)
{
if(c[i]<c[j])
{
m=c[i];
c[i]=c[j];
c[j]=m;
}
}
}
for(i=0;i<=k-1;++i)
{
for(j=0;j<=k-1;++j)
{
if(c[i]==d[j])
{
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",x[a[j]],y[a[j
]],z[a[j]],x[b[j]],y[b[j]],z[b[j]],c[i]);
d[j]=-1;
}
}
}
return 0;
}
|
64 | 31513 | int main()
{
struct point
{
int x;
int y;
int z;
}Point[10];
int n,i,j,k=0,f[45],b[45],temp;
double d[45],num;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&Point[i].x,&Point[i].y,&Point[i].z);
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
d[k]=sqrt((Point[i].x-Point[j].x)*(Point[i].x-Point[j].x)+(Point[i].y-Point[j].y)*(Point[i].y-Point[j].y)+(Point[i].z-Point[j].z)*(Point[i].z-Point[j].z));
f[k]=i;
b[k]=j;
k=k+1;
}
}
for(i=0;i<k;i++)
{
for(j=0;j<k-i;j++)
{
if(d[j]<d[j+1])
{
temp=f[j];
f[j]=f[j+1];
f[j+1]=temp;
temp=b[j];
b[j]=b[j+1];
b[j+1]=temp;
num=d[j];
d[j]=d[j+1];
d[j+1]=num;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",Point[f[i]].x,Point[f[i]].y,Point[f[i]].z,Point[b[i]].x,Point[b[i]].y,Point[b[i]].z,d[i]);
}
return 0;
} |
64 | 31514 | int main()
{
int x[100][30],i,j,k=0,m,n,p;
double s[1000],a;
scanf("%d",&n);
m=n*(n-1)/2;
for(i=0;i<n;i++){
for(j=0;j<3;j++){
scanf("%d",&x[i][j]);
}
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
s[k]=sqrt((pow(x[i][0]-x[j][0],2)+pow(x[i][1]-x[j][1],2)+pow(x[i][2]-x[j][2],2))*1.0);
k++;
}
}
for(i=1;i<k;i++){
for(j=0;j<k-i;j++){
if(s[j]>s[j+1]){
a=s[j];
s[j]=s[j+1];
s[j+1]=a;
}
}
}
s[k]=-1;
for(p=k-1;p>=0;p--){
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(s[p]!=s[p-1]){
if(sqrt((pow(x[i][0]-x[j][0],2)+pow(x[i][1]-x[j][1],2)+pow(x[i][2]-x[j][2],2))*1.0)==s[p])
{printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[i][0],x[i][1],x[i][2],x[j][0],x[j][1],x[j][2],s[p]);}}
}
}
}
return 0;
}
|
64 | 31515 | int main(){
struct dian{
int x,y,z;
}dians[45];
struct suoyou{
struct dian qian;
struct dian hou;
double ji;
}suoyous[45],e;
int n;
scanf("%d",&n);
int i;
for(i=0;i<n;i++){
scanf("%d%d%d",&dians[i].x,&dians[i].y,&dians[i].z);
}
int k,l=0;
for(i=0;i<n;i++){
for(k=i+1;k<n;k++){
suoyous[l].qian=dians[i];
suoyous[l].hou=dians[k];
suoyous[l].ji=sqrt((dians[i].x-dians[k].x)*(dians[i].x-dians[k].x)+(dians[i].y-dians[k].y)*(dians[i].y-dians[k].y)+(dians[i].z-dians[k].z)*(dians[i].z-dians[k].z));
l++;
}
}
for(i=1;i<=n*(n-1)/2;i++){
for(k=0;k<n*(n-1)/2-i;k++){
if(suoyous[k].ji<suoyous[k+1].ji){
e=suoyous[k];
suoyous[k]=suoyous[k+1];
suoyous[k+1]=e;
}
}
}
for(i=0;i<n*(n-1)/2;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",suoyous[i].qian.x,suoyous[i].qian.y,suoyous[i].qian.z,suoyous[i].hou.x,suoyous[i].hou.y,suoyous[i].hou.z,suoyous[i].ji);
}
return 0;
} |
64 | 31516 | float f(int a,int b,int c,int d,int e,int f);
int main()
{
int x[11],y[11],z[11],i,j,n,num=0;
scanf("%d",&n);
//scanf("%d %d %d",&x[0],&y[0],&z[0]);
for(i=0;i<n;i++)
scanf("%d %d %d",&x[i],&y[i],&z[i]);
struct POINT
{
int point1x;
int point1y;
int point1z;
int point2x;
int point2y;
int point2z;
int mark;
float l;
};
struct POINT temp;
struct POINT d[55];
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
d[num].mark=num;
d[num].point1x=x[i];d[num].point1y=y[i];d[num].point1z=z[i];
d[num].point2x=x[j];d[num].point2y=y[j];d[num].point2z=z[j];
d[num].l=f(x[i],y[i],z[i],x[j],y[j],z[j]);
num=num+1; //printf("%.2f\n",d[num].l);printf("%d %d %d %d %d %d\n",x[i],y[i],z[i],x[j],y[j],z[j]);
}
} //for(i=num-1;i>=0;i--)printf("%.2f\n",d[i].l);//printf("%d\n",num);
for(i=1;i<num;i++)
{
for(j=0;j<num-i;j++)
{
if(d[j].l>d[j+1].l)
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}
}
for(i=1;i<num;i++)
{
for(j=0;j<num-i;j++)
{
if(d[j].l==d[j+1].l&&d[j].mark<d[j+1].mark)
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}
} //printf("%.2f\n",d[3].l);
for(i=num-1;i>=0;i--)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",d[i].point1x,d[i].point1y,d[i].point1z,d[i].point2x,d[i].point2y,d[i].point2z,d[i].l);
return 0;
}
float f(int a,int b,int c,int d,int e,int f)
{
float length;
length=sqrt((a-d)*(a-d)+(b-e)*(b-e)+(c-f)*(c-f));
return(length);
} |
64 | 31517 | //
// main.cpp
// ????
//
// Created by ? ?? on 12-12-11.
// Copyright (c) 2012? ? ??. All rights reserved.
//
int main()
{
double b[99999][6];
double c[99999];
double a[1000][3];
int n;
cin >> n;
int i, j, k = 0, m;
for (i = 0; i < n; i++)
{
for (j = 0; j < 3; j++)
{
cin >> a[i][j];
}
}
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
b[k][0] = a[i][0];b[k][1] = a[i][1];b[k][2] = a[i][2];b[k][3] = a[j][0];b[k][4] = a[j][1];b[k][5] = a[j][2];
c[k] = sqrt(pow(a[j][0] - a[i][0], 2) + pow(a[j][1] - a[i][1], 2) + pow(a[j][2] - a[i][2], 2));
k++;
}
}
for (i = 0; i < k - 1; i++)
{
for (j = 0; j < k - 1 - i; j++)
{
if (c[j] < c[j + 1])
{
double p = c[j];
c[j] = c[j + 1];
c[j + 1] = p;
for (m = 0; m < 6; m++)
{
p = b[j][m];
b[j][m] = b[j+1][m];
b[j+1][m] = p;
}
}
}
}
for (i = 0; i < k; i++)
{
cout << fixed << setprecision(0) << "(" << b[i][0] << "," << b[i][1] << "," << b[i][2] << ")" << "-" << "(" << b[i][3] << "," << b[i][4] << "," << b[i][5] << ")" << "=" << fixed << setprecision(2) << c[i] << endl;
}
return 0;
}
|
64 | 31518 | struct point1
{
int x;
int y;
int z;
} point[10];
struct comb1
{
struct point1 po1;
struct point1 po2;
double distant;
} comb[50],t;
int abs(int a)
{
if(a>=0) return a;
else return(-a);
}
double dis(struct point1 a,struct point1 b)
{
int p,q,r;
double ans;
p=(a.x-b.x)*(a.x-b.x);
q=(a.y-b.y)*(a.y-b.y);
r=(a.z-b.z)*(a.z-b.z);
ans=sqrt(p+q+r);
return ans;
}
int main()
{
int n,i,j,k;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].z);
k=0;
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
comb[k].po1=point[i];
comb[k].po2=point[j];
comb[k].distant=dis(comb[k].po1,comb[k].po2);
k++;
}
for(i=1;i<k;i++)
for(j=0;j<k-i;j++)
if(comb[j].distant<comb[j+1].distant)
{
t=comb[j];
comb[j]=comb[j+1];
comb[j+1]=t;
}
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",comb[i].po1.x,comb[i].po1.y,comb[i].po1.z,comb[i].po2.x,comb[i].po2.y,comb[i].po2.z,comb[i].distant);
//scanf("%d",&i);
return 0;
} |
64 | 31519 | int main (){
int n,i,j,k,h,l;
scanf("%d",&n);
k=0;
int a[11];
int b[11];
int c[11];
int f[100];
int e[100];
double d[10000];
for(i=0;i<n;i++){
scanf("%d%d%d",&(a[i]),&(b[i]),&(c[i]));
}
k=1;
d[0]=0;
for(j=0;j<n;j++){
for(i=j+1;i<n;i++){
d[k]=sqrt((a[j]-a[i])*(a[j]-a[i])+(b[j]-b[i])*(b[j]-b[i])+(c[j]-c[i])*(c[j]-c[i]));
e[k]=i;
f[k]=j; //??d[k]???j,i
k++;
}l=k;
}for(h=0;h<n*n;h++){
for(k=0;k<=l;k++){
if(d[k]!=0){
for(i=0;i<=l;i++){
if(d[k]<d[i]){
break;
}if(i==(l-1)){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[f[k]],b[f[k]],c[f[k]],a[e[k]],b[e[k]],c[e[k]],d[k]);
d[k]=0;
k=0;
i=0;
break;
}
}
}
}
}
return 0;
}
|
64 | 31520 | //************************
//???????
//?????
//???2011-12-14
//************************
int main()
{
int x[10], y[10], z[10], n, i, j;
struct distance
{
int x1; //??
int y1;
int z1;
int x2;
int y2;
int z2;
double c; //??
}dis[46];
cin >> n;
cout << fixed;
for(i = 0;i < n;i++)
{
cin >> x[i] >> y[i] >> z[i]; //????
}
int k = 0;
for(i = 0;i < n;i++) //??????????????
for(j = i + 1;j < n;j++)
{
dis[k].x1 = x[i];
dis[k].y1 = y[i];
dis[k].z1 = z[i];
dis[k].x2 = x[j];
dis[k].y2 = y[j];
dis[k].z2 = z[j];
dis[k++].c = sqrt((dis[k].x1 - dis[k].x2) * (dis[k].x1 - dis[k].x2) + (dis[k].y1 - dis[k].y2) * (dis[k].y1 - dis[k].y2) + (dis[k].z1 - dis[k].z2) * (dis[k].z1 - dis[k].z2));
}
int t, t1;
for(i = 0;i < n * (n - 1) / 2 - 1;i++)
for(j = i + 1;j < n * (n - 1) / 2;j++)
{
if(dis[j].c - dis[i].c > 1e-6) //??????????????????
{
dis[45] = dis[j];
for(t = j, t1 = j;t > i;t--)
{
dis[t] = dis[--t1];
}
dis[i] = dis[45];
}
}
for(i = 0;i < n * (n - 1) / 2;i++) //??
{
cout << "(" << dis[i].x1 << "," << dis[i].y1 << "," << dis[i].z1 << ")" << "-" << "(" << dis[i].x2 << "," << dis[i].y2 << "," << dis[i].z2 << ")" << "=" << setprecision(2) << dis[i].c << endl;
}
return 0;
} |
64 | 31521 | //**********************************************************
//* ?????1.cpp *
//* ??????1200012906 *
//* ???2012?12?10? *
//* ????????? *
//**********************************************************
struct
{
int id;
int x1;
int y1;
int z1;
int x2;
int y2;
int z2;
double distance;
}data[55], t;
int main()
{
int n, x[10], y[10], z[10], i, j, k = 0;
cin >> n;
for(i = 0; i < n; i++)
cin >> x[i] >> y[i] >> z[i];
for(i = 0; i < n - 1; i++)
for(j = i + 1; j < n; j++)
{
data[k].id = k;
data[k].x1 = x[i];
data[k].y1 = y[i];
data[k].z1 = z[i];
data[k].x2 = x[j];
data[k].y2 = y[j];
data[k].z2 = z[j];
data[k].distance = pow(x[i] - x[j], 2.0) + pow(y[i] - y[j], 2.0) + pow(z[i] - z[j], 2.0);
k++; //k???????????
}
for(i = 0; i < k - 1; i++)
for(j = 0; j < k - i - 1; j++)
{
if (data[j].distance < data[j + 1].distance)
{ //??????
t = data[j];
data[j] = data[j + 1];
data[j + 1] = t;
}
}
for(i = 0; i < k; i++)
{
cout << "(" << data[i].x1 << "," << data[i].y1 << "," << data[i].z1 << ")-(";
cout << data[i].x2 << "," << data[i].y2 << "," << data[i].z2 << ")=";
cout << fixed << setprecision(2) << sqrt(data[i].distance) << endl;
}
return 0;
} |
64 | 31522 | int main()
{
int b,c,d,h,i,j,k,l,m,n,o,s;
struct{
int x,y,z;
}point[10];
struct{
struct{
int p1,p2,p3;
}p[50];
struct{
int q1,q2,q3;
}q[50];
double r;
}dis[50];
double g;
scanf("%d",&n);
for(int a=0;a<n;a++)
{
scanf("%d%d%d",&(point[a].x),&(point[a].y),&(point[a].z));
}
s=n*(n-1)/2;
o=0;
for(c=0;c<n-1;c++)
{
d=c+1;
for(b=o;b<s;b++)
{
dis[b].r=sqrt((point[c].x-point[d].x)*(point[c].x-point[d].x)+(point[c].y-point[d].y)*(point[c].y-point[d].y)+(point[c].z-point[d].z)*(point[c].z-point[d].z));
dis[b].p[b].p1=point[c].x;
dis[b].p[b].p2=point[c].y;
dis[b].p[b].p3=point[c].z;
dis[b].q[b].q1=point[d].x;
dis[b].q[b].q2=point[d].y;
dis[b].q[b].q3=point[d].z;
d++;
o++;
if(d<n)
continue;
else
break;
}
}
for(int e=1;e<=s;e++)
{
for(int f=0;f<s-e;f++)
{
if(dis[f].r<dis[f+1].r)
{
g=dis[f+1].r;
dis[f+1].r=dis[f].r;
dis[f].r=g;
h=dis[f+1].p[f+1].p1;
dis[f+1].p[f+1].p1=dis[f].p[f].p1;
dis[f].p[f].p1=h;
i=dis[f+1].p[f+1].p2;
dis[f+1].p[f+1].p2=dis[f].p[f].p2;
dis[f].p[f].p2=i;
j=dis[f+1].p[f+1].p3;
dis[f+1].p[f+1].p3=dis[f].p[f].p3;
dis[f].p[f].p3=j;
k=dis[f+1].q[f+1].q1;
dis[f+1].q[f+1].q1=dis[f].q[f].q1;
dis[f].q[f].q1=k;
l=dis[f+1].q[f+1].q2;
dis[f+1].q[f+1].q2=dis[f].q[f].q2;
dis[f].q[f].q2=l;
m=dis[f+1].q[f+1].q3;
dis[f+1].q[f+1].q3=dis[f].q[f].q3;
dis[f].q[f].q3=m;
}
}
}
for(b=0;b<s;b++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dis[b].p[b].p1,dis[b].p[b].p2,dis[b].p[b].p3,dis[b].q[b].q1,dis[b].q[b].q2,dis[b].q[b].q3,dis[b].r);
}
return 0;
} |
64 | 31523 | int main()
{
int spot[11][3],i,j,n,count=0,x,y,z;
float dis[4951][3],k;
cin >>n;
for (i=1;i<=n;i++)
for (j=0;j<3;j++)
cin >>spot[i][j];//????
for (i=1;i<n;i++)
for (j=i+1;j<=n;j++)
{
count++;
x=spot[i][0]-spot[j][0];
y=spot[i][1]-spot[j][1];
z=spot[i][2]-spot[j][2];
dis[count][0]=sqrt(x*x+y*y+z*z);
dis[count][1]=i;
dis[count][2]=j;
}//????????
for (i=1;i<count;i++)
for (j=1;j<=count-i;j++)
if (dis[j][0]<dis[j+1][0])
{
k=dis[j][0];
dis[j][0]=dis[j+1][0];
dis[j+1][0]=k;
k=dis[j][1];
dis[j][1]=dis[j+1][1];
dis[j+1][1]=k;
k=dis[j][2];
dis[j][2]=dis[j+1][2];
dis[j+1][2]=k;
}//??
for (i=1;i<=count;i++)
{
cout <<"(" <<spot[(int)dis[i][1]][0] <<"," <<spot[(int)dis[i][1]][1] <<"," <<spot[(int)dis[i][1]][2] <<")";
cout <<"-";
cout <<"(" <<spot[(int)dis[i][2]][0] <<"," <<spot[(int)dis[i][2]][1] <<"," <<spot[(int)dis[i][2]][2] <<")";
cout <<"=";
printf("%.2f",dis[i][0]);
cout <<endl;
}
return 0;
}
|
64 | 31524 | struct space
{
float b;
int x;
int y;
}
juli[100],cache;
int main()
{
int a[10][3];
int i,j,k=0;
int n;
scanf("%d",&n);
scanf("%d %d %d",&a[0][0],&a[0][1],&a[0][2]);
for(i=1;i<n;i++)
{
scanf(" %d %d %d",&a[i][0],&a[i][1],&a[i][2]);
}
for(i=0,j=0;;)
{
juli[k].x=i;juli[k].y=j;
juli[k].b=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
k++;
if(i==n-1&&j==n-1)break;
if(j==n-1)
{
i++;j=0;
}
else
j++;
}
for(i=0;i<n*n;i++)
{
for(k=0;k<n*n-i;k++)
{
if(juli[k].b<juli[k+1].b)
{
cache=juli[k+1];juli[k+1]=juli[k];juli[k]=cache;
}
}
}
int a1,a2;
for(i=0;i<n*n;i++)
{
if(juli[i].x>=juli[i].y)
continue;
else
{
a1=juli[i].x;a2=juli[i].y;
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[a1][0],a[a1][1],a[a1][2],a[a2][0],a[a2][1],a[a2][2],juli[i].b);
}
}
return 0;
}
|
64 | 31525 | main()
{
int x[10],y[10],z[10],a1[50],b1[50],c1[50],a2[50],b2[50],c2[50],n,i,j,k,m;
float d[50],q;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d",&x[i]);
scanf("%d",&y[i]);
scanf("%d",&z[i]);
}
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
d[k]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
a1[k]=x[i];
b1[k]=y[i];
c1[k]=z[i];
a2[k]=x[j];
b2[k]=y[j];
c2[k]=z[j];
k++;
}
}
for(i=0;i<(n*(n-1))/2-1;i++)
{
for(j=0;j<(n*(n-1))/2-1-i;j++)
{
if (d[j]<d[j+1])
{
q=d[j+1];
d[j+1]=d[j];
d[j]=q;
m=a1[j+1];
a1[j+1]=a1[j];
a1[j]=m;
m=b1[j+1];
b1[j+1]=b1[j];
b1[j]=m;
m=c1[j+1];
c1[j+1]=c1[j];
c1[j]=m;
m=a2[j+1];
a2[j+1]=a2[j];
a2[j]=m;
m=b2[j+1];
b2[j+1]=b2[j];
b2[j]=m;
m=c2[j+1];
c2[j+1]=c2[j];
c2[j]=m;
}
}
}
for(i=0;i<(n*(n-1))/2;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a1[i],b1[i],c1[i],a2[i],b2[i],c2[i],d[i]);
}
} |
64 | 31526 | int main(){
int a[10][3];
int x,y,z,i,j,k,n,f=0;
scanf("%d",&n);
double tmp,result[45][3];
for(i=0;i<n;i++){
scanf("%d%d%d",&x,&y,&z);
a[i][0]=x;a[i][1]=y;a[i][2]=z;
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
result[f][0]=sqrt(pow(a[i][0]-a[j][0],2)+pow(a[i][1]-a[j][1],2)+pow(a[i][2]-a[j][2],2));
result[f][1]=i;
result[f][2]=j;
f=f+1;
}
}
for(i = 0; i < f; i++){
for(j = f-1; j >i-1; j--){
if(result[j][0] < result[j+1][0]){
for(k=0;k<3;k++){
tmp = result[j+1][k];
result[j+1][k] = result[j][k];
result[j][k] = tmp;
}}
}
}
for(i=0;i<f;i++){
printf("(%d,%d,%d)-",a[(int)result[i][1]][0],a[(int)result[i][1]][1],a[(int)result[i][1]][2]);
printf("(%d,%d,%d)=",a[(int)result[i][2]][0],a[(int)result[i][2]][1],a[(int)result[i][2]][2]);
printf("%.2f\n",result[i][0]);
}
return 0;
} |
64 | 31527 | /*
* 3.cpp
*
* Created on: 2012-11-3
* Author: AK
*/
int main(){
double a[50][3]; //???????????????????
double distance;
int x[10],y[10],z[10]; //?????????
int n,x1,y1,z1,i,j,k=0; //?????????
cin>>n;
for(i=0;i<n;i++){ //????????
cin>>x1>>y1>>z1;
x[i]=x1;y[i]=y1;z[i]=z1;
}
for(i=0;i<=n-2;i++) //???????????????????????????
for(j=i+1;j<=n-1;j++)
{
a[k][0]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
a[k][1]=i;a[k][2]=j;k++;
}
for(i=1;i<=k-1;i++) //??????????????????????????????????????
for(j=k-1;j>=i;j--)
{
if(a[j][0]>a[j-1][0])
{
distance=a[j-1][0];a[j-1][0]=a[j][0];a[j][0]=distance;
distance=a[j-1][1];a[j-1][1]=a[j][1];a[j][1]=distance;
distance=a[j-1][2];a[j-1][2]=a[j][2];a[j][2]=distance;
}
}
for(i=0;i<=k-1;i++) //???? ????????????printf????
{
cout<<'('<<x[(int)(a[i][1])]<<','<<y[(int)(a[i][1])]<<','<<z[(int)(a[i][1])]<<")-(";
cout<<x[(int)(a[i][2])]<<','<<y[(int)(a[i][2])]<<','<<z[(int)(a[i][2])]<<")=";
cout<<fixed<<setprecision(2)<<a[i][0]<<endl;
}
return 0;
} |
64 | 31528 |
int main()
{
int n,i=0,j=0,e=0,m=-1,q=-1;
double a[100],b[100],c[100],t,g,f,r,v,s,o;
double d[100],p[100]={0},w[100]={0},k[100]={0},z[100]={0},l[100]={0},u[100]={0};
cin>>n;
for(i=0;i<n;i++)
cin>>a[i]>>b[i]>>c[i];
for(i=0;i<n*(n-1)/2;i++)
d[i]=0;
e=0;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{d[e]=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
p[e]=a[i];
w[e]=a[j];
u[e]=b[i];
l[e]=b[j];
k[e]=c[i];
z[e]=c[j];
e++;
}
for(i=0;i<(n*(n-1)/2)-1;i++)
for(j=0;j<(n*(n-1)/2)-i-1;j++)
{
if(d[j]<d[j+1])
{t=d[j];
d[j]=d[j+1];
d[j+1]=t;
g=p[j];
p[j]=p[j+1];
p[j+1]=g;
f=w[j];
w[j]=w[j+1];
w[j+1]=f;
r=u[j];
u[j]=u[j+1];
u[j+1]=r;
v=l[j];
l[j]=l[j+1];
l[j+1]=v;
s=k[j];
k[j]=k[j+1];
k[j+1]=s;
o=z[j];
z[j]=z[j+1];
z[j+1]=o;}
}
for(i=0;i<(n*(n-1)/2);i++)
{cout<<"("<<p[i]<<","<<u[i]<<","<<k[i]<<")"<<"-"<<"("<<w[i]<<","<<l[i]<<","<<z[i]<<")"<<"=";
printf("%.2f\n",d[i]);
}
}
|
64 | 31529 | int main(){
int x[10],y[10],z[10],n,i,j,c,maxi,maxj;
float s[10][10],max;
max=0.0f;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d %d %d",&x[i],&y[i],&z[i]);
}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
s[i][j]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
}
}
for(c=0;c<(n*(n-1)/2);c++){
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(s[i][j]>max){
max=s[i][j];
maxi=i;
maxj=j;
}
}
}
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",x[maxi],y[maxi],z[maxi],x[maxj],y[maxj],z[maxj],max);
s[maxi][maxj]=0.0f;
max=0.0f;
maxi=i;
maxj=j;
}
return 0;
} |
64 | 31530 | int main(){
int n;
int x[10],y[10],z[10], q=0,a[100],b[100],c[100],d[100],e[100],f[100];
float t,m[100];
scanf("%d",&n);
for(int h=0;h<n;h++){
scanf("%d%d%d",&x[h],&y[h],&z[h]);
}
for(int i=0;i<n;i++){
for(int u=i+1;u<n;u++){
m[q] =(float)sqrt((x[i]-x[u])*(x[i]-x[u])+(y[i]-y[u])*(y[i]-y[u])+(z[i]-z[u])*(z[i]-z[u]));
a[q]=x[i];b[q]=y[i];c[q]=z[i];d[q]=x[u];e[q]=y[u];f[q]=z[u];
q++;
}
}
for(int r=0;r<q;r++){
for(int k=0;k<q-r;k++){
if(m[k]<m[k+1]){
t=m[k+1];
m[k+1]=m[k];
m[k]=t;
t=a[k+1];
a[k+1]=a[k];
a[k]=t;
t=b[k+1];
b[k+1]=b[k];
b[k]=t;
t=c[k+1];
c[k+1]=c[k];
c[k]=t;
t=d[k+1];
d[k+1]=d[k];
d[k]=t;
t=e[k+1];
e[k+1]=e[k];
e[k]=t;
t=f[k+1];
f[k+1]=f[k];
f[k]=t;
}
}
}
for(int w=0;w<q;w++)
{printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[w],b[w],c[w],d[w],e[w],f[w],m[w]);}
return 0;
} |
64 | 31531 | int main(){
int x[10],y[10],z[10];
int n,i;
scanf("%d",&n);
int max,k=0;
max=n*(n-1)/2;
int MAX[45*45],MAX2[45*45];
int c;
double di[45][45],sz[45]={0.00};
for(i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
for(i=0;i<n-1;i++){
for(k=1;k+i<n;k++){
di[i][i+k]=sqrt((x[i]-x[i+k])*(x[i]-x[i+k])+(y[i]-y[i+k])*(y[i]-y[i+k])+(z[i]-z[i+k])*(z[i]-z[i+k]));}
}
for(c=0;c<max;c++){for(i=0;i<n-1;i++){
for(k=1;k+i<n;k++){if(c==0){if(sz[c]<di[i][i+k]){MAX[c]=i;MAX2[c]=i+k;sz[c]=di[i][i+k];}}
else if(sz[c]<di[i][i+k]&&di[i][i+k]<sz[c-1]){MAX[c]=i;MAX2[c]=i+k;sz[c]=di[i][i+k];}
else if(sz[c]<di[i][i+k]&&di[i][i+k]==sz[c-1]){if(i>MAX[c-1]){MAX[c]=i;MAX2[c]=i+k;sz[c]=di[i][i+k];}else if(i==MAX[c-1]){if(i+k>MAX2[c-1]){MAX[c]=i;MAX2[c]=i+k;sz[c]=di[i][i+k];}}
}}}}
for(c=0;c<max;c++){printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[MAX[c]],y[MAX[c]],z[MAX[c]],x[MAX2[c]],y[MAX2[c]],z[MAX2[c]],sz[c]);}
return 0;
} |
64 | 31532 | int main()
{
int n,i,k,j=0,m,f,g;
scanf("%d",&n);
int s[10][3],b[50][3],d[50][3];
double c[50],r,e;
for(i=0;i<n;i++){
for(k=0;k<3;k++){
scanf("%d",&s[i][k]);
}
}
for(i=0;i<n;i++){
for(k=i+1;k<n;k++){
r=sqrt((s[i][0]-s[k][0])*(s[i][0]-s[k][0])+(s[i][1]-s[k][1])*(s[i][1]-s[k][1])+(s[i][2]-s[k][2])*(s[i][2]-s[k][2]));
b[j][0]=s[i][0];
b[j][1]=s[i][1];
b[j][2]=s[i][2];
d[j][0]=s[k][0];
d[j][1]=s[k][1];
d[j][2]=s[k][2];
c[j]=r;
j++;
}
}
for(i=1;i<n*(n-1)/2;i++){
for(k=0;k<n*(n-1)/2-i;k++){
if(c[k]<c[k+1]){
e=c[k+1];
c[k+1]=c[k];
c[k]=e;
for(m=0;m<3;m++){
f=b[k+1][m];
b[k+1][m]=b[k][m];
b[k][m]=f;
g=d[k+1][m];
d[k+1][m]=d[k][m];
d[k][m]=g;
}
}
}
}
for(i=0;i<n*(n-1)/2;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",b[i][0],b[i][1],b[i][2],d[i][0],d[i][1],d[i][2],c[i]);
}
return 0;
}
|
64 | 31533 | int main(){
int x[1000],y[1000],z[1000],n,i,m,j,u[1000],v[1000],c,d;
double s[100],b;
b=0;
c=0;
d=0;
m=0;
scanf("%d",&n);
for( i=0;i<n;i++)
scanf("%d%d%d",&x[i],&y[i],&z[i]);
for(i=0;i<n;i++){
for(int j=n-1;j>i;j--){
b=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
s[m]= sqrt(b);
u[m]=i;
v[m]=j;
m++;
}
}
for(i=0;i<n*(n-1)/2;i++){
if(n==2)
break;
for(j=0;j<n*(n-1)/2;j++){
if(s[j]<s[j+1]){
b=s[j];
s[j]=s[j+1];
s[j+1]=b;
c=u[j];
u[j]=u[j+1];
u[j+1]=c;
d=v[j];
v[j]=v[j+1];
v[j+1]=d;
}
}
}
for(i=0;i<n*(n-1)/2;i++){
if(n==2)
break;
if(s[i]==s[i+1]){
if(u[i]>u[i+1]){
c=u[i];
u[i]=u[i+1];
u[i+1]=c;
d=v[i];
v[i]=v[i+1];
v[i+1]=d;
}
if(u[i]==u[i+1]){
if(v[i]>v[i+1]){
c=u[i];
u[i]=u[i+1];
u[i+1]=c;
d=v[i];
v[i]=v[i+1];
v[i+1]=d;
}
}
}
}
for(i=0;i<n*(n-1)/2;i++){
if(n==2)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[u[0]],y[u[0]],z[u[0]],x[v[0]],y[v[0]],z[v[0]],s[0]);
else{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[u[i]],y[u[i]],z[u[i]],x[v[i]],y[v[i]],z[v[i]],s[i]);
}
}
return 0;
}
|
64 | 31534 | /*
* jiegou_4.cpp
* ???????
* Created on: 2011-1-2
* Author: Wang Ju
*/
struct distance //?????distance
{
double a[3]; //??1
double b[3]; //??2
double distance; //???????
};
int factorial(int i) //????facortial,??i?????????
{
return (i*(i+1))/2;
}
double oper(double x1, double y1, double z1, double x2, double y2, double z2)
{
return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));
//????oper,???????
}
int main() //????
{
int n, i, j, m; //????
cin>>n; //??????n
double x[n][3];
for(i=0; i<n; i++)
{
cin>>x[i][0]>>x[i][1]>>x[i][2]; //????
}
m=factorial(n-1);//m?distance???
struct distance dot[m]; //??m?distance??
int k=0;
for(i=1; i<n; i++)
for(j=i+1; j<=n; j++)
{
dot[k].a[0]=x[i-1][0];
dot[k].a[1]=x[i-1][1];
dot[k].a[2]=x[i-1][2];
dot[k].b[0]=x[j-1][0];
dot[k].b[1]=x[j-1][1];
dot[k].b[2]=x[j-1][2];
dot[k].distance=oper(dot[k].a[0], dot[k].a[1], dot[k].a[2], dot[k].b[0], dot[k].b[1], dot[k].b[2]);
k++;
//?????????????????????????
}
for(i=0; i<m-1; i++)
for(j=0; j<m-i-1; j++)
{
if(dot[j].distance<dot[j+1].distance)
{
struct distance temp=dot[j];
dot[j]=dot[j+1];
dot[j+1]=temp; //?????
}
}
for(i=0; i<m; i++)
{
cout<<fixed<<setprecision(0)<<"("<<dot[i].a[0]<<","<<dot[i].a[1]<<","<<dot[i].a[2]<<")-("<<dot[i].b[0]<<
","<<dot[i].b[1]<<","<<dot[i].b[2]<<")=";
cout<<fixed<<setprecision(2)<<dot[i].distance<<endl;
} //???????????
return 0; //???0?
}
|
64 | 31535 | main()
{
int a[10],b[10],c[10];
int i,j,k,n,t;
float w;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&a[i],&b[i],&c[i]);
struct px
{
float d;
int p,q,r;
int x,y,z;
};
struct px m[45];
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
m[k].d=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
m[k].p=a[i];
m[k].q=b[i];
m[k].r=c[i];
m[k].x=a[j];
m[k].y=b[j];
m[k++].z=c[j];
}
}
for(i=0;i<n*(n-1)/2-1;i++)
{
for(j=0;j<n*(n-1)/2-i;j++)
{
if(m[j].d<m[j+1].d)
{
w=m[j].d;
m[j].d=m[j+1].d;
m[j+1].d=w;
t=m[j].p;
m[j].p=m[j+1].p;
m[j+1].p=t;
t=m[j].q;
m[j].q=m[j+1].q;
m[j+1].q=t;
t=m[j].r;
m[j].r=m[j+1].r;
m[j+1].r=t;
t=m[j].x;
m[j].x=m[j+1].x;
m[j+1].x=t;
t=m[j].y;
m[j].y=m[j+1].y;
m[j+1].y=t;
t=m[j].z;
m[j].z=m[j+1].z;
m[j+1].z=t;
}
}
}
for(i=0;i<n*(n-1)/2;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",m[i].p,m[i].q,m[i].r,m[i].x,m[i].y,m[i].z,m[i].d);
} |
64 | 31536 | int main(){
int N;
cin>>N;
int a[10][3];
int b[100][2];
int S=0;
float d[100];
for (int i=0;i<N;i++)cin>>a[i][0]>>a[i][1]>>a[i][2];
for (int i=0;i<N;i++){
for (int j=i;j<N;j++){
if (i==j)continue;
b[S][0]=i;b[S][1]=j;
d[S]=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
//cout<<d[S]<<endl;
S++;
}
}
int t;
float ft;
for (int i=0;i<S;i++){
for (int j=S-1;j>i;j--){
if (d[j]>d[j-1]){
ft=d[j];d[j]=d[j-1];d[j-1]=ft;
t=b[j][0];b[j][0]=b[j-1][0];b[j-1][0]=t;
t=b[j][1];b[j][1]=b[j-1][1];b[j-1][1]=t;
}
}
}
cout<<fixed;
for (int i=0;i<S;i++){
cout<<"("<<a[b[i][0]][0]<<","<<a[b[i][0]][1]<<","<<a[b[i][0]][2]<<")-("<<a[b[i][1]][0]<<","<<a[b[i][1]][1]<<","<<a[b[i][1]][2]<<")="<<setprecision(2)<<d[i]<<endl;
}
cin>>N;
return 0;
}
|
64 | 31537 | /*
* Distance sorting.cpp
*
* Created on: 2013-11-6
* Author: ???
*/
int main()
{ int a[10],b[10],c[10];
float d[100],p,x[100][3],y[100][3];
int i,j,n,k,m=0,s,t;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i]>>b[i]>>c[i];
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
x[m][0]=a[i];
x[m][1]=b[i];
x[m][2]=c[i];
y[m][0]=a[j];
y[m][1]=b[j];
y[m][2]=c[j];
d[m]=sqrt((x[m][0]-y[m][0])*(x[m][0]-y[m][0])+(x[m][1]-y[m][1])*(x[m][1]-y[m][1])+(x[m][2]-y[m][2])*(x[m][2]-y[m][2]));
m++;
}
}
for(j=0;j<m-1;j++)
{
for(i=0;i<m-1-j;i++)
{
if(d[i]<d[i+1])
{
p=d[i];
d[i]=d[i+1];
d[i+1]=p;
for(k=0;k<3;k++)
{ s=x[i][k];
x[i][k]=x[i+1][k];
x[i+1][k]=s;
t=y[i][k];
y[i][k]=y[i+1][k];
y[i+1][k]=t;
}
}
}
}
for(i=0;i<m;i++)
cout<< fixed<<setprecision(0)<<"("<<x[i][0]<<","<<x[i][1]<<","<<x[i][2]<<")-("<<y[i][0]<<","<<y[i][1]<<","<<y[i][2]<<")="<< fixed<<setprecision(2)<<d[i]<<endl;
return 0;
}
|
64 | 31538 | //********************************
//*?????(14-4) ???? **
//*?????? 1300012887 **
//*???2013.12.11 **
//********************************
int main()
{
int n, i, j, k = 0;
cin >> n; //????
struct dian //?????dian
{
int x;
int y;
int z;
} a[12]; //???????a
for (i = 0; i < n; i++)
cin >> a[i].x >> a[i].y >> a[i].z; //???????
struct cha //?????cha
{
int x1;
int y1;
int z1;
int x2;
int y2;
int z2;
double c;
} b[46], t; //???????b,???t
for (i = 0; i < n-1; i++) //???????????
for (j = i+1; j < n; j++)
{
b[k].x1 = a[i].x;
b[k].y1 = a[i].y;
b[k].z1 = a[i].z;
b[k].x2 = a[j].x;
b[k].y2 = a[j].y;
b[k].z2 = a[j].z; //???
b[k].c = sqrt((b[k].x2 - b[k].x1) * (b[k].x2 - b[k].x1) + (b[k].y2 - b[k].y1) * (b[k].y2 - b[k].y1) + (b[k].z2 - b[k].z1) * (b[k].z2 - b[k].z1)); //??????
k++; //??
}
for (i = 0; i < k-1; i++) //????????????
for (j = 0; j < k-i-1; j++)
{
if (b[j].c < b[j+1].c)
{
t = b[j];
b[j] = b[j+1];
b[j+1] = t;
}
}
for (i = 0; i < k; i++) //??????
{
cout << "(" << b[i].x1 << "," << b[i].y1 << "," << b[i].z1 << ")" << "-" << "(" << b[i].x2 << "," << b[i].y2 << "," << b[i].z2 << ")" << "=" ;
cout << fixed << setprecision(2) << b[i].c << endl;
}
return 0;
}
|
64 | 31539 | int main()
{
struct pointlong
{
int a1;
int b1;
int c1;
int a2;
int b2;
int c2;
double sl;
};
struct pointlong point[10000];
int x[11]={0};
int y[11]={0};
int z[11]={0};
double a[11][11]={0};
double c[1000]={0};
int i,j,n,k,p,sum,w,f;
float m;
double temp;
k=0;
w=0;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d %d %d",&x[i],&y[i],&z[i]);
}
sum=n*(n-1)/2;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
m=(float)(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
a[i][j]=sqrt(m);
}
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
c[k]=a[i][j];
k=k+1;
}
}
for(i=1;i<sum;i++)
{
for(j=0;j<sum;j++)
{
if(c[j]<c[j+1])
{
temp=c[j];
c[j]=c[j+1];
c[j+1]=temp;
}
}
}
for(i=0;i<=sum;i++)
{
for(j=0;j<n;j++)
{
for(p=j+1;p<n;p++)
{
if(a[j][p]==c[i])
{
point[w].a1=x[j];
point[w].b1=y[j];
point[w].c1=z[j];
point[w].a2=x[p];
point[w].b2=y[p];
point[w].c2=z[p];
point[w].sl=c[i];
w=w+1;
}
}
}
}
for(i=0;i<w;i++)
{
f=0;
for(j=0;j<i;j++)
{
if(point[i].a1==point[j].a1&&point[i].b1==point[j].b1&&point[i].c1==point[j].c1&&point[i].sl==point[j].sl&&point[i].a2==point[j].a2&&point[i].b2==point[j].b2&&point[i].c2==point[j].c2)
{
f=1;
break;
}
}
if(f==0)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",point[i].a1,point[i].b1,point[i].c1,point[i].a2,point[i].b2,point[i].c2,point[i].sl);
}
}
return 0;
}
|
64 | 31540 | double h(int x1,int y1,int z1,int x2,int y2,int z2)
{
double s;
int x,y,z;
x=x1-x2;
y=y1-y2;
z=z1-z2;
s=sqrt(x*x+y*y+z*z);
return s;
}
int main()
{
int n,a[10],b[10],c[10];
int i,k,j;
struct shizi{
int x1;int x2;
int y1;int y2;
int z1;int z2;
double l;
} s[50],tmp;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
s[k].x1=a[i];
s[k].x2=a[j];
s[k].y1=b[i];
s[k].y2=b[j];
s[k].z1=c[i];
s[k].z2=c[j];
s[k].l=h(a[i],b[i],c[i],a[j],b[j],c[j]);
k++;
}
}
for(i=1;i<=k;i++)
{
for(j=0;j<k-1;j++)
{
if(s[j].l<s[j+1].l)
{
tmp=s[j];
s[j]=s[j+1];
s[j+1]=tmp;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",s[i].x1,s[i].y1,s[i].z1,s[i].x2,s[i].y2,s[i].z2,s[i].l);
}
return 0;
} |
64 | 31541 | int main()
{
double f(int a[],int b[]);
int n,a[10][3],count=0,i,j,k,d[45][2],num=0;
int g(int i,int j,int k,int d[][2],double b[],int n);
double t,b[45];
scanf("%d",&n);
for(i=0;i<n;i++)
for(j=0;j<3;j++)
scanf("%d",&a[i][j]);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{b[count]=f(a[i],a[j]);
count++;}
for(i=0;i<n*(n-1)/2-1;i++)
for(j=0;j<n*(n-1)/2-1-i;j++)
if(b[j]<b[j+1])
{t=b[j];b[j]=b[j+1];b[j+1]=t;}
for(i=0;i<n-1;i++)
{ for(j=i+1;j<n;j++)
if(f(a[i],a[j])==b[0])
{printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[i][0],a[i][1],a[i][2],a[j][0],a[j][1],a[j][2],b[0]);d[0][0]=i;d[0][1]=j;num++;break;}
if(num==1) {num=0;break;}
}
for(k=1;k<n*(n-1)/2;k++)
for(i=0;i<n-1;i++)
{ for(j=i+1;j<n;j++)
if(f(a[i],a[j])==b[k])
{ if(b[k]!=b[k-1])
{ printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[i][0],a[i][1],a[i][2],a[j][0],a[j][1],a[j][2],b[k]);d[k][0]=i;d[k][1]=j;
num++; break;}
else if(g(i,j,k,d,b,n))
{ printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[i][0],a[i][1],a[i][2],a[j][0],a[j][1],a[j][2],b[k]);d[k][0]=i;d[k][1]=j;
num++; break;}
}
if(num==1) {num=0; break;}
}
return 0;
}
double f(int a[],int b[])
{double d;
d=sqrt((a[0]-b[0])*(a[0]-b[0])+(a[1]-b[1])*(a[1]-b[1])+(a[2]-b[2])*(a[2]-b[2]));
return d;
}
int g(int i,int j,int k,int d[][2],double b[],int n)
{int x,num1=0;
for(x=0;x<=k;x++)
if(b[x]==b[k]) num1++;
for(x=1;x<num1;x++)
if(d[k-x][0]==i&&d[k-x][1]==j)
{return 0;break;}
if(x>=num1) return 1;
}
|
64 | 31542 |
typedef struct point
{
int x,y,z;
}Point;
double Distance(Point p1, Point p2)
{
double dist=0;
dist = sqrtf((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y) + (p1.z-p2.z)*(p1.z-p2.z)+0.0 );
return dist;
}
int main(int argc, char* argv[])
{
int n, i, j, k=0, numtotal, maxpj=0, maxpi=0;
double ** ppdDist, dMaxDist=0.0;//*p1Dist,
Point * pcPoint;
scanf("%d",&n);
numtotal = n*(n-1)/2;
//p1Dist = (double *)calloc(numtotal, sizeof(double));
ppdDist = (double**)calloc(n, sizeof(double*));
for (i=0; i<n; i++)
{
ppdDist[i] = (double *)calloc(n, sizeof(double));
}
pcPoint = (Point *) calloc(n, sizeof(Point));
for (j=0; j<n; j++)
{
for (i=0; i<n; i++)
{
ppdDist[j][i] = 0.0;
}
}
//////////////////////////////////////////////////////////////////////////
for (i=0; i<n; i++)
{
scanf("%d%d%d", &(pcPoint[i].x), &(pcPoint[i].y), &(pcPoint[i].z));
}
for (j=0; j<n; j++)
{
for (i=j+1; i<n; i++)
{
ppdDist[j][i] =Distance(pcPoint[j], pcPoint[i]);
}
}
for (k=0; k<numtotal; k++)
{
for (j=0; j<n; j++)
{
for (i=j+1; i<n; i++)
{
if (ppdDist[j][i]>dMaxDist) ///????????????????0
{
maxpi = i;
maxpj = j;
dMaxDist = ppdDist[j][i];
}
}
}
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n", pcPoint[maxpj].x, pcPoint[maxpj].y, pcPoint[maxpj].z,
pcPoint[maxpi].x, pcPoint[maxpi].y, pcPoint[maxpi].z, dMaxDist);
ppdDist[maxpj][maxpi] =0.0;// is out
maxpi =0; maxpj =0; dMaxDist =0.0;
}
//////////////////////////////////////////////////////////////////////////
for (i=0; i<n; i++)
{
free(ppdDist[i]);
}
free(ppdDist);
free(pcPoint);
return 0;
} |
64 | 31543 | int main(){
int a[10][4],m[45][4],n[45][4],i=0,j=0,k=0,p,q,w;
double b[10][10],c[45];
scanf("%d",&w);
for(i=0;i<w;i++){
scanf("%d%d%d",&a[i][1],&a[i][2],&a[i][3]);
}
for(i=0;i<w;i++){
for(j=i+1;j<w;j++){
b[i][j]=(double)sqrt((a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2])+(a[i][3]-a[j][3])*(a[i][3]-a[j][3]));
}
}
for(k=0;k<w*(w-1)/2;k++){
c[k]=b[0][1];
p=0;
q=1;
for(i=0;i<w-1;i++){
for(j=i+1;j<w;j++){
if(c[k]<b[i][j]){
c[k]=b[i][j];
p=i;
q=j;
}
}
}
b[p][q]=-1;
m[k][1]=a[p][1];m[k][2]=a[p][2];m[k][3]=a[p][3];
n[k][1]=a[q][1];n[k][2]=a[q][2];n[k][3]=a[q][3];
}
for(k=0;k<w*(w-1)/2;k++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",m[k][1],m[k][2],m[k][3],n[k][1],n[k][2],n[k][3],c[k]);
}
return 0;
} |
64 | 31544 |
int main()
{
struct info1
{
int a[3];
}
point[N];
struct info2
{
int f[3],l[3];
double result;
}
dist[N*(N-1)/2];
int n,i,j,k=0,p;
double tmpdist;
int tmppoint;
scanf("%d",&n);
for (i=0;i<n;i++)
{
scanf("%d %d %d",&point[i].a[0],&point[i].a[1],&point[i].a[2]);
}
for (i=0;i<n;i++)
{
for (j=i+1;j<n;j++)
{
dist[k].result=sqrt((double)(point[i].a[0]-point[j].a[0])*(point[i].a[0]-point[j].a[0])+(point[i].a[1]-point[j].a[1])*(point[i].a[1]-point[j].a[1])+(point[i].a[2]-point[j].a[2])*(point[i].a[2]-point[j].a[2]));
for (p=0;p<3;p++)
{
dist[k].f[p]=point[i].a[p];
dist[k].l[p]=point[j].a[p];
}
k++;
}
}
for (j=1;j<k;j++)
{
for (i=0;i<k-j;i++)
{
if (dist[i].result<dist[i+1].result)
{
tmpdist=dist[i].result;
dist[i].result=dist[i+1].result;
dist[i+1].result=tmpdist;
for (p=0;p<3;p++)
{
tmppoint=dist[i].f[p];
dist[i].f[p]=dist[i+1].f[p];
dist[i+1].f[p]=tmppoint;
tmppoint=dist[i].l[p];
dist[i].l[p]=dist[i+1].l[p];
dist[i+1].l[p]=tmppoint;
}
}
}
}
for (i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dist[i].f[0],dist[i].f[1],dist[i].f[2],dist[i].l[0],dist[i].l[1],dist[i].l[2],dist[i].result);
}
return 0;
} |
64 | 31545 | //????
int main()
{
int n,a[10],b[10],c[10],s=0,x[100],y[100],ht;
double d[100],max;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i]>>b[i]>>c[i];//?????
}
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
d[s]=sqrt((a[i]*1.0-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
x[s]=i;y[s]=j;
s++;
}}//???????
for(int i=0;i<n*(n-1)/2;i++)
{
for(s=0;s<n*(n-1)/2-1;s++)
{
if(d[s]<d[s+1])
{
max=d[s];d[s]=d[s+1];d[s+1]=max;
ht=x[s];x[s]=x[s+1];x[s+1]=ht;
ht=y[s];y[s]=y[s+1];y[s+1]=ht;
}//????
}
}
for(s=0;s<=n*(n-1)/2 -1;s++)
{
cout<<'('<<a[x[s]]<<','<<b[x[s]]<<','<<c[x[s]]<<")-("<<a[y[s]]<<','<<b[y[s]]<<','<<c[y[s]]<<')'<<'='<<setprecision(2)<<fixed<<d[s]<<endl;//??
}
return 0;
}
|
64 | 31546 | int main()
{
int n,b,c,i,j,k,e,g;
scanf("%d",&n);
int sa[11],sb[11],sc[11];
for(i=0;i<n;i++)
{
scanf("%d%d%d",&sa[i],&sb[i],&sc[i]);
}
int s[51],y[51],z[51];
double l[51],f;
i=0;
for(j=0;j<n-1;j++)
{
for(k=j+1;k<n;k++)
{
s[i]=(sa[j]-sa[k])*(sa[j]-sa[k])+(sb[j]-sb[k])*(sb[j]-sb[k])+(sc[j]-sc[k])*(sc[j]-sc[k]);
l[i]=sqrt(s[i]);
y[i]=j;
z[i]=k;//??????
i++;
}
}
for(i=1;i<=(n*(n-1)/2);i++)
{
for(j=0;j<(n*(n-1)/2-i);j++)
{
if(l[j]<l[j+1])
{
f=l[j];
l[j]=l[j+1];
l[j+1]=f;//????
e=y[j];
y[j]=y[j+1];
y[j+1]=e;
g=z[j];
z[j]=z[j+1];
z[j+1]=g;//???????
}
}
}
for(i=0;i<(n*(n-1)/2);i++)
{
b=y[i];
c=z[i];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",sa[b],sb[b],sc[b],sa[c],sb[c],sc[c],l[i]);
}
return 0;
} |
64 | 31547 | int main(){
int n,a[100][100],i,j,k,p,l,m=0,x,c[100][100],d[100][100],e2,e3,o,w=0;
double b[100],e1;
scanf("%d",&n);
for(i=0;i<n;i++){
for(j=0;j<3;j++){
scanf("%d",&a[i][j]);
}
}
for(p=1;p<=n;p++){
for(k=p-1;k<n-1;k++){
for(j=0;j<3;j++){
x=a[p-1][j]-a[k+1][j];
m=m+x*x;
c[w][j]=a[p-1][j];
d[w][j]=a[k+1][j];
}
b[w]=sqrt(m);
w++;
m=0;
}
}
o=n*(n-1)/2;
for(l=1;l<=o;l++){
for(k=0;k<o-l;k++){
if(b[k]<b[k+1]){
for(j=0;j<3;j++){
e1=b[k];
e2=c[k][j];
e3=d[k][j];
b[k]=b[k+1];
c[k][j]=c[k+1][j];
d[k][j]=d[k+1][j];
b[k+1]=e1;
c[k+1][j]=e2;
d[k+1][j]=e3;
}
}
}
}
for(k=0;k<o;k++){
printf("(");
printf("%d,%d,%d",c[k][0],c[k][1],c[k][2]);
printf(")-(");
printf("%d,%d,%d",d[k][0],d[k][1],d[k][2]);
printf(")=");
printf("%.2lf\n",b[k]);
}
return 0;
}
|
64 | 31548 | int main(){
int a[10],b[10],c[10],e,f,g,l,m=0,o[50],p[50],q[50],r[50],s[50],t[50],u,v,w,x,y,z;
double d[50],n;
char h='(',i=')',j='-',k='=';
scanf("%d",&e);
for(f=0;f<e;f++){
scanf("%d%d%d",&a[f],&b[f],&c[f]);
}
for(f=0;f<(e-1);f++){
for(g=f+1;g<e;g++){
l=(a[f]-a[g])*(a[f]-a[g])+(b[f]-b[g])*(b[f]-b[g])+(c[f]-c[g])*(c[f]-c[g]);
d[m]=sqrt(l);
o[m]=a[f];
p[m]=b[f];
q[m]=c[f];
r[m]=a[g];
s[m]=b[g];
t[m]=c[g];
m++;
}
}
for(f=0;f<m;f++){
for(g=f+1;g<m;g++){
if(d[f]<d[g]){
n=d[g];
u=o[g];
v=p[g];
w=q[g];
x=r[g];
y=s[g];
z=t[g];
for(e=g;e>f;e--){
d[e]=d[e-1];
o[e]=o[e-1];
p[e]=p[e-1];
q[e]=q[e-1];
r[e]=r[e-1];
s[e]=s[e-1];
t[e]=t[e-1];
}
d[f]=n;
o[f]=u;
p[f]=v;
q[f]=w;
r[f]=x;
s[f]=y;
t[f]=z;
}
}
}
for(f=0;f<m;f++){
printf("%c%d,%d,%d%c%c%c%d,%d,%d%c%c%.2lf\n",h,o[f],p[f],q[f],i,j,h,r[f],s[f],t[f],i,k,d[f]);
}
return 0;
}
|
64 | 31549 |
int main(){
int n=0,x[11],y[11],z[11],a[51][3];
double d[50];
scanf("%d\n",&n);
for(int i=1;i<=n;i++)
scanf("%d %d %d ",&x[i],&y[i],&z[i]);
int cnt=0;
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++){
int c=++cnt;
d[c]=sqrt(sqr(x[i]-x[j])+sqr(y[i]-y[j])+sqr(z[i]-z[j]));
a[c][1]=i;
a[c][2]=j;
}
for(int i=1;i<=cnt;i++)
for(int j=cnt;j>i;j--)
if(d[j-1]<d[j]){
double t1;
int t2,t3;
t1=d[j-1];
d[j-1]=d[j];
d[j]=t1;
t2=a[j-1][1];
t3=a[j-1][2];
a[j-1][1]=a[j][1];
a[j-1][2]=a[j][2];
a[j][1]=t2;
a[j][2]=t3;
}
for(int i=1;i<=cnt;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",
x[a[i][1]],y[a[i][1]],z[a[i][1]],x[a[i][2]],y[a[i][2]],z[a[i][2]],d[i]);
return 0;
}
|
64 | 31550 | struct POINT {
int x;
int y;
int z;
};
struct DIST {
int a;
int b;
double dis;
};
int main()
{
int n,i,j,k,t;
double td;
struct POINT point[20];
struct DIST dists[200];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].z);
}
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
dists[k].a=i;
dists[k].b=j;
dists[k].dis=sqrt((point[i].x-point[j].x)*(point[i].x-point[j].x)+
(point[i].y-point[j].y)*(point[i].y-point[j].y)+(point[i].z-point[j].z)*(point[i].z-point[j].z));
k++;
}
}
for(i=0;i<k;i++)
{
for(j=k-1;j>i;j--)
{
if(dists[j].dis>dists[j-1].dis)
{
t=dists[j].a;
dists[j].a=dists[j-1].a;
dists[j-1].a=t;
t=dists[j].b;
dists[j].b=dists[j-1].b;
dists[j-1].b=t;
td=dists[j].dis;
dists[j].dis=dists[j-1].dis;
dists[j-1].dis=td;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",
point[dists[i].a].x,point[dists[i].a].y,point[dists[i].a].z,
point[dists[i].b].x,point[dists[i].b].y,point[dists[i].b].z,
dists[i].dis);
}
return 0;
} |
64 | 31551 | //********************************
//*??????? **
//*?????? 1200012839 **
//*???2012.12.10 **
//********************************
int main()
{
int n, k = 0;
cin >> n;
struct point
{
int x;
int y;
int z;
}point[n];
struct distance
{
int pointa;
int pointb;
double d;
}dis[4950],temp;
for (int i = 0; i < n; i++)
{
cin >> point[i].x >> point[i].y >> point[i].z;
}
for (int i=0;i<n-1;i++)
{
for (int j=i+1;j<n;j++)
{
dis[k].d = sqrt((point[i].x - point[j].x) * (point[i].x - point[j].x)
+ (point[i].y - point[j].y) * (point[i].y - point[j].y)
+ (point[i].z - point[j].z) * (point[i].z - point[j].z));
dis[k].pointa = i;
dis[k].pointb = j;
k++;
}
}
for (int i = 0; i < n * (n - 1) / 2 - 1; i++)
{
for (int j = i + 1; j < n * (n - 1) / 2; j++)
{
if (dis[i].d < dis[j].d)
{
temp = dis[i];
dis[i] = dis[j];
dis[j] = temp;
}
if (dis[i].d == dis[j].d && (dis[i].pointa > dis[j].pointa || dis[i].pointb > dis[j].pointb))
{
temp = dis[i];
dis[i] = dis[j];
dis[j] = temp;
}
}
}
for (int i = 0; i < n * (n - 1) / 2; i++)
{
cout << "(" << point[dis[i].pointa].x << "," << point[dis[i].pointa].y << "," << point[dis[i].pointa].z << ")" << "-"
<< "(" << point[dis[i].pointb].x << "," << point[dis[i].pointb].y << "," << point[dis[i].pointb].z << ")" << "="
<< fixed << setprecision(2) << dis[i].d << endl;
}
return 0;
} |
64 | 31552 | int main()
{
int n;
scanf("%d",&n);
int point[11][3];
for(int i=0;i<n;i++)
{
for(int j=0;j<3;j++)
{
scanf("%d",&point[i][j]);
}
}
double distance[15][15]={0};
double s;
for(int i=0;i<n;i++)
{
for(int k=1;i+k<n;k++)
{
s=sqrt((point[i][0]-point[i+k][0])*(point[i][0]-point[i+k][0])+(point[i][1]-point[i+k][1])*(point[i][1]-point[i+k][1])+(point[i][2]-point[i+k][2])*(point[i][2]-point[i+k][2]));
distance[i][i+k]=s;
}
}
double lenth[105];
int id[105][2];
int k=0;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(distance[i][j]==0)
{
continue;
}
id[k][0]=i;
id[k][1]=j;
lenth[k]=distance[i][j];
k++;
}
}
double e;
for(int p=1;p<k;p++)
{
for(int i=k-1;i>=p;i--)
{
if(lenth[i]>lenth[i-1])
{
e=id[i][0];
id[i][0]=id[i-1][0];
id[i-1][0]=e;
e=id[i][1];
id[i][1]=id[i-1][1];
id[i-1][1]=e;
e=lenth[i];
lenth[i]=lenth[i-1];
lenth[i-1]=e;
}
}
}
for(int i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",point[id[i][0]][0],point[id[i][0]][1],point[id[i][0]][2],point[id[i][1]][0],point[id[i][1]][1],point[id[i][1]][2],lenth[i]);
}
scanf("%d",&n);
return 0;
} |
64 | 31553 | struct
{
int x;
int y;
int z;
} dot[10];
struct
{
int f1;
int f2;
double dis;
} d[55], t;
int main()
{
int n, i, j, c = 0, x1, y1, z1;
cin >> n;
for (i = 0; i < n; i++)
cin >> dot[i].x >> dot[i].y >> dot[i].z;
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
x1 = (dot[i].x - dot[j].x) * (dot[i].x - dot[j].x);
y1 = (dot[i].y - dot[j].y) * (dot[i].y - dot[j].y);
z1 = (dot[i].z - dot[j].z) * (dot[i].z - dot[j].z);
d[c].f1 = i;
d[c].f2 = j;
d[c++].dis = sqrt(x1 + y1 + z1);
}
}
for (i = 0; i < c; i++)
for (j = c - 1; j > i; j--)
{
if (d[j].dis > d[j - 1].dis)
{
t = d[j - 1];
d[j - 1] = d[j];
d[j] = t;
}
}
for (i = 0; i < c; i++)
{
cout << '(' << dot[d[i].f1].x << ',' << dot[d[i].f1].y << ',' << dot[d[i].f1].z << ")-("
<< dot[d[i].f2].x << ',' << dot[d[i].f2].y << ',' << dot[d[i].f2].z << ")=";
cout << fixed << setprecision(2) << d[i].dis << endl;
}
return 0;
}
|
64 | 31554 | int main()
{
typedef struct _Point
{
int x,y,z;
} Point;
typedef struct _Distance
{
int first, second;
float dist;
} Distance;
Point point[10];
int n;
scanf("%d", &n);
int i,j,total = n*(n-1)>>1;
n--;
for(i=0; i<=n; i++)
scanf("%d%d%d", &point[i].x, &point[i].y, &point[i].z);
Distance * pDistance = (Distance *)malloc(total * sizeof(Distance));
int k = 0;
for(i=0; i<n; i++)
for(j=i+1; j<=n; j++)
{
pDistance[k].first = i;
pDistance[k].second = j;
pDistance[k].dist = sqrt((float)((point[i].x-point[j].x)*(point[i].x-point[j].x) +
(point[i].y-point[j].y)*(point[i].y-point[j].y) +
(point[i].z-point[j].z)*(point[i].z-point[j].z)));
k++;
}
for(i=1; i<total; i++)
{
int tmp = total - i;
for(j=0; j<tmp; j++)
if(pDistance[j].dist < pDistance[j+1].dist)
{
Distance tmp = pDistance[j];
pDistance[j] = pDistance[j+1];
pDistance[j+1] = tmp;
}
}
for(i=0; i<k; i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n", point[pDistance[i].first].x, point[pDistance[i].first].y,
point[pDistance[i].first].z, point[pDistance[i].second].x, point[pDistance[i].second].y,
point[pDistance[i].second].z, pDistance[i].dist);
free(pDistance);
return 0;
} |
64 | 31555 |
int main(){
int n,i,j,k,l;
int x[20],y[20],z[20];
struct
{
int x1,y1,z1;
int x2,y2,z2;
double dis;
}
out[50],h;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
out[k].x1=x[i];
out[k].y1=y[i];
out[k].z1=z[i];
out[k].x2=x[j];
out[k].y2=y[j];
out[k].z2=z[j];
k++;
}
}
for(i=0;i<n*(n-1)/2;i++)
{
out[i].dis=sqrt((out[i].x1-out[i].x2)*(out[i].x1-out[i].x2)
+(out[i].y1-out[i].y2)*(out[i].y1-out[i].y2)
+(out[i].z1-out[i].z2)*(out[i].z1-out[i].z2));
}
for(i=0;i<n*(n-1)/2;i++)
{
for(j=n*(n-1)/2-1;j>i;j--)
{
if(out[j].dis>out[j-1].dis)
{
h=out[j];
out[j]=out[j-1];
out[j-1]=h;
}
}
}
for(i=0;i<n*(n-1)/2;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",out[i].x1,
out[i].y1,out[i].z1,out[i].x2,out[i].y2,out[i].z2
,out[i].dis);
}
return 0;
}
|
64 | 31556 | struct
{
float a;
int f,g;
}s[50],temp;
void main()
{
int n,i,j,x[10],y[10],z[10];
scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d%d%d",&x[i],&y[i],&z[i]);
int t=0;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{
s[t].a=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
s[t].f=i;
s[t].g=j;
t++;
}
for(i=0;i<t-1;i++)
for(j=0;j<t-i-1;j++)
if(s[j].a<s[j+1].a)
{
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
for(i=0;i<t;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",x[s[i].f],y[s[i].f],z[s[i].f],x[s[i].g],y[s[i].g],z[s[i].g],s[i].a);
} |
64 | 31557 | struct dis{
int p1[3];
int p2[3];
double d;
};
void main()
{
int a[10][3],i,j,k,r,n;
struct dis dt[45],t;
scanf("%d",&n);
for (i=0;i<n;i++)
{
for (j=0;j<3;j++)
{
scanf("%d",&a[i][j]);
}
}
for (i=0,r=0;i<n;i++)
{
for (j=i+1;j<n;j++)
{
for (dt[r].d=0,k=0;k<3;k++)
{
dt[r].p1[k]=a[i][k];
dt[r].p2[k]=a[j][k];
dt[r].d+=(a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
}
dt[r].d=sqrt(dt[r].d);
r++;
}
}
for (r=1;r<n*(n-1)/2;r++)
{
for (k=0;k<n*(n-1)/2-r;k++)
{
if (dt[k].d<=dt[k+1].d)
{
t=dt[k];
dt[k]=dt[k+1];
dt[k+1]=t;
}
}
}
for (i=r-1;dt[i].d==dt[i-1].d;i--);
for (j=r-1;j>i;j--)
{
for (k=r-1;k>=i+r-j;k--)
{
t=dt[k];
dt[k]=dt[k-1];
dt[k-1]=t;
}
}
for (i=0;i<r;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dt[i].p1[0],dt[i].p1[1],dt[i].p1[2],dt[i].p2[0],dt[i].p2[1],dt[i].p2[2],dt[i].d);
}
} |
64 | 31558 | double sqrt(double x);
int main(){
int n;
int sz[10][3];
int f=0;
double jl[100];
int zbx[100],zby[100];
scanf("%d",&n);
for(int s=0;s<n;s++){
for(int c=0;c<3;c++){
scanf("%d",&sz[s][c]);
}
}
for(int r=0;r<n;r++){
for(int t=r+1;t<n;t++){
jl[f]=sqrt(((sz[r][0]-sz[t][0])*(sz[r][0]-sz[t][0]))+((sz[r][1]-sz[t][1])*(sz[r][1]-sz[t][1]))+((sz[r][2]-sz[t][2])*(sz[r][2]-sz[t][2])));
zbx[f]=r;
zby[f]=t;
f++;
}
}
for(int k=1;k<=f;k++){
int b,p;
double e;
for(int m=0;m<f-k;m++){
if(jl[m]<jl[m+1]){
e=jl[m];b=zbx[m];p=zby[m];
jl[m]=jl[m+1];zbx[m]=zbx[m+1];zby[m]=zby[m+1];
jl[m+1]=e;zbx[m+1]=b;zby[m+1]=p;
}
}
}
for(int q=0;q<f;q++){
printf("(");
for(int l=0;l<2;l++){
printf("%d,",sz[zbx[q]][l]);
}
printf("%d)",sz[zbx[q]][2]);
printf("-(");
for(int h=0;h<2;h++){
printf("%d,",sz[zby[q]][h]);
}
printf("%d)=",sz[zby[q]][2]);
printf("%.2lf\n",jl[q]);
}
return 0;
} |
64 | 31559 | struct point{
int a[3];
int b[3];
double distant;
}p[45],change;
void swap(struct point p[],int k);
void main()
{
int i,j,k=0,n;
int x[10],y[10],z[10];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&x[i],&y[i],&z[i]);
for(j=0;j<n-1;j++)
for(i=j+1;i<n;i++){
p[k].a[0]=x[j];
p[k].a[1]=y[j];
p[k].a[2]=z[j];
p[k].b[0]=x[i];
p[k].b[1]=y[i];
p[k].b[2]=z[i];
p[k++].distant=sqrt(pow(x[j]-x[i],2)+pow(y[j]-y[i],2)+pow(z[j]-z[i],2));
}
swap(p,k-1);
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",p[i].a[0],p[i].a[1],p[i].a[2],p[i].b[0],p[i].b[1],p[i].b[2],p[i].distant);
}
void swap(struct point p[],int k)
{
int r,q;
for(r=0;r<k;r++)
for(q=0;q<k-r;q++)
if(p[q].distant<p[q+1].distant){
change=p[q];
p[q]=p[q+1];
p[q+1]=change;
}
} |
64 | 31560 | int main() {
int n,a[1000][3],i,j,x,e;
double jl[1000][1000],m,k;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d%d%d",&a[i][0],&a[i][1],&a[i][2]);
}
k=0;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
m=(a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]);
jl[i][j]=sqrt(1.0*m);
if(k<jl[i][j]){
k=jl[i][j];
}
}
}
for(x=1;x<=n*(n-1)/2;x++){
e=0;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(k==jl[i][j] && e==0){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[i][0],a[i][1],a[i][2],a[j][0],a[j][1],a[j][2],jl[i][j]);
jl[i][j]=0;
k=0;
e=1;
}
}
}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(k<jl[i][j]){
k=jl[i][j];
}
}
}
}
return 0;
} |
64 | 31561 | struct District
{
int x;
int y;
int z;
}dis[11];//????
struct Distance
{
int a;
int b;
double c;
}d[91],temp;//?????????
int main()
{
int n,k=1;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>dis[i].x>>dis[i].y>>dis[i].z;
}
for(int i=1;i<n;i++)
{
for(int j=i+1;j<=n;j++)
{
d[k].a=i;
d[k].b=j;
d[k].c=sqrt((double)(dis[i].x-dis[j].x)*(dis[i].x-dis[j].x)+(dis[i].y-dis[j].y)*(dis[i].y-dis[j].y)+(dis[i].z-dis[j].z)*(dis[i].z-dis[j].z));
k++;
}
}//?i????j?????
for(int i=1;i<=k-2;i++)
{
for(int j=1;j<=k-i;j++)
{
if(d[j].c<d[j+1].c)
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}
}//??????
for(int i=1;i<=k-1;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",dis[d[i].a].x,dis[d[i].a].y,dis[d[i].a].z,dis[d[i].b].x,dis[d[i].b].y,dis[d[i].b].z,d[i].c);
}//??
return 0;
}
|
64 | 31562 | double a[10000],g[10000];
void mppx(double a[],int n);
int main()
{
int n,i,j,k,l,v,w;
double d,e,f;
struct b{
double x,y,z;
}c[1000];
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%lf%lf%lf",&(c[i].x),&(c[i].y),&(c[i].z));
}
j=0;
k=1;
for(i=0;i<(n-1)*n/2;i++){
d=(c[j].x-c[k].x)*(c[j].x-c[k].x);
e=(c[j].y-c[k].y)*(c[j].y-c[k].y);
f=(c[j].z-c[k].z)*(c[j].z-c[k].z);
if(e<0){
e=-e;
}
if(f<0){
f=-f;
}
if(d<0){
d=-d;
}
a[i]=d+e+f;
a[i]=sqrt(a[i]);
k++;
if(k==n){
j++;
k=j+1;
}
}
mppx(a,n*(n-1)/2);
l=0;
v=n-1;
for(i=0;i<(n-1)*n/2;i++){
for(j=0;j<(n-1)*n/2;j++){
if(a[j]==g[i]){
for(w=j;w>=v;j=j){
if(w>=v){
l++;
w=w-v+l;
}
}
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",(int)(c[l].x),(int)(c[l].y),(int)(c[l].z),(int)(c[w+1].x),(int)(c[w+1].y),(int)(c[w+1].z),g[i]);
a[j]=0;
l=0;
break;
}
}
}
return 0;
}
void mppx(double a[],int n){
int i,j;
double t;
for(i=0;i<n;i++){
g[i]=a[i];
}
for(i=0;i<n-1;i++){
for(j=n-2;j>=0;j--){
if(g[j]<g[j+1]){
t=g[j];
g[j]=g[j+1];
g[j+1]=t;
}
}
}
} |
64 | 31563 | int main()
{
int n,i,e,j=1,k;
int x[10];
int y[10];
int z[10];
double a[45],m;
int b[45];
int c[45];
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d %d %d",&(x[i]),&(y[i]),&(z[i]));
}
for(i=1;i<=n-1;i++){
for(k=i+1;k<=n;k++){
a[j]=sqrt((x[i]-x[k])*(x[i]-x[k])+(y[i]-y[k])*(y[i]-y[k])+(z[i]-z[k])*(z[i]-z[k]));
b[j]=i;
c[j]=k;
j++;}}
j=j-1;
for(k=1;k<=j-1;k++){
for(i=1;i<=j-k;i++){
if(a[i]<a[i+1]){
m=a[i];a[i]=a[i+1];a[i+1]=m;
e=b[i];b[i]=b[i+1];b[i+1]=e;
e=c[i];c[i]=c[i+1];c[i+1]=e;
}}}
for(k=1;k<=j;k++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[b[k]],y[b[k]],z[b[k]],x[c[k]],y[c[k]],z[c[k]],a[k])
;}
return 0;
}
|
64 | 31564 | int main()
{
int n,i,m,x[100],y[100],z[100],r[100],t[100],a,b,k,c,d,p;
double q[100],e;
m=0;
scanf("%d", &n);
for(i=0;i<n;i++){
scanf("%d%d%d", &x[i], &y[i], &z[i]);}
for(k=0;k<n;k++){
for(i=k+1;i<n;i++){
q[m]=sqrt(1.0*(x[i]-x[k])*(x[i]-x[k])+1.0*(y[i]-y[k])*(y[i]-y[k])+1.0*(z[i]-z[k])*(z[i]-z[k]));
r[m]=k;
t[m]=i;
m++;}
}
p=n*(n-1)/2;
for(a=1;a<p+1;a++){
for(m=0;m<p-a;m++){
if(q[m]<q[m+1]){
e=q[m+1];
q[m+1]=q[m];
q[m]=e;
b=r[m+1];
r[m+1]=r[m];
r[m]=b;
b=t[m+1];
t[m+1]=t[m];
t[m]=b;}
}
}
c=0;
d=0;
for(m=0;m<p;m++){
c=r[m];
d=t[m];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n", x[c], y[c], z[c], x[d], y[d], z[d], q[m]);}
return 0;
} |
64 | 31565 | int main() {
int n;
int a[10][3];
int i,j;
int b[100][2];
double s[100];
scanf("%d", &n);
for(i=0;i<n;i++) {
scanf("%d%d%d",&(a[i][0]), &(a[i][1]), &(a[i][2]));
}
int k=0;
for(i=0;i<n-1;i++) {
for(j=i+1;j<n;j++) {
s[k] = sqrt(pow(a[i][0]-a[j][0],2)+pow(a[i][1]-a[j][1],2)+pow(a[i][2]-a[j][2],2));
b[k][0] = i;
b[k][1] = j;
k++;
}
}
for(i=1; i<k; i++) {
for(j=0;j<k-i;j++) {
if(s[j] < s[j+1]) {
double t=s[j];
s[j]=s[j+1];
s[j+1]=t;
int tt=b[j][0];
b[j][0]=b[j+1][0];
b[j+1][0]=tt;
tt=b[j][1];
b[j][1]=b[j+1][1];
b[j+1][1]=tt;
}
}
}
for(i=0;i<k;i++) {
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n", a[b[i][0]][0], a[b[i][0]][1], a[b[i][0]][2], a[b[i][1]][0], a[b[i][1]][1], a[b[i][1]][2], s[i]);
}
return 0;
} |
64 | 31566 | int main()
{
int n,i,j,k;
int x,y;
int a[10][3];
double b[45][3],temp;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&a[i][0],&a[i][1],&a[i][2]);
for(i=0,k=0;i<n;i++)
for(j=i+1;j<n;j++){
b[k][0]=i;
b[k][1]=j;
b[k][2]=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
k++;
}
for(i=1;i<k;i++)
for(j=0;j<k-i;j++){
if(b[j][2]<b[j+1][2]){
temp=b[j][0];b[j][0]=b[j+1][0];b[j+1][0]=temp;
temp=b[j][1];b[j][1]=b[j+1][1];b[j+1][1]=temp;
temp=b[j][2];b[j][2]=b[j+1][2];b[j+1][2]=temp;
}
if(b[j][2]==b[j+1][2]){
if(b[j][0]>b[j+1][0]){
temp=b[j][0];b[j][0]=b[j+1][0];b[j+1][0]=temp;
temp=b[j][1];b[j][1]=b[j+1][1];b[j+1][1]=temp;
temp=b[j][2];b[j][2]=b[j+1][2];b[j+1][2]=temp;
}
if(b[j][0]==b[j+1][0])
if(b[j][1]>b[j+1][1]){
temp=b[j][0];b[j][0]=b[j+1][0];b[j+1][0]=temp;
temp=b[j][1];b[j][1]=b[j+1][1];b[j+1][1]=temp;
temp=b[j][2];b[j][2]=b[j+1][2];b[j+1][2]=temp;
}
}
}
for(i=0;i<k;i++){
x=b[i][0];y=b[i][1];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[x][0],a[x][1],a[x][2],a[y][0],a[y][1],a[y][2],b[i][2]);
}
return 0;
} |
64 | 31567 | int main(){
int n;
scanf("%d",&n);
int i,j=0,x[100],y[100],z[100],nlx[100],nly[100],nlz[100],nfx[100],nfy[100],nfz[100];
for(i=0;i<n;i++){
scanf("%d %d %d",&x[i],&y[i],&z[i]);
}
double d,jl[45];
for(i=0;i<n-1;i++){
for(int k=i+1;k<n;k++){
d=1.0*(x[i]-x[k])*(x[i]-x[k])+1.0*(y[i]-y[k])*(y[i]-y[k])+1.0*(z[i]-z[k])*(z[i]-z[k]);
jl[j]=sqrt(d);
nfx[j]=x[i];
nfy[j]=y[i];
nfz[j]=z[i];
nlx[j]=x[k];
nly[j]=y[k];
nlz[j]=z[k];
j++;
}
}
int result;
result=n*(n-1)/2;
for(int k=1;k<=result;k++){
double e;
for(j=0;j<result-k;j++){
if(jl[j]<jl[j+1]){
e=jl[j+1];
jl[j+1]=jl[j];
jl[j]=e;
e=nfx[j+1];
nfx[j+1]=nfx[j];
nfx[j]=e;
e=nfy[j+1];
nfy[j+1]=nfy[j];
nfy[j]=e;
e=nfz[j+1];
nfz[j+1]=nfz[j];
nfz[j]=e;
e=nlx[j+1];
nlx[j+1]=nlx[j];
nlx[j]=e;
e=nly[j+1];
nly[j+1]=nly[j];
nly[j]=e;
e=nlz[j+1];
nlz[j+1]=nlz[j];
nlz[j]=e;
}
}
}
for(j=0;j<result;j++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",nfx[j],nfy[j],nfz[j],nlx[j],nly[j],nlz[j],jl[j]);
}
return 0;
}
|
64 | 31568 | main()
{
struct B
{int a;int b;int c;int d;int e;int f;float g;}B[45];
int n,A[10][3],i,j,p=0,q=0;
float c[45];
scanf("%d",&n);
for(i=0;i<n;i++)
for(j=0;j<3;j++)
scanf("%d",&A[i][j]);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
B[p].a=A[i][0];
B[p].b=A[i][1];
B[p].c=A[i][2];
B[p].d=A[j][0];
B[p].e=A[j][1];
B[p].f=A[j][2];
B[p].g=(float)sqrt((A[i][0]-A[j][0])*(A[i][0]-A[j][0])+(A[i][1]-A[j][1])*(A[i][1]-A[j][1])+(A[i][2]-A[j][2])*(A[i][2]-A[j][2]));
p++;
}
for(i=0;i<p;i++)
{
c[i]=0;
if(i==0){for(j=0;j<p;j++)if(B[j].g>c[i]) {c[i]=B[j].g;q++;}}
else
for(j=0;j<p;j++)
{
if(c[i]<B[j].g&&B[j].g<c[i-1])
{c[i]=B[j].g;q++;}
}
}
int z=0;
for(i=0;i<q;i++)
for(j=0;j<p;j++)
{ if(z==n*(n-1)/2)break;
if(B[j].g==c[i])
{z++;printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",B[j].a,B[j].b,B[j].c,B[j].d,B[j].e,B[j].f,B[j].g);
}
}
} |
64 | 31569 |
int main()
{
int n,i,j,k;
double x,y,z;
int a[10][3]={0};;
double b[45]={0};
int c[45]={0},d[45]={0};
cin>> n;
for(i=0;i<n;i++)
{
cin>> a[i][0] >> a[i][1] >> a[i][2];
}
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
x=y=z=0;
x=(a[i][0]-a[j][0])*(a[i][0]-a[j][0]);
y=(a[i][1]-a[j][1])*(a[i][1]-a[j][1]);
z=(a[i][2]-a[j][2])*(a[i][2]-a[j][2]);
b[k]=sqrt(x+y+z);c[k]=i;d[k]=j;
k++;
}
}
for(i=0;i<n*(n-1)/2-1;i++)
{
for(j=0;j<n*(n-1)/2-i-1;j++)
{
if(b[j]<b[j+1])
{
x=b[j];b[j]=b[j+1];b[j+1]=x;
k=c[j];c[j]=c[j+1];c[j+1]=k;
k=d[j];d[j]=d[j+1];d[j+1]=k;
}
}
}
for(i=0;i<n*(n-1)/2;i++)
{
cout<<"("<<a[c[i]][0]<<","<<a[c[i]][1]<<","<<a[c[i]][2]<<")-("<<a[d[i]][0]<<","<<a[d[i]][1]<<","<<a[d[i]][2]<<")=";
printf("%.2f",b[i]);cout<<endl;
}
return 0;
}
|
64 | 31570 | int main()
{
int n,l=0,a[101],i,j,b[101],c[101],f[50],g[50],x;
double e[50],y;
for(i=0;i<50;i++){e[i]=0;}
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d %d %d",&a[i],&b[i],&c[i]);
}
for(j=0;j<n-1;j++)
{
for(i=j+1;i<n;i++)
{
e[l]=sqrt((a[j]-a[i])*(a[j]-a[i])+(b[j]-b[i])*(b[j]-b[i])+(c[j]-c[i])*(c[j]-c[i]));
f[l]=j;
g[l]=i;
l++;
}
}
for(l=0;l<(n*(n-1))/2;l++)
{
for(i=0;i<(n*(n-1)/2-1);i++)
{
if(e[i]<e[i+1])
{
y=e[i];
e[i]=e[i+1];
e[i+1]=y;
x=f[i];
f[i]=f[i+1];
f[i+1]=x;
x=g[i];
g[i]=g[i+1];
g[i+1]=x;
}
}
}
for(l=0;l<n*(n-1)/2;l++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[f[l]],b[f[l]],c[f[l]],a[g[l]],b[g[l]],c[g[l]],e[l]);
}
return 0;
}
|
64 | 31571 | int main()
{
int n,j,q;
scanf("%d",&n);
struct zb {
int x,y,z;
} zb[1000];
for(q=0;q<n;q++){
scanf("%d%d%d",&(zb[q].x),&(zb[q].y),&(zb[q].z));
}
int i=0;
struct jl {
int x1,x2,y1,y2,z1,z2;
double s;
} jl[1000];
for(q=0;q<n-1;q++){
for(j=q+1;j<n;j++){
jl[i].x1=zb[q].x;
jl[i].x2=zb[j].x;
jl[i].y1=zb[q].y;
jl[i].y2=zb[j].y;
jl[i].z1=zb[q].z;
jl[i].z2=zb[j].z;
int a,b,c;
double f;
a=jl[i].x1-jl[i].x2;
b=jl[i].y1-jl[i].y2;
c=jl[i].z1-jl[i].z2;
f=a*a+b*b+c*c;
jl[i].s=sqrt(f);
i++;
}
}
int m;
m=i;
for(q=1;q<=m;q++){
for(j=0;j<m-q;j++){
if((jl[j+1].s)>(jl[j].s)){
jl[1000]=jl[j+1];
jl[j+1]=jl[j];
jl[j]=jl[1000];
}
}
}
for(i=0;i<m;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",jl[i].x1,jl[i].y1,jl[i].z1,jl[i].x2,jl[i].y2,jl[i].z2,jl[i].s);
}
return 0;
} |
64 | 31572 | struct distance
{
double d;
int dx;
int dy;
}dis[100] = {0}, t;
struct point
{
int x;
int y;
int z;
}poi[10] = {0};
void input(int);
void calculate(int);
void arrange(int);
void output(int);
int main()
{
int n;
cin >> n;
input(n);
calculate(n);
arrange(n);
output(n);
return 0;
}
void input(int n)
{
int i;
for(i = 0; i <
n; i++)
{
cin >> poi[i].x >> poi[i].y >> poi[i].z;
}
}
void calculate(int n)
{
int i;
/* for(i = 0; i < n * n; i++)
{
dis[i].d = sqrt((poi[i/n].x - poi[i%n].x) * (poi[i/n].x - poi[i%n].x)+
(poi[i/n].y - poi[i%n].y) * (poi[i/n].y - poi[i%n].y)+
(poi[i/n].z - poi[i%n].z) * (poi[i/n].z - poi[i%n].z));
dis[i].dx = i / n;
dis[i].dy = i % n;
}
*/
int x1 = 0, y1 = 1;
for(i = 0; i < n * (n - 1) / 2; i++)
{
dis[i].d = sqrt((poi[x1].x - poi[y1].x) * (poi[x1].x - poi[y1].x) +
(poi[x1].y - poi[y1].y) * (poi[x1].y - poi[y1].y) +
(poi[x1].z - poi[y1].z) * (poi[x1].z - poi[y1].z));
dis[i].dx = x1;
dis[i].dy = y1;
y1++;
if(y1 == n)
{
x1++;
y1 = x1 + 1;
}
}
return;
}
void arrange(int n)
{
int i;
int j;
for(i = 0; i < n * (n - 1) / 2 - 1; i++)
{
for(j = 0; j < n * (n - 1) / 2 - i - 1; j++)
{
if(dis[j].d < dis[j + 1].d)
{
t = dis[j];
dis[j] = dis[j + 1];
dis[j + 1] = t;
}
}
}
return;
}
void output(int n)
{
int i;
for(i = 0; i < n * (n - 1) / 2; i++) //(0,0,0)-(1,1,1)=1.73
{
cout << "(" << poi[dis[i].dx].x << "," << poi[dis[i].dx].y << "," << poi[dis[i].dx].z << ")-("
<< poi[dis[i].dy].x << "," << poi[dis[i].dy].y << "," << poi[dis[i].dy].z << ")="
<< setprecision(2) << fixed <<dis[i].d << endl;
}
return;
}
|
64 | 31573 | int main(){
int n,i,p,j,e,k,u;
double s[50];
int x[10],y[10],z[10];
struct result{
int x1,y1,z1,x2,y2,z2;
double s;
}a[50],t;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
p=(n*(n-1))/2;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
e=(n-1.0*(i+1)/2)*i+j-i-1;
u=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
s[e]=sqrt(1.0*u);
}
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
e=(n-1.0*(i+1)/2)*i+j-i-1;
a[e].x1=x[i];
a[e].y1=y[i];
a[e].z1=z[i];
a[e].x2=x[j];
a[e].y2=y[j];
a[e].z2=z[j];
a[e].s=s[e];
}
}
for(k=1;k<=p;k++){
for(i=0;i<p-k;i++){
if(a[i].s<a[i+1].s){
t=a[i+1];
a[i+1]=a[i];
a[i]=t;
}
}
}
for(i=0;i<p;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[i].x1,a[i].y1,a[i].z1,a[i].x2,a[i].y2,a[i].z2,a[i].s);
}
return 0;
} |
64 | 31574 | int main(){
int n,m,j,e,x[101],y[101],z[101],a[20000],b[20000];
int s[10000];
int t=0;
double c[10000];
scanf("%d\n",&n);
for(int i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);}
for(int i=0;i<n;i++){
for(j=i+1;j<n;j++){
s[t]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
a[t]=i;b[t]=j;t++;
}}
for(int i=0;i<t-1;i++){
for(j=0;j<t-i-1;j++){
if(s[j]<s[j+1]){
e=s[j+1];
s[j+1]=s[j];
s[j]=e;
e=a[j+1];a[j+1]=a[j];a[j]=e;e=b[j+1];b[j+1]=b[j];b[j]=e;
}
}}
for(m=0;m<t;m++){
c[m]=1.0*sqrt(s[m]);}
for(m=0;m<t;m++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[a[m]],y[a[m]],z[a[m]],x[b[m]],y[b[m]],z[b[m]],c[m]);}
return 0;
}
|
64 | 31575 | int main() {
int n,i,h,k,m;
scanf("%d",&n);
double dj[30];
struct dian {
double x,y,z;
} d[10];
struct jl {
double x1,y1,z1,x2,y2,z2;
double c;
} cd[46];
for(i=0;i<3*n;i++){
scanf("%lf",&(dj[i]));}
for(i=0;i<n;i++){
d[i].x=dj[3*i];
d[i].y=dj[3*i+1];
d[i].z=dj[3*i+2];}
k=0;
for(i=0;i<n-1;i++){
for(h=1;h<n-i;h++){
cd[k].x1=d[i].x;
cd[k].y1=d[i].y;
cd[k].z1=d[i].z;
cd[k].x2=d[i+h].x;
cd[k].y2=d[i+h].y;
cd[k].z2=d[i+h].z;
cd[k].c=sqrt(((cd[k].x1-cd[k].x2)*(cd[k].x1-cd[k].x2)+(cd[k].y1-cd[k].y2)*(cd[k].y1-cd[k].y2)+(cd[k].z1-cd[k].z2)*(cd[k].z1-cd[k].z2)));
k++;}}
m=k;
for(k=1;k<m;k++){
for(i=0;i<m-k;i++){
if((cd[i].c)<(cd[i+1].c)){
cd[45]=cd[i+1];
cd[i+1]=cd[i];
cd[i]=cd[45];}}}
for(i=0;i<m;i++){
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",cd[i].x1,cd[i].y1,cd[i].z1,cd[i].x2,cd[i].y2,cd[i].z2,cd[i].c);}
return 0;} |
64 | 31576 | int main(){
int n,y;
scanf("%d\n",&n);
int x[n][3];
double jl[10][10],o;
for(int i=0;i<n;i++){
scanf("%d%d%d",&x[i][0],&x[i][1],&x[i][2]);
}
for(int i=0;i<n-1;i++){
for(int k=i+1;k<n;k++){
jl[i][k]=0;
}
}
for(int i=0;i<n-1;i++){
for(int k=i+1;k<n;k++){
jl[i][k]=sqrt((x[i][0]-x[k][0])*(x[i][0]-x[k][0])+(x[i][1]-x[k][1])*(x[i][1]-x[k][1])+(x[i][2]-x[k][2])*(x[i][2]-x[k][2]));
}
}
o=0;
int m,p,q,a=0;
m=n*(n-1)/2;
for(int i=0;i<9;i++){
if(a==m){
break;
}
for(int k=i+1;k<10;k++){
if(o<jl[i][k]){
o=jl[i][k];
p=i;
q=k;
}
if(i==8&&k==9){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[p][0],x[p][1],x[p][2],x[q][0],x[q][1],x[q][2],o);
jl[p][q]=0;
i=-1;
o=0;
a++;
}
}
}
return 0;
}
|
64 | 31577 | double jl(int ma,int mb,int mc,int md,int me,int mf);
int main(){
int a[max],b[max];
int i,k,n,j,h;
double t,s[max];
struct dian{
int x,y,z;
}d[max];
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d%d%d",&(d[i].x),&(d[i].y),&(d[i].z));
}
for(k=0,j=0;j<n;j++){
for(i=j+1;i<n;i++,k++){
s[k]=jl(d[i].x,d[i].y,d[i].z,d[j].x,d[j].y,d[j].z);
a[k]=i;
b[k]=j;
}
}
for(k=1;k<=n*(n-1)/2;k++){
for(i=0;i<n*(n-1)/2-k;i++){
if(s[i+1]>s[i]){
t=s[i+1];
s[i+1]=s[i];
h=a[i];
a[i]=a[i+1];
a[i+1]=h;
s[i]=t;
j=b[i];
b[i]=b[i+1];
b[i+1]=j;
}
}
}
for(i=0;i<n*(n-1)/2;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",d[b[i]].x,d[b[i]].y,d[b[i]].z,d[a[i]].x,d[a[i]].y,d[a[i]].z,s[i]);
}
return 0;
}
double jl(int ma,int mb,int mc,int md,int me,int mf){
double l;
l=sqrt((double)(ma-md)*(ma-md)+(mb-me)*(mb-me)+(mc-mf)*(mc-mf));
return l;
}
|
64 | 31578 | int main()
{
int n,i,j,a[10000],b[10000],m,x[100],y[100],z[100];
float dis[10000],t;
cin>>n;
for (i=1; i<=n; i++)
cin>>x[i]>>y[i]>>z[i];
int cnt=0;
for (i=1; i<=n; i++)
for (j=i+1; j<=n; j++)
{
dis[cnt]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
a[cnt]=i;
b[cnt]=j;
cnt=cnt+1;
}
for (i=0; i<cnt-1; i++)
for(j=0; j<cnt-1-i; j++)
if(dis[j]<dis[j+1]){
t=dis[j];
dis[j]=dis[j+1];
dis[j+1]=t;
m=a[j];
a[j]=a[j+1];
a[j+1]=m;
m=b[j];
b[j]=b[j+1];
b[j+1]=m;
}
for(i=0; i<cnt; i++)
cout<<fixed<<setprecision(2)<<"("<<x[a[i]]<<","<<y[a[i]]<<","<<z[a[i]]<<")-("<<x[b[i]]<<","<<y[b[i]]<<","<<z[b[i]]<<")="<<dis[i]<<endl;
return 0;
} |
64 | 31579 | int main(){
int n;
scanf("%d",&n);
int *x=(int*)malloc(sizeof(int)*n);
int *y=(int*)malloc(sizeof(int)*n);
int *z=(int*)malloc(sizeof(int)*n);
int i,j;
for(i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
double *d=(double*)malloc(sizeof(double)*((n-1)*n/2));
int *number1=(int*)malloc(sizeof(int)*((n-1)*n/2));
int *number2=(int*)malloc(sizeof(int)*((n-1)*n/2));
int pos=0; //number1?number2??????? (n-1)*n/2
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
//d[i]=sqrt((x[i]-x[j])^2+(y[i]-y[j])^2+(z[i]-z[j])^2); //~????????
d[pos]=sqrt(pow(x[i]-x[j],2)+pow(y[i]-y[j],2)+pow(z[i]-z[j],2));
number1[pos]=i;
number2[pos]=j;
pos++;
}
}
int k,f,g;
double e;
for(k=1;k<=(n-1)*n/2;k++){
for(i=0;i<(n-1)*n/2-k;i++){
if(d[i]<d[i+1]){
e=d[i];
d[i]=d[i+1];
d[i+1]=e;
f=number1[i];
number1[i]=number1[i+1];
number1[i+1]=f;
g=number2[i];
number2[i]=number2[i+1];
number2[i+1]=g;
}
}
}
for(k=0;k<(n-1)*n/2;k++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[number1[k]],y[number1[k]],z[number1[k]],x[number2[k]],y[number2[k]],z[number2[k]],d[k]);
}
free(x);
free(y);
free(z);
free(number1);
free(number2);
return 0;
}
|
64 | 31580 | int main()
{
int n,i,t,j,m,k;
float a[10],b[10],c[10];
float d[10][10];
int e[10][10];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%f %f %f",&a[i],&b[i],&c[i]);
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
d[i][j]=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])+(c[i]-c[j])*(c[i]-c[j]));
e[i][j]=1;
}
}
for(t=1;t<300;t++)
{
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(e[i][j]==0)
continue;
for(m=0;m<n-1;m++)
{
for(k=m+1;k<n;k++)
{
if(d[i][j]<d[m][k]&&e[m][k]!=0)
break;
}
if(k<n)
break;
}
if(m==n-1)
{
printf("(%.0f,%.0f,%.0f)-(%.0f,%.0f,%.0f)=%.2f\n",a[i],b[i],c[i],a[j],b[j],c[j],d[i][j]);
e[i][j]=0;
break;
}
}
if(j<n)
break;
}
}
return 0;
}
|
64 | 31581 | int main(){
int n,m,i,a,b,*sz,*jd,*wd;
double *d,c;
scanf("%d",&n);
m=0;
for(i=0;i<n;i++){
m+=n-1-i;
}
sz=(int*)malloc(sizeof(int)*3*n);
d=(double*)malloc(sizeof(double)*m);
jd=(int*)malloc(sizeof(int)*m);
wd=(int*)malloc(sizeof(int)*m);
for(i=0;i<3*n;i++){
scanf("%d",&sz[i]);
}
i=0;
for(a=0;a<n;a++){
for(b=a+1;b<n;b++){
d[i]=sqrt(1.0*(sz[3*a+0]-sz[3*b+0])*(sz[3*a+0]-sz[3*b+0])+(sz[3*a+1]-sz[3*b+1])*(sz[3*a+1]-sz[3*b+1])+(sz[3*a+2]-sz[3*b+2])*(sz[3*a+2]-sz[3*b+2]));
jd[i]=a;
wd[i]=b;
i++;
}
}
for(a=1;a<=m;a++){
for(b=0;b<m-a;b++){
if(d[b]<d[b+1]){
c=d[b];
d[b]=d[b+1];
d[b+1]=c;
i=jd[b];
jd[b]=jd[b+1];
jd[b+1]=i;
i=wd[b];
wd[b]=wd[b+1];
wd[b+1]=i;
}
}
}
for(i=0;i<m;i++){
a=jd[i];
b=wd[i];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",sz[3*a+0],sz[3*a+1],sz[3*a+2],sz[3*b+0],sz[3*b+1],sz[3*b+2],d[i]);
}
free(sz);
free(d);
free(jd);
free(wd);
return 0;
}
|
64 | 31582 | int main(){
int n,i,m,j,k,w,p;
int sz[1000][3],num[10000][2];
double d[1000],q;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d %d %d",&sz[i][0] ,&sz[i][1] ,&sz[i][2]);
}
m=n*(n-1)/2;
k=0;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
d[k]=sqrt((double)((sz[i][0]-sz[j][0])*(sz[i][0]-sz[j][0])+(sz[i][1]-sz[j][1])*(sz[i][1]-sz[j][1])+(sz[i][2]-sz[j][2])*(sz[i][2]-sz[j][2])));
num[k][0]=i;
num[k][1]=j;
k++;
}
}
for(j=1;j<=m;j++){
for(i=0;i<m-j;i++){
if(d[i]<d[i+1]){
q=d[i];d[i]=d[i+1];d[i+1]=q;
w=num[i][0];
num[i][0]=num[i+1][0];
num[i+1][0]=w;
p=num[i][1];
num[i][1]=num[i+1][1];
num[i+1][1]=p;
}
}
}
for(i=0;i<m;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",sz[num[i][0]][0],sz[num[i][0]][1],sz[num[i][0]][2],sz[num[i][1]][0],sz[num[i][1]][1],sz[num[i][1]][2],d[i]);
}
return 0;
}
|
64 | 31583 | typedef struct _DISTANCE{
float distance;
int pointa[3];
int pointb[3];
} DISTANCE;
int main() {
int n,i,j,k=0,b,m,point[10][3];
cin>>n;
for(i=0;i<n;i++){
for(j=0;j<3;j++){
cin>>point[i][j];
}
}
DISTANCE test[n*(n-1)/2];
for ( i = 0; i <n; ++i)
{
for(j=i+1;j<n;j++)
{
float distance=sqrt((point[i][0]-point[j][0])*(point[i][0]-point[j][0])+(point[i][1]-point[j][1])*(point[i][1]-point[j][1])+(point[i][2]-point[j][2])*(point[i][2]-point[j][2]));
test[k].distance=distance;
for(m=0;m<3;m++)
test[k].pointa[m]=point[i][m];
for(m=0;m<3;m++)
test[k].pointb[m]=point[j][m];
k++;
}
}
for ( i = 0; i <n*(n-1)/2-1 ; i++)
{
for(j = 0; j <n*(n-1)/2-i-1 ; j++)
{
if(test[j].distance<test[j+1].distance)
{
DISTANCE temp=test[j+1];
test[j+1]=test[j] ;
test[j]=temp;
}
}
}
for(k=0;k<n*(n-1)/2;k++)
{
cout<<"("<<test[k].pointa[0]<<","<<test[k].pointa[1]<<"," <<test[k].pointa[2]<<")"<<"-"<<"("<<test[k].pointb[0]<<","<<test[k].pointb[1]<<"," <<test[k].pointb[2]<<")"<<"=";
printf("%.2f\n",test[k].distance);
}
} |
64 | 31584 | void dx(int x, int y);
void ds(double x, double y);
int main()
{
int n,i,j,q,p,l,k;
scanf("%d",&n);
p=0.5*n*(n-1);
int x[n],y[n],z[n];
double o;
double jl[p];
int xx[p],yy[p],zz[p],xa[p],ya[p],za[p];
q=0;
for(i=0;i<n;i++)
{scanf("%d%d%d",&x[i],&y[i],&z[i]);}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
xx[q]=x[i];
yy[q]=y[i];
zz[q]=z[i];
xa[q]=x[j];
ya[q]=y[j];
za[q]=z[j];
jl[q]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
q++;
}
}
for(i=0;i<p;i++)
{
for(j=0;j<p-1;j++)
{
if(jl[j]<jl[j+1])
{
k=xx[j];
xx[j]=xx[j+1];
xx[j+1]=k;
k=yy[j];
yy[j]=yy[j+1];
yy[j+1]=k;
k=zz[j];
zz[j]=zz[j+1];
zz[j+1]=k;
k=ya[j];
ya[j]=ya[j+1];
ya[j+1]=k;
k=xa[j];
xa[j]=xa[j+1];
xa[j+1]=k;
k=za[j];
za[j]=za[j+1];
za[j+1]=k;
o=jl[j];
jl[j]=jl[j+1];
jl[j+1]=o;
}
}
}
for(i=0;i<p;i++)
{printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",xx[i],yy[i],zz[i],xa[i],ya[i],za[i],jl[i]);}
return 0;
}
void dx(int *x, int *y)
{
int e=0;
e=*x;
*x=*y;
*y=e;
return;
}
void ds(double *x, double *y)
{
double r=0;
r=*x;
*x=*y;
*y=r;
return;
}
|
64 | 31585 | int main()
{
int n,m,i,j,k=0;
int q,w;
int a[10000][4],c[10000],d[10000];
double b[10000],e;
scanf("%d",&n);
m=n*(n-1)/2;
for(i=0;i<n;i++)
{
scanf("%d",&a[i][0]);
scanf("%d",&a[i][1]);
scanf("%d",&a[i][2]);
}
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
b[k]=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
c[k]=i;
d[k]=j;
k++;
}
}
for(j=1;j<m;j++)
{
for(i=0;i<m-j;i++)
{
if(b[i+1]>b[i])
{
e=b[i];b[i]=b[i+1];b[i+1]=e;
q=c[i];c[i]=c[i+1];c[i+1]=q;
w=d[i];d[i]=d[i+1];d[i+1]=w;
}
}
}
for(i=0;i<m;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[c[i]][0],a[c[i]][1],a[c[i]][2],a[d[i]][0],a[d[i]][1],a[d[i]][2],b[i]);
return 0;
} |
64 | 31586 | int main()
{
double n,x[100],y[100],z[100],c[100],l[100][100],e;
int a[1000],b[1000],i,j,m,p,q;
scanf("%lf",&n);
m=0;
for(i=0;i<n;i++)
{
scanf("%lf%lf%lf",&x[i],&y[i],&z[i]);
}
for(i=0;i<n;i++)
{
for(j=(i+1);j<n;j++)
{
l[i][j]=sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
c[m]=l[i][j];
a[m]=i;
b[m]=j;
m=m+1;
}
}
for(p=0;p<m;p++)
{
for(q=0;q<(m-1-p);q++)
{
if(c[q]>c[q+1])
{
e=c[q+1];
c[q+1]=c[q];
c[q]=e;
e=a[q+1];
a[q+1]=a[q];
a[q]=e;
e=b[q+1];
b[q+1]=b[q];
b[q]=e;
}
}
}
for(p=0;p<m;p++)
{
for(q=0;q<(m-1-p);q++)
{
if(c[q]==c[q+1])
{
if(a[q]<a[q+1]||b[q]<b[q+1])
{
e=a[q+1];
a[q+1]=a[q];
a[q]=e;
e=b[q+1];
b[q+1]=b[q];
b[q]=e;
}
}
}
}
for(i=m-1;i>=0;i--)
{
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",x[a[i]],y[a[i]],z[a[i]],x[b[i]],y[b[i]],z[b[i]],c[i]);
}
return 0;
}
|
64 | 31587 | double distance(int xa,int ya,int za,int xb,int yb,int zb);
double distance(int xa,int ya,int za,int xb,int yb,int zb){
int sum;
double dis;
sum=(xb-xa)*(xb-xa)+(yb-ya)*(yb-ya)+(zb-za)*(zb-za);
dis=sqrt(sum);
return dis;
}
int main(){
int n,i,t,j,b=0,w=0,te;
double td;
scanf("%d",&n);
struct point{
int x,y,z;
}point[10];
for(i=0;i<n;i++)
scanf("%d %d %d",&point[i].x,&point[i].y,&point[i].z);
struct{
int p,q;
double dist;
}temp[45];
for(i=0;i<45;i++)
temp[i].dist=-1;
for(i=0;i<n;i++)
for(j=0;j<i;j++){
temp[w].p=i;
temp[w].q=j;
temp[w].dist=distance(point[i].x,point[i].y,point[i].z,point[j].x,point[j].y,point[j].z);
w=w+1;
}
for(i=0;i<45;i++)
for(w=0;w<44;w++)
if(temp[w].dist<temp[w+1].dist)
{
te=temp[w+1].p;
temp[w+1].p=temp[w].p;
temp[w].p=te;
te=temp[w+1].q;
temp[w+1].q=temp[w].q;
temp[w].q=te;
td=temp[w+1].dist;
temp[w+1].dist=temp[w].dist;
temp[w].dist=td;
}
for(w=0;w<45;w++)
if(temp[w].dist!=-1){
printf("(%d,%d,%d)-",point[temp[w].q].x,point[temp[w].q].y,point[temp[w].q].z);
printf("(%d,%d,%d)=",point[temp[w].p].x,point[temp[w].p].y,point[temp[w].p].z);
printf("%.2lf\n",temp[w].dist);
}
return 0;
}
|
64 | 31588 | int main()
{
int x[20] = {0}, y[20] = {0}, z[20] = {0}, n, flag1[200], flag2[200], i, j, k = 1, p;
double distance[200], t;
cin >> n;
for (i = 1; i <= n; i++)
{
cin >> x[i] >> y[i] >> z[i];
}
for (i = 1; i <= n; i++)
{
for (j = i + 1; j <= n; j++, k++)
{
distance[k] = sqrt(pow(x[i] - x[j], 2.0) + pow(y[i] - y[j], 2.0) + pow(z[i] - z[j], 2.0));
flag1[k] = i;
flag2[k] = j;
}
}
for (k = 1; k <= n * (n - 1) / 2; k++)
{
for (i = 1; i <= n * (n - 1) / 2 + 1 - k; i++)
{
if (distance[i] < distance[i + 1])
{
t = distance[i];
distance[i] = distance[i + 1];
distance[i + 1] = t;
p = flag1[i];
flag1[i] = flag1[i + 1];
flag1[i + 1] = p;
p = flag2[i];
flag2[i] = flag2[i + 1];
flag2[i + 1] = p;
}
}
}
for (i = 1; i <= n * (n - 1) / 2; i++)
{
cout << "(" << x[flag1[i]] << "," << y[flag1[i]] << "," << z[flag1[i]] << ")-(" << x[flag2[i]] << "," << y[flag2[i]] << "," << z[flag2[i]] << ")=" << fixed << setprecision(2) << distance[i] << endl;
}
return 0;
} |
64 | 31589 | int main(){
int n,i,j,c,d,s[10][3],k,f;
double a[10][10],e;
scanf("%d",&n);
for(i=0;i<n;i++){
for(j=0;j<3;j++){
scanf("%d",&s[i][j]);
}}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
a[i][j]=sqrt(pow(s[i][0]-s[j][0],2)+pow(s[i][2]-s[j][2],2)+pow(s[i][1]-s[j][1],2));
}}
e=0;f=(n*n-n)/2;
for(k=1;k<=f;k++){
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(e<a[i][j]){
e=a[i][j];
c=i;
d=j;
}}}
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",s[c][0],s[c][1],s[c][2],s[d][0],s[d][1],s[d][2],e);
e=0;
a[c][d]=0;
c=0;
d=0;
}
return 0;
}
|
64 | 31590 | int main(){
int a[10][3],dian[50][2],n,i,j,k=0,m;
double d[50],temp;
cin >> n;
for(i=0;i<n;i++){
cin >> a[i][0] >> a[i][1] >> a[i][2];}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
d[k]=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
dian[k][0]=i;
dian[k][1]=j;
k++;}
}
for(i=0;i<k-1;i++){
for(j=0;j<k-i-1;j++){
if(d[j]<d[j+1]){
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
m=dian[j][0],dian[j][0]=dian[j+1][0],dian[j+1][0]=m;
m=dian[j][1],dian[j][1]=dian[j+1][1],dian[j+1][1]=m;
}
}
}
for(i=0;i<k;i++){
cout <<"("<<a[dian[i][0]][0]<<","<<a[dian[i][0]][1]<<","<<a[dian[i][0]][2]<<")"<<"-"<<"("<<a[dian[i][1]][0]<<","<<a[dian[i][1]][1]<<","<<a[dian[i][1]][2]<<")"<<"="<<fixed<<setprecision(2)<<d[i]<<endl;
}
return 0;
}
|
64 | 31591 | struct loc
{
int x;
int y;
int z;
};
int main()
{
struct loc a[10];
double len[10][10],max;
int n,i,j,k,no1,no2;
memset(len,0,sizeof(len));
scanf("%d",&n);
for (i=0;i<n;i++)
scanf("%d%d%d",&a[i].x,&a[i].y,&a[i].z);
for (i=0;i<n-1;i++)
for (j=i+1;j<n;j++)
len[i][j]=sqrt((a[i].x-a[j].x)*(a[i].x-a[j].x)+(a[i].y-a[j].y)*(a[i].y-a[j].y)+(a[i].z-a[j].z)*(a[i].z-a[j].z));
for (k=0;k<(n-1)*n/2;k++)
{
max=0;
for (i=0;i<n-1;i++)
for (j=i+1;j<n;j++)
if (len[i][j]>max)
{
max=len[i][j];
no1=i;
no2=j;
}
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[no1].x,a[no1].y,a[no1].z,a[no2].x,a[no2].y,a[no2].z,len[no1][no2]);
len[no1][no2]=0;
}
return 0;
}
|
64 | 31592 |
int main()
{
int n;
struct dian
{
float a;
int x;
int y;
}a[45];
struct dian t;
int d[10][3];
int i,j,k=0;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&d[i][0],&d[i][1],&d[i][2]);
}
for(i=1;i<n;i++)
{
for(j=0;j<i;j++)
{
a[k].a=sqrt((d[i][0]-d[j][0])*(d[i][0]-d[j][0])+(d[i][1]-d[j][1])*(d[i][1]-d[j][1])+(d[i][2]-d[j][2])*(d[i][2]-d[j][2]));
a[k].x=j;
a[k].y=i;
k++;
}
}
for(i=0;i<k-1;i++)
{
for(j=0;j<k-1-i;j++)
{
if(a[j].a<a[j+1].a)
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",d[a[i].x][0],d[a[i].x][1],d[a[i].x][2],d[a[i].y][0],d[a[i].y][1],d[a[i].y][2],a[i].a);
}
return 0;
}
|
64 | 31593 | int main()
{
int sz1[10][3],n,i=0,m;
double d[100],e;
scanf("%d", &n);
m=n*(n-1)/2;
for (int row=0; row<n; row++){
for (int col=0; col<3; col++){
scanf("%d", &sz1[row][col]);
}
}
for (int row1=0; row1<n; row1++){
for (int row2=row1+1; row2<n; row2++){
d[i]=sqrt((pow(sz1[row1][0]-sz1[row2][0],2)+pow(sz1[row1][1]-sz1[row2][1],2)+pow(sz1[row1][2]-sz1[row2][2],2))*1.0);
i=i+1;
}
}
for(int k=1;k<=m;k++){
for (i=0;i<m-k;i++){
if (d[i]>d[i+1]){
e=d[i+1];
d[i+1]=d[i];
d[i]=e;
}
}
}
d[m]=0;
for (i=m-1;i>=0;i--){
for (int row1=0; row1<n; row1++){
for (int row2=row1+1; row2<n; row2++){
if(d[i]!=d[i+1]){
if(sqrt((pow(sz1[row1][0]-sz1[row2][0],2)+pow(sz1[row1][1]-sz1[row2][1],2)+pow(sz1[row1][2]-sz1[row2][2],2))*1.0)==d[i]){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",sz1[row1][0],sz1[row1][1],sz1[row1][2],sz1[row2][0],sz1[row2][1],sz1[row2][2],d[i]);
}}
}
}
}
return 0;
}
|
64 | 31594 |
int main() {
int n;
scanf("%d",&n);
struct coordinate{int x;int y;int z;int io;}pt[n];
int i;
for(i=0;i<n;i=i+1)
{
scanf("%d %d %d",&(pt[i].x),&(pt[i].y),&(pt[i].z));
pt[i].io=i;
}
int j;
int m;
m=n*(n-1)/2;//?????
struct distance{struct coordinate pt1;struct coordinate pt2;double l;}dist[m];
int t=0;
for(i=0;i<n;i=i+1)
{
for(j=i+1;j<n;j=j+1)
{
dist[t].pt1=pt[i];
dist[t].pt2=pt[j];
dist[t].l=sqrt(pow(1.0*(dist[t].pt1.x-dist[t].pt2.x),2.0)+pow(1.0*(dist[t].pt1.y-dist[t].pt2.y),2.0)+pow(1.0*(dist[t].pt1.z-dist[t].pt2.z),2.0));
t=t+1;
}
}
struct distance temp;
int s=0;
while(s==0)
{
s=1;
for(i=0;i<m-1;i++)
{
if(dist[i].l<dist[i+1].l)
{
temp=dist[i];
dist[i]=dist[i+1];
dist[i+1]=temp;
s=0;
}
}
}
for(i=0;i<m;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dist[i].pt1.x,dist[i].pt1.y,dist[i].pt1.z,dist[i].pt2.x,dist[i].pt2.y,dist[i].pt2.z,dist[i].l);
}
return(0);
}
|
64 | 31595 | int dist(int x1,int y1,int z1,int x2,int y2,int z2)
{
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2);
}
int main()
{
int x[10],y[10],z[10],d[100],i,j,n,m,k,a1[100],b1[100],c1[100],a2[100],b2[100],c2[100];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
k=0;
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
d[k]=dist(x[i],y[i],z[i],x[j],y[j],z[j]);
a1[k]=x[i];
b1[k]=y[i];
c1[k]=z[i];
a2[k]=x[j];
b2[k]=y[j];
c2[k]=z[j];
k++;
}
}
for(i=0;i<k-1;i++)
for(j=0;j<k-i-1;j++)
{
if(d[j]<d[j+1])
{
m=d[j];
d[j]=d[j+1];
d[j+1]=m;
m=a1[j];
a1[j]=a1[j+1];
a1[j+1]=m;
m=b1[j];
b1[j]=b1[j+1];
b1[j+1]=m;
m=c1[j];
c1[j]=c1[j+1];
c1[j+1]=m;
m=a2[j];
a2[j]=a2[j+1];
a2[j+1]=m;
m=b2[j];
b2[j]=b2[j+1];
b2[j+1]=m;
m=c2[j];
c2[j]=c2[j+1];
c2[j+1]=m;
}
}
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a1[i],b1[i],c1[i],a2[i],b2[i],c2[i],sqrt(d[i]));
return 0;
} |
64 | 31596 | void main()
{
struct point
{
int x;
int y;
int z;
}P[10];
struct triple
{
struct point A;
struct point B;
double d;
}pair[50],tmp;
int n,i,j,k,c[31];
scanf("%d",&n);
for(i=1;i<=3*n;i++)
scanf("%d",&c[i]);
for(i=0;i<n;i++)
{
(P[i]).x=c[3*i+1];
(P[i]).y=c[3*i+2];
(P[i]).z=c[3*i+3];
}
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
k=i*n+j-i*(i+3)/2;
(pair[k]).A=P[i];
(pair[k]).B=P[j];
int X=P[i].x-P[j].x;
int Y=P[i].y-P[j].y;
int Z=P[i].z-P[j].z;
(pair[k]).d=sqrt(X*X+Y*Y+Z*Z);
}
for(i=n*(n-1)/2;i>1;i--)
for(k=1;k<i;k++)
{
if ((pair[k]).d<(pair[k+1]).d)
{
tmp=pair[k+1];
pair[k+1]=pair[k];
pair[k]=tmp;
}
}
for(k=1;k<=n*(n-1)/2;k++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",(pair[k]).A.x,(pair[k]).A.y,(pair[k]).A.z,(pair[k]).B.x,(pair[k]).B.y,(pair[k]).B.z,(pair[k]).d);
}
|
64 | 31597 |
int main(){
int n,nn;
int a[101],b[101],c[101],x[46][3],y[46][3],xx[46],yy[46],px,py,pz;
double jl[46],m;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d %d %d",&a[i],&b[i],&c[i]);
}
int d=0;
for(int w=0;w<n;w++){
for(int j=w+1;j<n;j++){
jl[d]=sqrt(1.0*(a[w]-a[j])*(a[w]-a[j])+(b[w]-b[j])*(b[w]-b[j])+(c[w]-c[j])*(c[w]-c[j]));
x[d][0]=a[w];
x[d][1]=b[w];
x[d][2]=c[w];
y[d][0]=a[j];
y[d][1]=b[j];
y[d][2]=c[j];
xx[d]=w;
yy[d]=j;
d++;
}
}
for(int k=1;k<=n*(n-1)/2;k++){
for(int j=0;j<n*(n-1)/2-k;j++){
if(jl[j]>jl[j+1]||(xx[j]<xx[j+1]&&jl[j]==jl[j+1])||(yy[j]<yy[j+1]&&xx[j]==xx[j+1]&&jl[j]==jl[j+1])){
m=jl[j+1];
jl[j+1]=jl[j];
jl[j]=m;
nn=xx[j+1];
xx[j+1]=xx[j];
xx[j]=nn;
nn=yy[j+1];
yy[j+1]=yy[j];
yy[j]=nn;
px=x[j+1][0];
py=x[j+1][1];
pz=x[j+1][2];
x[j+1][0]=x[j][0];
x[j+1][1]=x[j][1];
x[j+1][2]=x[j][2];
x[j][0]=px;
x[j][1]=py;
x[j][2]=pz;
px=y[j+1][0];
py=y[j+1][1];
pz=y[j+1][2];
y[j+1][0]=y[j][0];
y[j+1][1]=y[j][1];
y[j+1][2]=y[j][2];
y[j][0]=px;
y[j][1]=py;
y[j][2]=pz;
}
}
}
for(int j=n*(n-1)/2-1;j>=0;j--){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",x[j][0],x[j][1],x[j][2],y[j][0],y[j][1],y[j][2],jl[j]);
}
}
|
64 | 31598 | struct point
{
int x;
int y;
int z;
}; //?????????
struct point dian[101];
double distance(struct point dian[],int i,int j){
int x=dian[i].x-dian[j].x;
int y=dian[i].y-dian[j].y;
int z=dian[i].z-dian[j].z;
double dis=(double)(x*x+y*y+z*z);
return sqrt(dis);
}
int main()
{
int n,i,j;
int t=0,k=0;
double a[105];
cin>>n;
for(i=0;i<n;++i)
cin>>dian[i].x>>dian[i].y>>dian[i].z;
for(i=0;i<n;++i)
for(j=i+1;j<n;++j)
{ int t=0;
while(t<k+1 &&(a[t]-distance(dian,i,j)>0.00001 ||distance(dian,i,j)-a[t]>0.00001)) t++;
if(t==k+1){ a[k]=distance(dian,i,j);
k++; }
}
int count=k;
for(i=0;i<count;i++)
for(j=0;j<count-i;j++)
if(a[j]<a[j+1]){
double temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
k=0;
while(k<count){
for(i=0;i<n;++i){
for(j=i+1;j<n;++j){
if(abs(a[k]-distance(dian,i,j))<0.0000001)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n\n",dian[i].x,dian[i].y,dian[i].z,dian[j].x,dian[j].y,dian[j].z,distance(dian,i,j));
}
}
k++;
}
//while(1);
return 0;
} |
64 | 31599 | int main(){
int n,i,j,k=0,z;
int a[10][3];
scanf("%d",&n);
for(i=0;i<n;i++){
if(i==0){
scanf("%d %d %d",&a[0][0],&a[0][1],&a[0][2]);
}
else{
scanf(" %d %d %d",&a[i][0],&a[i][1],&a[i][2]);}
}
struct {
int b[3],c[3];
float d;
}x[46];
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
x[k].b[0]=a[i][0];
x[k].b[1]=a[i][1];
x[k].b[2]=a[i][2];
x[k].c[0]=a[j][0];
x[k].c[1]=a[j][1];
x[k].c[2]=a[j][2];
x[k].d=sqrt((a[i][0]-a[j][0])*(a[i][0]-a[j][0])+(a[i][1]-a[j][1])*(a[i][1]-a[j][1])+(a[i][2]-a[j][2])*(a[i][2]-a[j][2]));
k++;
}
}
for(i=0;i<k;i++){
for(j=k-1;j>i;j--){
if(x[j].d>x[j-1].d){
x[45]=x[j];
x[j]=x[j-1];
x[j-1]=x[45];
}
}
}
for(i=0;i<k;i++){
printf("\n(%d,%d,%d)-(%d,%d,%d)=%.2f",x[i].b[0],x[i].b[1],x[i].b[2],x[i].c[0],x[i].c[1],x[i].c[2],x[i].d);
}
return 0;}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.