label
stringlengths 1
2
| index
stringlengths 1
5
| code
stringlengths 87
8.24k
|
|---|---|---|
64 | 31800 | int main()
{
double s[10][3],a[100],b[100]; //?s????n?????
double l[100];
int n;
int i,j,k=0,g=0,c,d;
double t;
cin>>n;
for(i=0;i<n;i++)
for(j=0;j<3;j++)
cin>>s[i][j];
for(i=0;i<n-1;i++)
{
for(g=i+1;g<n;g++)
{
l[k]=sqrt((s[i][0]-s[g][0])*(s[i][0]-s[g][0])+(s[i][1]-s[g][1])*(s[i][1]-s[g][1])+(s[i][2]-s[g][2])*(s[i][2]-s[g][2]));
a[k]=i;
b[k]=g;
k++;
}
}
k=k; //l????k????
for(i=0;i<k-1;i++)
for(j=0;j<k-i;j++)
{
if(l[j]<l[j+1])
{
t=l[j+1];
l[j+1]=l[j];
l[j]=t; //?????
t=0;
t=a[j+1];
a[j+1]=a[j];
a[j]=t;
t=0;
t=b[j+1];
b[j+1]=b[j];
b[j]=t; //??a?b?????l?????
}
}
for(i=0;i<k;i++)
{
c=a[i];
d=b[i];
cout<<"("<<s[c][0]<<","<<s[c][1]<<","<<s[c][2]<<")-("<<s[d][0]<<","<<s[d][1]<<","<<s[d][2]<<")=";
printf("%.2f",l[i]);
if(i<k-1)
cout<<endl;
}
return 0;
}
|
64 | 31801 | int main()
{
int n=0,k=0,j=0,count=0;//?????????
float x[10],y[10],z[10],d[45];//???????
int name[45][3];//??????????
cin>>n;
for(k=0;k<n;k++)//????
{
cin>>x[k]>>y[k]>>z[k];
}
for(k=0;k<n-1;k++)//????
{
for(j=k+1;j<n;j++)
{
d[count]=sqrt((x[k]-x[j])*(x[k]-x[j])+(y[k]-y[j])*(y[k]-y[j])+(z[k]-z[j])*(z[k]-z[j]));//??
name[count][1]=k;//??
name[count][2]=j;//??
count++;
}
}
for(k=0;k<count-1;k++)//?????
for(j=0;j<count-1-k;j++)
if(d[j]<d[j+1])
{
float a;
a=d[j];d[j]=d[j+1];d[j+1]=a;
a=name[j][1];name[j][1]=name[j+1][1];name[j+1][1]=a;
a=name[j][2];name[j][2]=name[j+1][2];name[j+1][2]=a;
}
for(k=0;k<count;k++)//??
{
cout<<"("<<x[name[k][1]]<<","<<y[name[k][1]]<<","<<z[name[k][1]]<<")-("<<x[name[k][2]]<<","<<y[name[k][2]]<<","<<z[name[k][2]]<<")=";
printf("%.2f\n",d[k]);
}
return 0;
} |
64 | 31802 | int main(){
int n,i,j,k,t,m,pair;
double e;
double sz[10][3],num[45][7];
scanf("%d",&n);
pair=n*(n-1)/2;
for(i=0;i<n;i++){
for(j=0;j<3;j++){
scanf("%lf",&sz[i][j]);
}
}
m=0;
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
for(k=0;k<3;k++){
num[m][k]=sz[i][k];
}
for(t=3;t<6;t++){
num[m][t]=sz[j][t-3];
}
num[m][6]=sqrt((num[m][0]-num[m][3])*(num[m][0]-num[m][3])+(num[m][1]-num[m][4])*(num[m][1]-num[m][4])+(num[m][2]-num[m][5])*(num[m][2]-num[m][5]));
m++;
}
}
for(k=1;k<=pair;k++){
for(i=0;i<pair-k;i++){
if(num[i][6]<num[i+1][6]){
for(t=0;t<7;t++){
e=num[i+1][t];
num[i+1][t]=num[i][t];
num[i][t]=e;
}
}
}
}
for(t=0;t<pair;t++){
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",(num[t][0]),(num[t][1]),(num[t][2]),(num[t][3]),(num[t][4]),(num[t][5]),(num[t][6]));
}
return 0;
}
|
64 | 31803 |
struct dist
{
int i;
int j;
float d;
}d[45];//??i?j?????
struct node
{
int x;
int y;
int z;
}a[10];//????????
void main()
{
int n,i,j,count=0;
struct dist temp;//????????
scanf("%d",&n);
for(i=0;i<45;i++) d[i].d=0.0;//????
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++)
{
d[count].i=i;
d[count].j=j;
d[count].d=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));
count++;
}//??i?j?????
count=n*(n-1)/2;
for(i=0;i<count-1;i++)
for(j=0;j<count-i-1;j++)
{
if(d[j].d<d[j+1].d)
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
}
}//????
for(i=0;i<count;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[d[i].i].x,a[d[i].i].y,a[d[i].i].z,a[d[i].j].x,a[d[i].j].y,a[d[i].j].z,d[i].d);
}
|
64 | 31804 | int main(){
int a[10][3];
int n;
int i,j,k;
double ans[100];
cin>>n;
for(i = 0;i<n;++i){
for(j = 0;j<3;++j){
cin>>a[i][j];
}
}
for(i = 0;i<n;++i){
for(j = i+1;j<n;++j){
ans[i*n+j] = sqrt(pow((double)a[i][0]-a[j][0],2)+pow((double)a[i][1]-a[j][1],2)+pow((double)a[i][2]-a[j][2],2));
//cout<<ans[i *n + j]<<" ";
}
//cout<<endl;
}
int sum = n*(n-1)/2;
while(sum >0){
--sum;
int max = 1;
for(i = 0;i<n;++i){
for(j = i+1;j<n;++j){
if(ans[i*n+j] > ans[max])max = i*n+j;
}
}
//(1,1,0)-(1,1,1)=1.00
cout<<"("<<a[max/n][0]<<","<<a[max/n][1]<<","<<a[max/n][2]<<")-("
<<a[max%n][0]<<","<<a[max%n][1]<<","<<a[max%n][2]<<")="
<<fixed<<setprecision(2)<<ans[max]<<endl;
ans[max] = -9999999;
}
cin>>i;
return 0;
}
|
64 | 31805 | float sqr(float x)
{
float ans;
ans=x*x;return(ans);
}
float work(float a[3],float b[3])
{
float ans;
ans=sqrt(sqr(a[0]-b[0])+sqr(a[1]-b[1])+sqr(a[2]-b[2]));
return(ans);
}
int main()
{
int n,i,j,x,num;
int a[101][3]={0};
float dis[101]={0},d[11][3],x1;
scanf("%d",&n);
for (i=0;i<n;i++)
for (j=0;j<3;j++)
scanf("%f",&d[i][j]);
num=0;
for (i=0;i<n;i++)
for (j=i+1;j<n;j++)
{dis[num]=work(d[i],d[j]);a[num][1]=i;a[num][2]=j;num++;}
for (i=0;i<num-1;i++)
for (j=0;j<num-1;j++)
if (dis[j]<dis[j+1])
{x1=dis[j];dis[j]=dis[j+1];dis[j+1]=x1;
x=a[j][1];a[j][1]=a[j+1][1];a[j+1][1]=x;
x=a[j][2];a[j][2]=a[j+1][2];a[j+1][2]=x;}
for (i=0;i<num;i++)
{x=a[i][1];j=a[i][2];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",(int)d[x][0],(int)d[x][1],(int)d[x][2],(int)d[j][0],(int)d[j][1],(int)d[j][2],dis[i]);}
}
|
64 | 31806 | typedef struct Point {
int x;
int y;
int z;
} Point; //??????????????????~~?????????
//??????????????
//???????????????????????????????????????????????????????????
//???????????
double Distance(Point *p1, Point *p2) {
int x = (p1->x) - (p2->x);
int y = (p1->y) - (p2->y);
int z = (p1->z) - (p2->z);
double temp = (double) (x * x + y * y + z * z);
return sqrt(temp);
}//???????
void Output(Point *p1, Point *p2) {
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n\n", p1->x, p1->y, p1->z, p2->x, p2->y,
p2->z, Distance(p1, p2));
}//???????
int main() {
int n, i, j;
scanf("%d", &n);
Point *p[n];
for (i = 0; i < n; i++) {
p[i] = (Point *) malloc(sizeof(Point));
scanf("%d", &p[i]->x);
scanf("%d", &p[i]->y);
scanf("%d", &p[i]->z);
}
double a[n * (n - 1) / 2];//??????
int k = 0;
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
int t = 0;
while (t < k + 1 && (a[t] - Distance(p[i], p[j]) > 0.00001
|| Distance(p[i], p[j]) - a[t] > 0.00001))
//?????double????????????????????????????
t++;
if (t == k + 1) {
a[k] = Distance(p[i], p[j]);
k++;
}
//Output(p[i],p[j]);
}
}//????????????????????
int count = k;//??????
for (i = 0; i < count; i++) {
for (j = i + 1; j < count; j++) {
if (a[i] < a[j]) {
double temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}//??a[]??
k = 0;
while (k < count) {//?????????????????????????
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if (a[k] > Distance(p[i], p[j])) {
if (a[k] - Distance(p[i], p[j]) < 0.000001)//a[k]==Distance(p[i],p[j])
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n\n", p[i]->x, p[i]->y, p[i]->z, p[j]->x, p[j]->y,
p[j]->z, Distance(p[i], p[j]));
} else {
if (Distance(p[i], p[j]) - a[k] < 0.000001)//a[k]==Distance(p[i],p[j])
Output(p[i], p[j]);
}//float???????????????????
}
}
k++;
}
}
|
64 | 31807 | int main()
{
int n,i,j,t,q,s;//n??????i,j??????t??????????q,s?????????????
cin>>n;//??n
t=n*(n-1)/2;//??t
int x[n+1],y[n+1],z[n+1],a[t+1],b[t+1];//???????a[n+1],b[n+1]??????????????
float dis[t+1],p;//???p?????
for(i=1;i<=n;i++)//?????????
{
cin>>x[i]>>y[i]>>z[i];
}
for(i=1;i<=n-1;i++)//???????????????????????
{
for(j=i+1;j<=n;j++)
{
dis[(2*n-i)*(i-1)/2+j-i]=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[(2*n-i)*(i-1)/2+j-i]=i;
b[(2*n-i)*(i-1)/2+j-i]=j;
}
}
for(j=1;j<=t;j++)//????
{
for(i=1;i<=t;i++)
{
if(dis[i]<dis[i+1])
{
p=dis[i];
dis[i]=dis[i+1];
dis[i+1]=p;
q=a[i];
a[i]=a[i+1];
a[i+1]=q;
s=b[i];
b[i]=b[i+1];
b[i+1]=s;
}
}
}
for(i=1;i<=t;i++)//????
{
cout<<"("<<x[a[i]]<<","<<y[a[i]]<<","<<z[a[i]]<<")-("<<x[b[i]]<<","<<y[b[i]]<<","<<z[b[i]]<<")="<<fixed<<setprecision(2)<<dis[i]<<endl;
}
return 0;
}
|
64 | 31808 | /*
* fuck.cpp
*
* Created on: 2011-12-16
* Author: guan hong wei
*/
struct locations//????,????
{
int x;
int y;
int z;
}locations[100];
struct distances//?????????
{
int i;
int j;
double distance;
}distances[100];
struct distances m;
int main()
{
int n,i,j,t=0;
cin>>n;//?????
for(i=0;i<n;i++)
{
cin>>locations[i].x>>locations[i].y>>locations[i].z;//??????
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
distances[t].i=i;
distances[t].j=j;
distances[t].distance=sqrt((double)(pow(locations[i].x-locations[j].x,2.0)+pow(locations[i].y-locations[j].y,2.0)+pow(locations[i].z-locations[j].z,2.0)));//????
t++;
}
}
for(i=0;i<t;i++)//???????????
{
for(j=t-1;j>i;j--)
{
if(distances[j].distance>distances[j-1].distance)
{
m=distances[j];
distances[j]=distances[j-1];
distances[j-1]=m;
}
}
}
for(i=0;i<t;i++)
{
cout<<'('<<locations[distances[i].i].x<<','<<locations[distances[i].i].y<<','<<locations[distances[i].i].z<<')'<<'-'<<'('<<locations[distances[i].j].x<<','<<locations[distances[i].j].y<<','<<locations[distances[i].j].z<<")="<<fixed<<setprecision(2)<<distances[i].distance<<endl;
}
return 0;
}
|
64 | 31809 | int main()
{
int i,j,k,l,n,m,a[10],b[10],c[10],z[50],x[50],v[50],s[50],d[50],f[50],q,w,r,t,o,u;
double y[50],jl[50],e;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
m=n*(n-1)/2;
k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
y[k]=1.0*((a[j]-a[i])*(a[j]-a[i])+(b[j]-b[i])*(b[j]-b[i])+(c[j]-c[i])*(c[j]-c[i]));
jl[k]=sqrt(y[k]);
z[k]=a[i];
x[k]=b[i];
v[k]=c[i];
s[k]=a[j];
d[k]=b[j];
f[k]=c[j];
k++;
}
}
for(l=1;l<=m;l++)
{
for(i=0;i<m-l;i++)
{
if(jl[i]<jl[i+1])
{
e=jl[i];
jl[i]=jl[i+1];
jl[i+1]=e;
q=z[i];
z[i]=z[i+1];
z[i+1]=q;
w=x[i];
x[i]=x[i+1];
x[i+1]=w;
r=v[i];
v[i]=v[i+1];
v[i+1]=r;
t=s[i];
s[i]=s[i+1];
s[i+1]=t;
o=d[i];
d[i]=d[i+1];
d[i+1]=o;
u=f[i];
f[i]=f[i+1];
f[i+1]=u;
}
}
}
for(i=0;i<m;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",z[i],x[i],v[i],s[i],d[i],f[i],jl[i]);
}
return 0;
} |
64 | 31810 | /**
* @file 1.cpp
* @author ???
* @date 2011-12?07
* @description
* ??????:????
*/
int main()
{
int n, d[101][3];
int i, j, k, m1, m2;
int (*p)[3];
p = d;
double l[10][10], max = 0;
cin >> n;
for (i = 0; i < n; i++)
{
cin >>*(*(p + i)) >> *(*(p + i) + 1) >> *(*(p + i) + 2); // ??i??????
}
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
l[i][j] = sqrt((double)(*(*(p + i)) - *(*(p + j))) * (*(*(p + i)) - *(*(p + j))) +
(*(*(p + i) + 1) - *(*(p + j) + 1)) * (*(*(p + i) + 1) - *(*(p + j) + 1)) +
(*(*(p + i) + 2) - *(*(p + j) + 2)) * (*(*(p + i) + 2) - *(*(p + j) + 2)));
} // ????????
}
for (k = 0; k < n * (n - 1) / 2; k++)
{
for (i = 0; i < n - 1; i++)
{
for (j = i + 1; j < n; j++)
{
if (l[i][j] > max)
{
max = l[i][j];
m1 = i;
m2 = j; // ?????????
}
}
}
cout << '(' << *(*(p + m1)) << ',' << *(*(p + m1) + 1) << ',' << *(*(p + m1) + 2) << ")-(";
cout << *(*(p + m2)) << ',' << *(*(p + m2) + 1) << ',' << *(*(p + m2) + 2) << ')' << '=' ;
cout << fixed << setprecision(2) << l[m1][m2] << endl;
l[m1][m2] = 0; // ??????????????????????
max = 0;
}
return 0;
} |
64 | 31811 | int main()
{
int M;
M=N*(N-1)/2;
int x[N],y[N],z[N],d[M],a[M],b[M],p=0,i,j,n,k,m;
double c;
scanf("%d",&n);
printf("\n");
for(i=0;i<n;i++)
scanf("%d%d%d",&x[i],&y[i],&z[i]);
printf("\n");
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
d[p]=(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[p]=i;
b[p]=j;
p++;
}
for(j=1;j<=p;j++)
for(i=0;i<p-j;i++)
if(d[i]<d[i+1])
{
d[i]=d[i]+d[i+1];
d[i+1]=d[i]-d[i+1];
d[i]=d[i]-d[i+1];
a[i]=a[i]+a[i+1];
a[i+1]=a[i]-a[i+1];
a[i]=a[i]-a[i+1];
b[i]=b[i]+b[i+1];
b[i+1]=b[i]-b[i+1];
b[i]=b[i]-b[i+1];
}
for(i=0;i<p;i++)
{
k=a[i];
m=b[i];
c=sqrt(d[i]);
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[k],y[k],z[k],x[m],y[m],z[m],c);
}
return 0;
}
|
64 | 31812 | typedef struct Point
{
int x;
int y;
int z;
}Point;
double Distance(Point *p1,Point *p2)
{
int x=(p1->x)-(p2->x);
int y=(p1->y)-(p2->y);
int z=(p1->z)-(p2->z);
double temp=(double)(x*x+y*y+z*z);
return sqrt(temp);
}
void Input(Point *p[],int n)
{
int i;
for(i=0;i<n;i++)
{
p[i]=(Point *)malloc(sizeof(Point));
scanf("%d",&p[i]->x);
scanf("%d",&p[i]->y);
scanf("%d",&p[i]->z);
}
}
void Output(Point *p1,Point *p2)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n\n",p1->x,p1->y,p1->z,p2->x,p2->y,p2->z,Distance(p1,p2));
}
int main()
{
int n,i,j;
scanf("%d",&n);
Point *p[10];
Input(p,n);
double a[10*(10-1)/2];
int k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{ int t=0;
while(t<k+1 &&(a[t]-Distance(p[i],p[j])>0.00001 ||Distance(p[i],p[j])-a[t]>0.00001)) t++;
if(t==k+1){ a[k]=Distance(p[i],p[j]); k++; }
}
}
int count=k;
for(i=0;i<count;i++)
{
for(j=i+1;j<count;j++)
{
if(a[i]<a[j])
{ double temp=a[i]; a[i]=a[j]; a[j]=temp; }
}
}
k=0;
while(k<count)
{
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{ if(a[k]>Distance(p[i],p[j]))
{ if(a[k]-Distance(p[i],p[j])<0.000001)
Output(p[i],p[j]);
}
else
{
if(Distance(p[i],p[j])-a[k]<0.000001)
Output(p[i],p[j]);
}
}
}
k++;
}
} |
64 | 31813 | struct
{
int x,y,z;
}a[12];
struct
{
int x1,x2,y1,y2,z1,z2;
double l;
}dis[120],t;
void sort(int a)
{
for (int i=0; i<a; i++)
for (int j=0; j<a-1-i; j++)
{
if (dis[j].l < dis[j+1].l)
{
t= dis[j];
dis[j] = dis[j+1];
dis[j+1] = t;
}
}
for (int i=0; i<a; i++)
{
cout << "(" << dis[i].x1 << "," << dis[i].y1 << "," << dis[i].z1
<< ")-(" << dis[i].x2 << "," << dis[i].y2 << "," << dis[i].z2 <<
")=" << fixed << setprecision(2) << dis[i].l <<endl;
}
}
int main()
{
int n;
cin >> n;
for (int i=0; i<n; i++)
{
cin >> a[i].x >> a[i].y >> a[i].z ;
}
int count = 0;
for (int i=0; i<n; i++)
{
for (int j=i+1; j<n; j++)
{
dis[count].l = 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));
dis[count].x1 = a[i].x;
dis[count].x2 = a[j].x;
dis[count].y1 = a[i].y;
dis[count].y2 = a[j].y;
dis[count].z1 = a[i].z;
dis[count].z2 = a[j].z;
count++;
}
}
sort (count);
cin >> n;
return 0;
}
|
64 | 31814 | void main()
{
int i,j,k,b,c,n;
double s[100][100],max,a[100][3];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%lf %lf %lf",&a[i][0],&a[i][1],&a[i][2]);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
s[i][j]=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])));
for(k=0;k<(n*(n-1)/2);k++)
{
max=0;
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
if(s[i][j]>max)
{
max=s[i][j];
b=i;
c=j;
}
}
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",a[b][0],a[b][1],a[b][2],a[c][0],a[c][1],a[c][2],max);
s[b][c]=0;
}
} |
64 | 31815 | int main(){
int n,i,s,j,b;
b=0;
int x[11],y[11],z[11],a[46],c[46];
double d[46];
double t,f;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d %d %d",&x[i],&y[i],&z[i]);
}
s=n*(n-1)/2;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
f=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
t=sqrt(f);
d[b]=t;
a[b]=i;
c[b]=j;
b++;
}
}
for(int k=1;k<=s;k++){
for(b=0;b<s-k;b++){
if(d[b]>d[b+1]){
double e=d[b+1];
d[b+1]=d[b];
d[b]=e;
int g=a[b+1];
a[b+1]=a[b];
a[b]=g;
int u=c[b+1];
c[b+1]=c[b];
c[b]=u;
}else{
if(d[b]==d[b+1]){
if(a[b]<a[b+1]){
double o=d[b+1];
d[b+1]=d[b];
d[b]=o;
int p=a[b+1];
a[b+1]=a[b];
a[b]=p;
int q=c[b+1];
c[b+1]=c[b];
c[b]=q;
}else{
if(a[b]==a[b+1]){
if(c[b]<c[b+1]){
double o=d[b+1];
d[b+1]=d[b];
d[b]=o;
int p=a[b+1];
a[b+1]=a[b];
a[b]=p;
int q=c[b+1];
c[b+1]=c[b];
c[b]=q;
}
}
}
}
}
}
}
for(b=s-1;b>=0;b--){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[(a[b])],y[(a[b])],z[(a[b])],x[(c[b])],y[(c[b])],z[(c[b])],d[b]);
}
return 0;
}
|
64 | 31816 | int main ()
{
int a[10][3] = {0}; //????????
int n = 0; //??n??????
cin >> n;
int i = 0, j = 0, k = 0; //????????
for ( i = 0; i < n; i ++ ) //??????
for ( j = 0; j < 3; j ++ )
cin >> a[i][j];
double distance[100] = {0}; //???????????
double dis = 0; //?????
for ( i = 0; i < n; i ++ ) //??????
for ( j = i + 1; j < n; j ++ )
{
for ( k = 0; k < 3; k ++ )
dis = dis + (a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
distance[i*10+j] = sqrt(dis);
dis = 0;
}
int b[100] = {0}; //????????????
for ( i = 0; i < 100; i ++ )
b[i] = i;
for ( i = 0; i < 99; i ++ ) //?????
for ( j = 0; j < 99 - i; j ++ )
{
if ( distance[j] < distance[j+1] )
{
swap ( distance[j], distance[j+1] );
swap ( b[j], b[j+1] );
}
}
for ( i = 0; i < n*(n-1)/2; i ++ ) //????????????
{
cout << "(" << a[b[i]/10][0] << "," << a[b[i]/10][1] << "," << a[b[i]/10][2] << ")-(";
cout << a[b[i]%10][0] << "," << a[b[i]%10][1] << "," << a[b[i]%10][2] << ")=";
printf ( "%.2f", distance[i] );
cout << endl;
}
return 0;
} |
64 | 31817 |
int main(){
int n,x[10],y[10],z[10],xx1[50],yy1[50],zz1[50],xx2[50],yy2[50],zz2[50],i,t,k=0,e;
double j[10][10],jj[50],f;
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(t=0;t<n;t++){
j[i][t]=sqrt((x[i]-x[t])*(x[i]-x[t])+(y[i]-y[t])*(y[i]-y[t])+(z[i]-z[t])*(z[i]-z[t]));
}
}
for(i=0;i<n;i++){
for(t=i+1;t<n;t++){
jj[k]=j[i][t];
xx1[k]=x[i];
xx2[k]=x[t];
yy1[k]=y[i];
yy2[k]=y[t];
zz1[k]=z[i];
zz2[k]=z[t];
k++;
}
}
for(i=1;i<=k+1;i++){
for(t=0;t<k-1;t++){
if(jj[t]<jj[t+1]){
f=jj[t+1];
jj[t+1]=jj[t];
jj[t]=f;
e=xx1[t+1];
xx1[t+1]=xx1[t];
xx1[t]=e;
e=yy1[t+1];
yy1[t+1]=yy1[t];
yy1[t]=e;
e=zz1[t+1];
zz1[t+1]=zz1[t];
zz1[t]=e;
e=xx2[t+1];
xx2[t+1]=xx2[t];
xx2[t]=e;
e=yy2[t+1];
yy2[t+1]=yy2[t];
yy2[t]=e;
e=zz2[t+1];
zz2[t+1]=zz2[t];
zz2[t]=e;
}
}
}
for(i=0;i<k;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",xx1[i],yy1[i],zz1[i],xx2[i],yy2[i],zz2[i],jj[i]);
}
return 0;
} |
64 | 31818 | int main()
{
int n;
float distance[150];
int k=1;
int i=1,j=1,t=1;
double temp;
struct point
{
int x,y,z;
}
stu1[12];
struct ttt
{
int x1,y1,z1;
int x2,y2,z2;
}
stu2[150];
scanf("%d",&n);
for(i=1;i<=n;i++)
scanf("%d %d %d",&stu1[i].x,&stu1[i].y,&stu1[i].z);
for(i=1;i<=n-1;i++)
{
for(j=i+1;j<=n;j++)
{
distance[k]=(float)sqrt((stu1[i].x-stu1[j].x)*(stu1[i].x-stu1[j].x)+(stu1[i].y-stu1[j].y)*(stu1[i].y-stu1[j].y)
+(stu1[i].z-stu1[j].z)*(stu1[i].z-stu1[j].z));
stu2[k].x1=stu1[i].x;
stu2[k].y1=stu1[i].y;
stu2[k].z1=stu1[i].z;
stu2[k].x2=stu1[j].x;
stu2[k].y2=stu1[j].y;
stu2[k].z2=stu1[j].z;
k++;//k=0--k=n-1*n-2/2
}
}
t=k-1;//eg:n=4 k=7 t=6
for(j=0;j<=t-1;j++)//????
{
for(i=1;i<=t-j;i++)
{
if(distance[i]<distance[i+1])
{
temp=distance[i];
distance[i]=distance[i+1];
distance[i+1]=temp;
temp=stu2[i].x1;
stu2[i].x1=stu2[i+1].x1;
stu2[i+1].x1=temp;
temp=stu2[i].y1;
stu2[i].y1=stu2[i+1].y1;
stu2[i+1].y1=temp;
temp=stu2[i].z1;
stu2[i].z1=stu2[i+1].z1;
stu2[i+1].z1=temp;
temp=stu2[i].x2;
stu2[i].x2=stu2[i+1].x2;
stu2[i+1].x2=temp;
temp=stu2[i].y2;
stu2[i].y2=stu2[i+1].y2;
stu2[i+1].y2=temp;
temp=stu2[i].z2;
stu2[i].z2=stu2[i+1].z2;
stu2[i+1].z2=temp;
}
}
}
for(k=1;k<=t;k++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",stu2[k].x1,stu2[k].y1,stu2[k].z1,stu2[k].x2,stu2[k].y2,stu2[k].z2,distance[k]);
return 0;
}
|
64 | 31819 | struct point{
int x;
int y;
int z;
};
struct diskumi{
struct point po1;
struct point po2;
double dist;
};
int main()
{
int n;
int xa[15],ya[15],za[15];
struct diskumi dis[45];
int baka;
double cir;
int i,j,k=0;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&xa[i],&ya[i],&za[i]);
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
dis[k].po1.x=xa[i];
dis[k].po1.y=ya[i];
dis[k].po1.z=za[i];
dis[k].po2.x=xa[j];
dis[k].po2.y=ya[j];
dis[k].po2.z=za[j];
dis[k].dist=sqrt((xa[i]-xa[j])*(xa[i]-xa[j])+(ya[i]-ya[j])*(ya[i]-ya[j])+(za[i]-za[j])*(za[i]-za[j]));
k++;
}
}
for(i=0;i<k-1;i++)
{
for(j=0;j<k-i-1;j++)
{
if(dis[j+1].dist>dis[j].dist)
{
baka=dis[j].po1.x;
dis[j].po1.x=dis[j+1].po1.x;
dis[j+1].po1.x=baka;
baka=dis[j].po1.y;
dis[j].po1.y=dis[j+1].po1.y;
dis[j+1].po1.y=baka;
baka=dis[j].po1.z;
dis[j].po1.z=dis[j+1].po1.z;
dis[j+1].po1.z=baka;
baka=dis[j].po2.x;
dis[j].po2.x=dis[j+1].po2.x;
dis[j+1].po2.x=baka;
baka=dis[j].po2.y;
dis[j].po2.y=dis[j+1].po2.y;
dis[j+1].po2.y=baka;
baka=dis[j].po2.z;
dis[j].po2.z=dis[j+1].po2.z;
dis[j+1].po2.z=baka;
cir=dis[j].dist;
dis[j].dist=dis[j+1].dist;
dis[j+1].dist=cir;
}
}
}
k--;
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf",dis[0].po1.x,dis[0].po1.y,dis[0].po1.z,dis[0].po2.x,dis[0].po2.y,dis[0].po2.z,dis[0].dist);
for(i=1;i<=k;i++)
{
printf("\n(%d,%d,%d)-(%d,%d,%d)=%.2lf",dis[i].po1.x,dis[i].po1.y,dis[i].po1.z,dis[i].po2.x,dis[i].po2.y,dis[i].po2.z,dis[i].dist);
}
} |
64 | 31820 | int main(){
int n,a,m,js=0,p=0,q,e;
scanf("%d\n",&n);
int x[n-1],y[n-1],z[n-1];
double jg[100],o;
for(int i=0;i<100;i++){
jg[i]=-1;
}
for(int i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
for(int i=0;i<n-1;i++){
for(int k=i+1;k<n;k++){
a=10*i+k;
jg[a]=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]));
}
}
o=0;
m=n*(n-1)/2;
for(int i=0;i<100;i++){
if(js==m){
break;
}
if(o<jg[i]){
o=jg[i];
p=i;
}
if(i==99){
q=p/10;
n=p-q*10;
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[q],y[q],z[q],x[n],y[n],z[n],o);
jg[p]=-1;
i=-1;
o=0;
js++;
}
}
return 0;
}
|
64 | 31821 | int main()
{
float point[10][3],distant[45],t;
int n,i,j,k=0,p,d[45][2];
cin>>n;
for(i=0;i<n;i++)
for(j=0;j<3;j++)
cin>>point[i][j]; //i???????j?????????
for(i=0;i<n;i++)
for(j=i+1;j<n;j++,k++){//distant????????????d??????????????
distant[k]=sqrt(pow((point[i][0]-point[j][0]),2)+pow((point[i][1]-point[j][1]),2)+pow((point[i][2]-point[j][2]),2));
d[k][0]=i;d[k][1]=j;}
for(i=1;i<n*(n-1)/2;i++) //?????????distance????
for(j=0;j<n*(n-1)/2-i;j++)
if(distant[j]<distant[j+1]){
t=distant[j];
distant[j]=distant[j+1];
distant[j+1]=t;
p=d[j][0];
d[j][0]=d[j+1][0];
d[j+1][0]=p;
p=d[j][1];
d[j][1]=d[j+1][1];
d[j+1][1]=p;}
for(k=0;k<(n*(n-1)/2);k++)//????
cout<<'('<<fixed<<setprecision(0)<<point[d[k][0]][0]<<','<<point[d[k][0]][1]<<','<<
point[d[k][0]][2]<<')'<<'-'<<'('<<point[d[k][1]][0]<<','<<
point[d[k][1]][1]<<','<<point[d[k][1]][2]<<')'<<'='<<fixed<<setprecision(2)<<distant[k]<<endl;
return 0;
} |
64 | 31822 |
typedef struct Point
{
int x,y,z;
}Point;
typedef struct Distance
{
double len;
int pt1,pt2;
}Distance;
double CalDis(Point pt1,Point pt2)
{
return sqrt((double)(pt1.x-pt2.x)*(pt1.x-pt2.x)+(pt1.y-pt2.y)*(pt1.y-pt2.y)+(pt1.z-pt2.z)*(pt1.z-pt2.z));
}
int cmp( const void *a ,const void *b)
{
if((*(Distance *)b).len != (*(Distance *)a).len)
return (*(Distance *)b).len > (*(Distance *)a).len ? 1 : -1;
else
return (*(Distance *)a).pt1 > (*(Distance *)b).pt1 ? 1 : -1;
}
Distance ds[N];
int main()
{
int n,count=0,i,j;
Point pts[11];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&pts[i].x,&pts[i].y,&pts[i].z);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
ds[count].len=CalDis(pts[i],pts[j]);
ds[count].pt1=i;
ds[count++].pt2=j;
}
qsort(ds,count,sizeof(ds[0]),cmp);
for(i=0;i<count;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",pts[ds[i].pt1].x,pts[ds[i].pt1].y,
pts[ds[i].pt1].z,pts[ds[i].pt2].x,pts[ds[i].pt2].y,pts[ds[i].pt2].z,ds[i].len);
return 0;
} |
64 | 31823 | int main()
{
int n,i,j,k,r,c;
float a[10][3],b[11][11],sum,max;
cin>>n;
for(i=0;i<n;i++)
{
for(j=0;j<3;j++)
cin>>a[i][j];
}
for(i=0;i<n-1;i++)
{
for(k=i+1;k<n;k++)
{
sum=0;
for(j=0;j<3;j++)
{
sum=sum+(a[i][j]-a[k][j])*(a[i][j]-a[k][j]);
}
b[i][k]=sqrt(sum);
}
}
for(j=0;j<(n-1)*n/2;j++)
{
max=0;
for(i=0;i<n-1;i++)
{
for(k=i+1;k<n;k++)
{
if(b[i][k]>max)
{
max=b[i][k];
r=i;
c=k;
}
}
}
b[r][c]=0;
cout<<'('<<a[r][0]<<','<<a[r][1]<<','<<a[r][2]<<')'<<'-'<<'('<<a[c][0]<<','<<a[c][1]<<','<<a[c][2]<<')'<<'=';
printf("%.2f\n",max);
}
return 0;
} |
64 | 31824 | double cal(int a[3],int b[3])
{
int i=0,sum=0;
for(;i<3;i++)
sum+=(a[i]-b[i])*(a[i]-b[i]);
return sqrt(sum);
}
int change(double a[7],double b[7])
{
double temp;
int i;
for(i=0;i<7;i++)
{
temp=a[i];
a[i]=b[i];
b[i]=temp;
}
return 0;
}
void main()
{
int i,j,n,a[10][3],k1=0,k2;
double b[60][7];
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++)
{
for(k2=0;k2<3;k2++)
b[k1][k2]=a[i][k2];
for(k2=0;k2<3;k2++)
b[k1][k2+3]=a[j][k2];
b[k1][6]=cal(a[i],a[j]);
k1++;
}
for(i=0;i<k1;i++)
for(j=0;j<k1-1;j++)
if(b[j][6]<b[j+1][6])
change(b[j],b[j+1]);
for(i=0;i<k1;i++)
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",b[i][0],b[i][1],b[i][2],b[i][3],b[i][4],b[i][5],b[i][6]);
} |
64 | 31825 | int main(){
int n,i,j,k=0,p,q;
double t;
scanf("%d",&n);
double x[200];
double y[200];
double z[200];
double jl[200][200];
double jljl[200];
double dhi[200];
double dhj[200];
for(i=0;i<n;i++){
scanf("%lf",&(x[i]));
scanf("%lf",&(y[i]));
scanf("%lf",&(z[i]));
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
jl[i][j]=sqrt(((x[j])-(x[i]))*((x[j])-(x[i]))+((y[j])-(y[i]))*((y[j])-(y[i]))+((z[j])-(z[i]))*((z[j])-(z[i])));
jljl[k]=jl[i][j];
dhi[k]=i;
dhj[k]=j;
k++;
}
}
for(i=0;i<n*(n-1)/2;i++){
for(j=n*(n-1)/2-1;j>i;j--){
if(jljl[j]>jljl[j-1]){
t=jljl[j];
jljl[j]=jljl[j-1];
jljl[j-1]=t;
t=dhi[j];
dhi[j]=dhi[j-1];
dhi[j-1]=t;
t=dhj[j];
dhj[j]=dhj[j-1];
dhj[j-1]=t;
}
}
}
k=0;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
jl[i][j]=jljl[k];
p=(int)dhi[k];
q=(int)dhj[k];
k++;
printf("(%.0lf,%.0lf,%.0lf)-(%.0lf,%.0lf,%.0lf)=%.2lf\n",x[p],y[p],z[p],x[q],y[q],z[q],jl[i][j]);
}
}
return 0;
}
|
64 | 31826 | int main()
{
int n;
int i,j,k=0;
struct point
{
int x;
int y;
int z;
}p[10];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
}
struct distant
{
struct point p1,p2;
double r;
}d[45],t;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++,k++)
{
d[k].p1=p[i];
d[k].p2=p[j];
d[k].r=sqrt(1.0*((d[k].p1.x-d[k].p2.x)*(d[k].p1.x-d[k].p2.x)+(d[k].p1.y-d[k].p2.y)*(d[k].p1.y-d[k].p2.y)+(d[k].p1.z-d[k].p2.z)*(d[k].p1.z-d[k].p2.z)));
if(k>n*(n-1)/2)
break;
}
if(k>n*(n-1)/2)
break;
}
for(i=k-1;i>0;i--)
{
for(j=0;j<i;j++)
{
if(d[j].r<d[j+1].r)
{
t=d[j];
d[j]=d[j+1];
d[j+1]=t;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\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].r);
}
return 0;
}
|
64 | 31827 | int main(){
int i,j,m=0,n,x[10],y[10],z[10],a,b,c,e,f,g,x1[55],y1[55],z1[55],x2[55],y2[55],z2[55];
double jl[55],d;
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++){
jl[m]=sqrt(pow(x[i]-x[j],2)+pow(y[i]-y[j],2)+pow(z[i]-z[j],2));
x1[m]=x[i];x2[m]=x[j];y1[m]=y[i];y2[m]=y[j];z1[m]=z[i];z2[m]=z[j];
m++;
}
}
for(j=0;j<m-1;j++){
for(i=0;i<m-j-1;i++){
if(jl[i]<jl[i+1]){
d=jl[i+1];jl[i+1]=jl[i];jl[i]=d;
a=x1[i+1];x1[i+1]=x1[i];x1[i]=a;
b=x2[i+1];x2[i+1]=x2[i];x2[i]=b;
c=y1[i+1];y1[i+1]=y1[i];y1[i]=c;
e=y2[i+1];y2[i+1]=y2[i];y2[i]=e;
f=z1[i+1];z1[i+1]=z1[i];z1[i]=f;
g=z2[i+1];z2[i+1]=z2[i];z2[i]=g;
}
}
}
for(i=0;i<m;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x1[i],y1[i],z1[i],x2[i],y2[i],z2[i],jl[i]);
}
return 0;
}
|
64 | 31828 | int main()
{
int n,i,j,m=0,k,s,t;
cin >> n;
double d[101][101];
struct point
{
int x;
int y;
int z;
}p[11];
for (i=0;i<=n-1;i++)
{
cin >> p[i].x >> p[i].y >> p[i].z;
}
for (i=0;i<n;i++)
{
for (j=i+1;j<n;j++)
{
d[i][j]=sqrt((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));
}
}
for (t=0;t<(n*(n+1))/2;t++)
{
for (i=0;i<n;i++)
{
for (j=i+1;j<n;j++)
{
m=0;
for (k=0;k<n;k++)
{
for (s=k+1;s<=n;s++)
{
if (d[i][j]<d[k][s])
m++;
}
}
if (m==t)
{
cout<< "(" << p[i].x << "," << p[i].y << "," << p[i].z << ")"<< "-" <<"(" << p[j].x << "," << p[j].y << "," << p[j].z << ")"<< "=" << fixed << setprecision (2) << d[i][j] << endl;
}
}
}
}
return 0;
}
|
64 | 31829 | struct distants
{double d;
int x;
int y;
}b[45],mid;
int main()
{int n,i,j,num=0;
int a[10][3];
struct distants b[45],mid;
scanf("%d",&n);
if(n<=10){
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[num].d=sqrt((double)((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])));
b[num].x=i;
b[num].y=j;
num++;
}
}//????num????b[num-1].d
for(i=1;i<num;i++)
{
for(j=1;j<=num-i;j++)
{
if((b[j-1].d<b[j].d)||((b[j-1].d-b[j].d<1e-6)&&(b[j-1].x>b[j].x))||((b[j-1].d-b[j].d<1e-6)&&(b[j-1].x==b[j].x)&&(b[j-1].y>b[j].y)))
{
mid=b[j-1];
b[j-1]=b[j];
b[j]=mid;
}
}
}
for(i=0;i<num;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[b[i].x][0],a[b[i].x][1],a[b[i].x][2],a[b[i].y][0],a[b[i].y][1],a[b[i].y][2],b[i].d);
}
}
return 0;
}
|
64 | 31830 | int main()
{
int n;
double x[11], y[11], z[11], s[11][11];
cin >> n;
for(int i = 1; i <= n; i++)
cin >> x[i] >> y[i] >> z[i];
for(int i = 1; i <= n; i++)
{
for(int j = i + 1; j <= n; j++)
{
s[i][j] = (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[i][j] = sqrt(s[i][j]);
}
}
for(int k = 1; k <= n * (n-1) / 2; k++)
{
double max = 0;
int t1 = 0, t2 = 0;
for(int i = 1; i <= n; i++)
{
for(int j = i + 1; j <= n; j++)
{
if(s[i][j] > max )
{
// cout << i<<" "<<j<<" : "<<s[i][j] << " & "<<max <<endl;
max = s[i][j];
t1 = i;
t2 = j;
}
}
}
cout << "(" << x[t1] << "," << y[t1] << "," << z[t1] << ")-(" << x[t2] << "," << y[t2] << "," << z[t2] << ")=" ;
printf( "%.2lf\n", s[t1][t2]);
s[t1][t2] = 0;
}
return 0;
} |
64 | 31831 | int main(){
int x[10],y[10],z[10],n,num=0;//????x,y,z?num?????
double a[10][10],b[45];//???????????????????????????????????????
cin>>n;
for(int i=0;i<n;i++){
cin>>x[i]>>y[i]>>z[i];
}//????????
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
a[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]));
b[num]=a[i][j];
num++;
}//?????????????????????
}
double p;
for(int i=0;i<num-1;i++){
for(int j=0;j<num-1-i;j++){
if(b[j]<b[j+1]){
p=b[j];
b[j]=b[j+1];
b[j+1]=p;
}
}
}//?????????????
for(int k=0;k<num;k++){
if(b[k]==b[k+1])continue;//??????????????????
else {
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(a[i][j]==b[k]){//?????????????????
cout<<"("<<x[i]<<","<<y[i]<<","<<z[i]<<")"<<"-"<<"("<<x[j]<<","<<y[j]<<","<<z[j]<<")=";
printf("%.2lf",b[k]);//??????
cout<<'\n';
}
}
}
}
}
return 0;
}
|
64 | 31832 | //**************************
//*?????(14-4) ???? **
//*?????? 1200012888 **
//*???2013.12.11**
//**************************
struct //????????? Point ?? x y z ??
{
int x;
int y;
int z;
}Point[10]; //????? Point
struct dis //????????? dis ?? ????d???????Point????????
{
int pos_1;
int pos_2;
double d;
}Dis[45];
int main()
{
int n;
cin >> n;
for (int i = 0 ; i < n ; i++) //??n?????
{
cin >> Point[i].x >> Point[i].y >> Point[i].z;
}
int count = 0; //count????
for (int i = 0 ; i < n ; i ++)
{
for (int j = i + 1 ; j < n ; j ++)
{
Dis[count].d = sqrt(1.0*(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[count].pos_1 = i; //?????????
Dis[count].pos_2 = j;
count ++;
}
}
for (int i = 0 ; i < count - 1 ; i ++) //?????
{
for (int j = 0 ; j < count - i - 1; j++)
{
if (Dis[j].d < Dis[j + 1].d)
{
struct dis temp;
temp = Dis[j];
Dis[j] = Dis[j + 1];
Dis[j + 1] = temp;
}
}
}
for (int i = 0 ; i < count ; i ++) //????????
{
cout << '(' << Point[Dis[i].pos_1].x << ','<< Point[Dis[i].pos_1].y << ','<< Point[Dis[i].pos_1].z << ')' << '-' << '(' << Point[Dis[i].pos_2].x << ','<< Point[Dis[i].pos_2].y << ','<< Point[Dis[i].pos_2].z << ')' << '=';
cout << fixed << setprecision(2) << Dis[i].d << endl;
}
return 0;
} |
64 | 31833 | int main()
{
int n,i,j,k;
int x[10],y[10],z[10];
double t;
double d[45];
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++)
d[(j-i)+(n-1+n-i)*i/2-1]=sqrt((double)((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(i=0;i<n*(n-1)/2-1;i++)
{
for(j=i+1;j<n*(n-1)/2;j++)
{
if(d[i]<d[j])
{t=d[i];d[i]=d[j];d[j]=t;
}
}
}
for(k=0;k<n*(n-1)/2;k++)
{
if(d[k]!=d[k+1])
{
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
if(sqrt((double)((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j])))-d[k]==0)
{cout<<"("<<x[i]<<","<<y[i]<<","<<z[i]<<")-("<<x[j]<<","<<y[j]<<","<<z[j]<<")=";
cout<<(fixed)<<setprecision(2)<<d[k]<<'\n';
}
}
}
}
}
return 0;
}
|
64 | 31834 | int main()
{
int n,i,j=0,k,r,g,o,l;
int x[100],y[100],z[100];
int q[100],w[100];
double s[450],e;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d%d%d",&x[i],&y[i],&z[i]);
}
for(k=0;k<n-1;k++){
for(i=k+1;i<n;i++){
s[j]=1.0*pow((x[k]-x[i]),2)+pow((y[k]-y[i]),2)+pow((z[k]-z[i]),2);
s[j]=sqrt(s[j]);
q[j]=k;
w[j]=i;
j++;
}
}
for(g=1;g<=j;g++){
for(r=0;r<j-g;r++){
if(s[r]<s[r+1]){
e=s[r+1];
s[r+1]=s[r];
s[r]=e;
o=q[r+1];
q[r+1]=q[r];
q[r]=o;
l=w[r+1];
w[r+1]=w[r];
w[r]=l;
}
}
}
for(r=0;r<=j-1;r++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[q[r]],y[q[r]],z[q[r]],x[w[r]],y[w[r]],z[w[r]],s[r]);
}
return 0;
} |
64 | 31835 | int main(){
int i,a[1000][3],n,e,j,k=0,h;
double m[3000][3],r,p,q;
scanf("%d",&n);
h=n*(n-1)/2;
for(i=0;i<n;i++)
{
scanf("%d%d%d",&a[i][0],&a[i][1],&a[i][2]);
}
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
m[k][0]=i;
m[k][1]=j;
m[k][2]=sqrt((double) ((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<h;i++)
{
for(k=0;k<h-1-i;k++)
{
if(m[k][2]<m[k+1][2])
{
r=m[k][0];
m[k][0]=m[k+1][0];
m[k+1][0]=r;
p=m[k][1];
m[k][1]=m[k+1][1];
m[k+1][1]=p;
q=m[k][2];
m[k][2]=m[k+1][2];
m[k+1][2]=q;
}
}
}
for(i=0;i<h;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[(int)m[i][0]][0],a[(int)m[i][0]][1],a[(int)m[i][0]][2],a[(int)m[i][1]][0],a[(int)m[i][1]][1],a[(int)m[i][1]][2],m[i][2]);
return 0;
}
|
64 | 31836 |
int main()
{
int spot[100][3],n,i,j,k=0;
struct D
{
int s[2][3];
double d;
} D[1000],tem;
scanf("%d",&n);
for (i=0;i<n;i++)
scanf("%d%d%d",&spot[i][0],&spot[i][1],&spot[i][2]);
for (i=0;i<n-1;i++)
{
for (j=i+1;j<n;j++)
{
D[k].s[0][0]=spot[i][0];
D[k].s[0][1]=spot[i][1];
D[k].s[0][2]=spot[i][2];
D[k].s[1][0]=spot[j][0];
D[k].s[1][1]=spot[j][1];
D[k].s[1][2]=spot[j][2];
D[k].d=(double)sqrt((spot[i][0]-spot[j][0])*(spot[i][0]-spot[j][0])+(spot[i][1]-spot[j][1])*(spot[i][1]-spot[j][1])+(spot[i][2]-spot[j][2])*(spot[i][2]-spot[j][2]));
k++;
}
}
for(i=0;i<k;i++)
for(j=k-1;j>i;j--)
{
if (D[j].d>D[j-1].d)
{
tem=D[j];
D[j]=D[j-1];
D[j-1]=tem;
}
}
for (i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",D[i].s[0][0],D[i].s[0][1],D[i].s[0][2],D[i].s[1][0],D[i].s[1][1],D[i].s[1][2],D[i].d);
} |
64 | 31837 | //******************************************************
//* ? ? ? ?? ? ? ? *
//* ? ? ?? ? ? *
//* ? ? ? ??2010 ? 12 ? 15 ? *
//* ? ? ?1000010185 *
//******************************************************
int main()
{
struct distance // ???????????????
{
int x[3];
int y[3];
double d;
} dis[45], temp;
int n, a[10][3]; // ??a???n????
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < 3; j++)
cin >> a[i][j];
// ?n?????????????dis?
int k = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
{
for (int p = 0; p < 3; p++)
{
dis[k].x[p] = a[i][p];
dis[k].y[p] = a[j][p];
}
k++;
}
// ??????????
int k1 = n * (n - 1) / 2;
for (int i = 0; i < k1; i++)
{
double sum = 0;
for (int j = 0; j < 3; j++)
sum += (dis[i].x[j] - dis[i].y[j]) * (dis[i].x[j] - dis[i].y[j]);
dis[i].d = sqrt(sum);
for (int j = i - 1; j >= 0; j--)
if (dis[j + 1].d > dis[j].d)
{
temp = dis[j];
dis[j] = dis[j + 1];
dis[j + 1] = temp;
}
}
// ???????????
for (int i = 0; i < k1; i++)
cout << '(' << dis[i].x[0] << ',' << dis[i].x[1] << ',' << dis[i].x[2] << ")-(" << dis[i].y[0]
<< ',' << dis[i].y[1] << ',' << dis[i].y[2] << ")=" << fixed << setprecision(2) << dis[i].d << endl;
return 0;
} |
64 | 31838 | int main()
{
int n, i, j, k = 0;
cin >> n;
int num = n * (n - 1) / 2;
int a[10][3];
for ( i = 0; i < n; i++)
for ( j = 0; j < 3; j++)
cin >> a[i][j];
double b[10][10];
double c[45];
for ( i = 0; i < n - 1; i++)
for ( j = i + 1; j < n; j++)
{
double len1, len2, len3;
len1 = pow(a[i][0] - a[j][0], 2.0);
len2 = pow(a[i][1] - a[j][1], 2.0);
len3 = pow(a[i][2] - a[j][2], 2.0);
b[i][j] = sqrt(len1 + len2 + len3);
c[k++] = b[i][j];
}
double temp;
for(i = 0; i < num - 1; i++)
for (j = 0; j < num - 1 - i; j++)
{
if ((c[j] < c[j + 1]) )
{
temp = c[j];
c[j] = c[j + 1];
c[j + 1] = temp;
}
}
for (k = 0; k < num; k++)
{
if (k == 0)
{
for ( i = 0; i < n; i++)
for ( j = i + 1; j < n; j++)
if (fabs(b[i][j] - c[k]) < 1e-9)
{
cout << fixed;
cout << "(" << a[i][0] << "," << a[i][1] << "," << a[i][2] << ")" << "-";
cout << "(" << a[j][0] << "," << a[j][1] << "," << a[j][2] << ")";
cout << "=" << setprecision(2) << b[i][j] << endl;
}
}
else
{
while (fabs(c[k] - c[k - 1]) < 1e-9)
k++;
for ( i = 0; i < n; i++)
for ( j = i + 1; j < n; j++)
if (fabs(b[i][j] - c[k]) < 1e-9)
{
cout << fixed;
cout << "(" << a[i][0] << "," << a[i][1] << "," << a[i][2] << ")" << "-";
cout << "(" << a[j][0] << "," << a[j][1] << "," << a[j][2] << ")";
cout << "=" << setprecision(2) << b[i][j] << endl;
}
}
}
return 0;
}
|
64 | 31839 | main()
{
int i,j,p=0,n,b[10][3];
struct qwe
{
int a[3];
int b[3];
int jl;
}t[45],e;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",*(b+i),*(b+i)+1,*(b+i)+2);
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
t[p].a[0]=b[i][0];
t[p].a[1]=b[i][1];
t[p].a[2]=b[i][2];
t[p].b[0]=b[j][0];
t[p].b[1]=b[j][1];
t[p].b[2]=b[j][2];
t[p].jl=(b[i][0]-b[j][0])*(b[i][0]-b[j][0])+(b[i][1]-b[j][1])*(b[i][1]-b[j][1])+(b[i][2]-b[j][2])*(b[i][2]-b[j][2]);
p++;
}
}
for(i=0;i<p;i++)
{
for(j=0;j<p-i-1;j++)
{
if(t[j].jl<t[j+1].jl)
{
e=t[j];
t[j]=t[j+1];
t[j+1]=e;
}
}
}
for(i=0;i<p;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",t[i].a[0],t[i].a[1],t[i].a[2],t[i].b[0],t[i].b[1],t[i].b[2],sqrt(t[i].jl));
}
} |
64 | 31840 | struct point{
int a,b,c;
}x[10];
int d(int k,int n)
{
int i;
for(i=n-1;k>i;i--)
k-=i;
return(n-i-1);
}
int f(int k,int n)
{
int i;
for(i=n-1;k>i;i--)
k-=i;
return(n-i+k-1);
}
void main()
{
int n,i,j,k=0,q[46],t;
float y[46];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&x[i].a,&x[i].b,&x[i].c);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++,k++)
y[k]=sqrt((x[i].a-x[j].a)*(x[i].a-x[j].a)+(x[i].b-x[j].b)*(x[i].b-x[j].b)+(x[i].c-x[j].c)*(x[i].c-x[j].c));
for(i=0;i<=n*(n-1)/2;i++)
q[i]=i;
for(i=0;i<n*(n-1)/2-1;i++)
for(j=0;j<n*(n-1)/2-1-i;j++)
if(y[q[j]]<y[q[j+1]])
{t=q[j];
q[j]=q[j+1];
q[j+1]=t;
}
for(i=0;i<n*(n-1)/2;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",x[d(q[i]+1,n)].a,x[d(q[i]+1,n)].b,x[d(q[i]+1,n)].c,x[f(q[i]+1,n)].a,x[f(q[i]+1,n)].b,x[f(q[i]+1,n)].c,y[q[i]]);
}
}
|
64 | 31841 | /*
*????04.cpp
*??????
*?????2011-12-15
*???????????n??????10??,??n?????????,???????????????????????????
*/
int main()
{
int n; //?????????
cin>>n;
struct zb //?????????????
{
int x;
int y;
int z;
}dian[n];
for(int i=0;i<n;i++) //????
cin>>dian[i].x>>dian[i].y>>dian[i].z;
double distance[n][n]; //????????
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
distance[i][j]=0.0;
for(int i=0;i<n-1;i++) //?????????
for(int j=i+1;j<n;j++)
distance[i][j]=(sqrt)((dian[i].x-dian[j].x)*(dian[i].x-dian[j].x)+(dian[i].y-dian[j].y)*(dian[i].y-dian[j].y)+(dian[i].z-dian[j].z)*(dian[i].z-dian[j].z));
int amount=n*(n-1)/2;
for(int i=0;i<amount;i++) //??????????
{
double maxdis=0;
int maxX=0,maxY=0;
for(int j=0;j<n-1;j++) //??????????????????
{
for(int k=j+1;k<n;k++)
{
if(maxdis<distance[j][k])
{
maxdis=distance[j][k];
maxX=j;
maxY=k;
}
}
}
cout<<"("<<dian[maxX].x<<","<<dian[maxX].y<<","<<dian[maxX].z<<")"<<"-"<<"("<<dian[maxY].x<<","<<dian[maxY].y<<","<<dian[maxY].z<<")"<<"=";
cout<<fixed<<setprecision(2)<<maxdis<<endl;
distance[maxX][maxY]=0.0;
}
return 0;
} |
64 | 31842 | int main(){
int i,j,l,k=0,n;
cin >> n;
double x[11],y[11],z[11],dis[11][11],temp[50],ins;
for(i=0;i<n;i++)
cin >> x[i] >> y[i] >> z[i];
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
dis[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]); //?i???j????????
temp[k]=dis[i][j]; //??????????
k++;
}
}
for(i=0;i<k;i++){ //?????????
for(j=0;j<k-i-1;j++){
if(temp[j]>temp[j+1]){
ins=temp[j+1];
temp[j+1]=temp[j];
temp[j]=ins;
}
}
}
for(l=k-1;l>=0;l--){ //????
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(dis[i][j]==temp[l]) { //????????????????
cout << fixed << setprecision(0)<<'(' << x[i]<<','<<y[i]<<','<<z[i]<<")-("<<x[j]<<','<<y[j]<<','<<z[j]<<")="<<fixed << setprecision(2)<<sqrt(temp[l])<<endl;
//??????
dis[i][j]=-1; //??????????????????-1?????temp[]??
}
}
}
}
return 0;
}
|
64 | 31843 | int main()
{
int x[10],y[10],z[10];
int n,i,j,p,m,h;
double k,l[10][10];
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++)
{
k=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]);
l[i][j]=sqrt(k);
}
for(h=1;h<=n*(n-1)/2;h++)
{
double max=0;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(max<l[i][j])
{
max=l[i][j];
p=i,m=j;
}
cout<<"("<<x[p]<<","<<y[p]<<","<<z[p]<<")-("<<x[m]<<","<<y[m]<<","<<z[m]<<")="<< fixed << setprecision(2)<<l[p][m]<<endl;
l[p][m]=0;
}
return 0;
} |
64 | 31844 | //*******************************
//*??????? **
//*?????? 1300012965 **
//*???20131211 **
//*******************************
struct zb
{
int x;
int y;
int z;
}a[11];//??????
int main()
{
double l[100] = {0.0};
int i, j, k, n, co = 0, q[100] = {0}, temp, x1, y1, co1 = 0;
double lo, t;
cin >> n;
for(int p=1; p<=n*(n-1)/2; p++)
q[p] = p;//???????
for(i=1; i<=n; i++)
cin >> a[i].x >> a[i].y >> a[i].z;
for(j=1; j<=n-1; j++)
for(k=j+1; k<=n; k++)
{
lo = sqrt(((a[j].x-a[k].x)*(a[j].x-a[k].x)+
(a[j].y-a[k].y)*(a[j].y-a[k].y)+
(a[j].z-a[k].z)*(a[j].z-a[k].z))*1.0);//????
co++;
l[co] = lo;
}
for(int x=1; x<=n*(n-1)/2-1; x++)
for(int y=1; y<=n*(n-1)/2-x; y++)
if(l[y] < l[y+1])
{
t = l[y];
l[y] = l[y+1];
l[y+1] = t;//????
temp = q[y];
q[y] = q[y+1];
q[y+1] = temp;//????????
}
for(int x=1; x<=n*(n-1)/2; x++)
{
co1++;
for(int y=1; y<=n; y++)
{
if(q[co1] > n-y)
q[co1] -= n-y;
else
{
x1 = y;
y1 = q[co1] + y;//???????
break;
}
}
cout << "(" << a[x1].x << "," << a[x1].y << "," << a[x1].z << ")-("
<< a[y1].x << "," << a[y1].y << "," << a[y1].z << ")=" << fixed <<
setprecision(2) << l[x] << endl;
}
return 0;
} |
64 | 31845 | int main()
{
int n,i=0,j=0,k=0;;
double x[10],y[10],z[10],d[100],t,s,c[10][10]={0};
cin>>n;
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i]>>z[i];
}
for(int i=0;i<n;i++)
{
for(int 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]));
k++;
}
}
for(int k=0;k<(n*(n-1)/2)-1;k++)
{
for(int l=0;l<(n*(n-1)/2)-1;l++)
{
if(d[l]<d[l+1])
{
t=d[l+1];
d[l+1]=d[l];
d[l]=t;
}
}
}
for(int k=0;k<(n*(n-1)/2);k++)
{
s=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(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]))&&s==0&&c[i][j]==0)
{
cout<<"("<<fixed<<setprecision(0)<<x[i]<<","<<fixed<<setprecision(0)<<y[i]<<","<<fixed<<setprecision(0)<<z[i]<<")-("<<fixed<<setprecision(0)<<x[j]<<","<<fixed<<setprecision(0)<<y[j]<<","<<fixed<<setprecision(0)<<z[j]<<")="<<fixed<<setprecision(2)<<d[k]<<endl;
s+=1;
c[i][j]+=1;
}
}
}
}
return 0;
} |
64 | 31846 | int main()
{
int n,i,j,i1,j1,k;
double x[11],y[11],z[11],r[10][11];//?i????j??????r[i][j],?i??????(x[i],y[i],z[i])
cin>>n;//?n??
for(i=1;i<=n;i++)
cin>>x[i]>>y[i]>>z[i];//????
for(i=1;i<n;i++){
for(j=1;j<=n;j++)
r[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]));
}//?????????
double max=0;//?max?????????
for(k=1;k<=100;k++){
for(i=1;i<n;i++){
for(j=i;j<=n;j++){
if(r[i][j]>max){
max=r[i][j];
i1=i;j1=j;//????????????
}
}
}
if(max!=0){
cout<<fixed<<setprecision(0)<<"("<<x[i1]<<","<<y[i1]<<","<<z[i1]<<")-("<<x[j1]<<","<<y[j1]<<","<<z[j1]<<")=";
cout<<fixed<<setprecision(2)<<r[i1][j1]<<endl;
r[i1][j1]=0;//???????
max=0;}
}
return 0;
} |
64 | 31847 | int main()
{
int n,i,j,k=0,d,e,x[100],y[100],z[100];
double m,a[100][100]={-1},b[500]={-1},c[500];
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++){
a[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]));
b[k]=a[i][j];
k++;
}
}
for(i=0;i<k-1;i++){
for(j=0;j<k-i-1;j++){
if(b[j]<b[j+1]){
m=b[j];
b[j]=b[j+1];
b[j+1]=m;
}
}
}
e=1;
for(i=0;i<k-1;i++){
if(b[i]==b[i+e]){
for(e=1;1;e++){
if(b[i]==b[i+e])
b[i+e]=-1;
else
break;
}
}
}
j=0;
for(i=0;i<k;i++){
if(b[i]!=-1){
c[j]=b[i];
j++;
}
}
for(i=0;i<j;i++){
for(k=0;k<n-1;k++){
for(d=k+1;d<n;d++){
if(a[k][d]==c[i])
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[k],y[k],z[k],x[d],y[d],z[d],c[i]);
}
}
}
return 0;
} |
64 | 31848 | int main()
{
int a[1000][3],n,m,l=1,i,j;
double b[3000][3],q,w,e;
scanf("%d",&n);
m=n*(n-1)/2;
for( i=1;i<=n;i++){
for(j=1;j<=3;j++){
scanf("%d",&a[i][j]);
}}
for(i=1;i<=n;i++){
for( j=i+1;j<=n;j++){
b[l][1]=i;
b[l][2]=j;
b[l][3]=sqrt((double)(
(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])
)
);
l++;}
}
for(i=1;i<=m;i++){
for( j=1;j<=m-i;j++){
if(b[j][3]<b[j+1][3]){
q=b[j][1]; w=b[j][2]; e=b[j][3];
b[j][1]=b[j+1][1];b[j][2]=b[j+1][2];b[j][3]=b[j+1][3];
b[j+1][1]=q; b[j+1][2]=w; b[j+1][3]=e;
}
}
}
for(i=1;i<=m;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",
a[(int)b[i][1]][1],a[(int)b[i][1]][2],a[(int)b[i][1]][3],
a[(int)b[i][2]][1],a[(int)b[i][2]][2],a[(int)b[i][2]][3],
b[i][3]);
}
return 0;
} |
64 | 31849 | struct zz
{
float key;
int num1,num2;
}a[1005]={0,0,0},va;
int main()
{
int n;
cin>>n;
float x[n+5],y[n+5],z[n+5];
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i]>>z[i];
}
for(int i=0,k=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
{
a[k].key=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].num1=i;
a[k].num2=j;
k=k+1;
}
}
for(int i=0;i<(n-1)*n/2-1;i++)
{
for(int j=0;j<(n-1)*n/2-1-i;j++)
{
if(a[j].key<a[j+1].key || (a[j].key == a[j+1].key && a[j].num1 > a[j+1].num1) || (a[j].key == a[j+1].key && a[j].num1 == a[j+1].num1 && a[j].num2 > a[j+1].num2))
{
va=a[j];
a[j]=a[j+1];
a[j+1]=va;
}
}
}
for(int i=0;i<(n-1)*n/2;i++)
printf("(%.0f,%.0f,%.0f)-(%.0f,%.0f,%.0f)=%.2f\n",x[a[i].num1],y[a[i].num1],z[a[i].num1],x[a[i].num2],y[a[i].num2],z[a[i].num2],a[i].key);
return 0;
}
|
64 | 31850 | struct suanshi{
int a[3],b[3];
int no;
float x;
}dian[45];
int cmp(const void *a,const void *b){
struct suanshi *aa=(struct suanshi *)a;
struct suanshi *bb=(struct suanshi *)b;
if((aa->x)<(bb->x))return 1;
if((aa->x)>(bb->x))return -1;
else return (aa->no)-(bb->no);
}
void main(){
int point[11][3];
int n,i,j,t=0;
scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d%d%d",&point[i][0],&point[i][1],&point[i][2]);
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
dian[t].no=t+1;
dian[t].a[0]=point[i][0];dian[t].a[1]=point[i][1];dian[t].a[2]=point[i][2];
dian[t].b[0]=point[j][0];dian[t].b[1]=point[j][1];dian[t].b[2]=point[j][2];
dian[t].x=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]));
t++;
}
}
for(j=0;n>0;){
n--;
j+=n;
}
qsort(dian,j,sizeof(struct suanshi),cmp);
for(i=0;i<j;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",dian[i].a[0],dian[i].a[1],dian[i].a[2],dian[i].b[0],dian[i].b[1],dian[i].b[2],dian[i].x);
} |
64 | 31851 | int main()
{
int n;
cin>>n;
int x[n],y[n],z[n],p,q;
float d[n][n-1],t;
float a[n*(n-1)/2];
int k=0;
int b[n*(n-1)/2],c[n*(n-1)/2];
for(int i=0;i<n;i++)
cin>>x[i]>>y[i]>>z[i];
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++)
{
d[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]));
a[k]=d[i][j];b[k]=i;c[k]=j;
k++;
}
for(int i=1;i<n*(n-1)/2;i++)
for(int j=0;j<n*(n-1)/2-i;j++)
{
if(a[j]<a[j+1])
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
p=b[j];
b[j]=b[j+1];
b[j+1]=p;
q=c[j];
c[j]=c[j+1];
c[j+1]=q;
}
}
for(int i=0;i<k;i++)
{
cout<<"("<<x[b[i]]<<","<<y[b[i]]<<","<<z[b[i]]<<")-"<<"("<<x[c[i]]<<","<<y[c[i]]<<","<<z[c[i]]<<")="<<fixed<<setprecision(2)<<a[i]<<endl;
}
return 0;
} |
64 | 31852 | int main()
{
int n,m,i,j,x,y,t=0;
cin>>n;
int a[10],b[10],c[10],e[100];
double d[100];
for(i=0;i<n;i++)
cin>>a[i]>>b[i]>>c[i];
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{e[t]=10*i+j;
d[e[t]]=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]));
t++;
}
for(i=1;i<t;i++)
for(j=0;j<t-i;j++)
{if(d[e[j]]<d[e[j+1]])
{
m=e[j];
e[j]=e[j+1];
e[j+1]=m;
}}
for(i=0;i<t;i++)
{x=e[i]%10;
y=(e[i]-x)/10;
cout<<"("<<a[y]<<","<<b[y]<<","<<c[y]<<")-("<<a[x]<<","<<b[x]<<","<<c[x]<<")="<<fixed<<setprecision(2)<<d[e[i]]<<endl;
}
return 0;
} |
64 | 31853 | int main(){
int n,i,j,N,k,t;
int a[11][4],b[50][7];
double d[50],e;
scanf("%d",&n);
N=n*(n-1)/2;
for(i=1;i<=n;i++){
for(j=1;j<=3;j++){
scanf("%d",&a[i][j]);
}
}
t=1;
for(i=1;i<n;i++){
for(j=i+1;j<=n;j++){ b[t][3]=a[i][3];
b[t][1]=a[i][1];
b[t][2]=a[i][2];
b[t][6]=a[j][3];
b[t][4]=a[j][1];
b[t][5]=a[j][2];
t++;
}
}
for(t=1;t<=N;t++){
d[t]=sqrt((b[t][3]-b[t][6])*(b[t][3]-b[t][6])+(b[t][1]-b[t][4])*(b[t][1]-b[t][4])+(b[t][2]-b[t][5])*(b[t][2]-b[t][5]));
}
for(k=N;k>0;k--){
for(i=1;i<k;i++){
if(d[i]<d[i+1]){
e=d[i];
d[i]=d[i+1];
d[i+1]=e;
for(j=1;j<=6;j++){
e=b[i][j];
b[i][j]=b[i+1][j];
b[i+1][j]=e;
}
}
}
}
for(i=1;i<=N;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",b[i][1],b[i][2],b[i][3],b[i][4],b[i][5],b[i][6],d[i]);
}
return 0;
} |
64 | 31854 | struct coordinate
{
int x;
int y;
int z;
} point[10];
int main()
{
double dis[10][10]={0}, d[100]={0}, temp=0;
int i, j, n, k1=0, k2=0, k;
cin>>n;
for(i=0; i<n; i++)
{
cin>>point[i].x>>point[i].y>>point[i].z;
}
for(i=0; i<n-1; i++)
{
for(j=i+1; j<n; j++)
{
dis[i][j]=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)) ;
d[10*i+j]=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)) ;
}
}
for(i=0; i<99; i++)
{
for(j=99; j>i; j--)
{
if(d[j]>d[j-1])
{
temp=d[j];
d[j]=d[j-1];
d[j-1]=temp;
}
}
}
for(i=99; i>=1; i--)
{
if(d[i]==d[i-1])
{
d[i]=0;
}
}
for(k=0; k<99; k++)
{
if(d[k]!=0)
{
for(i=0; i<n-1; i++)
{
for(j=i+1; j<n; j++)
{
if(dis[i][j]==d[k])
{
cout<<"("<<point[i].x<<","<<point[i].y<<","<<point[i].z<<")-("<<
point[j].x<<","<<point[j].y<<","<<point[j].z<<")="<<fixed<<setprecision(2)<<dis[i][j]<<endl;
}
}
}
}
}
return 0;
} |
64 | 31855 | int main()
{
int i,k,m,n,h,d,g;
int a[10],b[10],c[10],p[50],q[50];
double s[50],max;
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
for(i=1,m=0;i<n;i++)
{
for(k=i+1;k<=n;k++)
{
m++;
s[m]=sqrt((a[i]-a[k])*(a[i]-a[k])+(b[i]-b[k])*(b[i]-b[k])+(c[i]-c[k])*(c[i]-c[k]));
p[m]=i;
q[m]=k;
}
}
for(i=1;i<=m;i++)
{
for(k=1;k<=m-i;k++)
{
if(s[k]<s[k+1])
{
max=s[k];
s[k]=s[k+1];
s[k+1]=max;
h=p[k];
p[k]=p[k+1];
p[k+1]=h;
d=q[k];
q[k]=q[k+1];
q[k+1]=d;
}
}
}
for(i=1;i<=m;i++)
{
h=p[i];
d=q[i];
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[h],b[h],c[h],a[d],b[d],c[d],s[i]);
}
return 0;
}
|
64 | 31856 | float juli(float x1,float y1,float z1,float x2,float y2,float z2)
{
return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)+(z1-z2)*(z1-z2));
}
int main()
{
int n,u=0;
int i,j,t;
float x[10],y[10],z[10],d[50],m;
int a[50],b[50];
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%f %f %f",&x[i],&y[i],&z[i]);
}
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
d[u]=juli(x[i],y[i],z[i],x[j],y[j],z[j]);
a[u]=i;
b[u]=j;
u++;
}
}
for(i=0;i<u;i++)
{
for(j=u-1;j>i;j--)
{
if(d[j]>d[j-1])
{
m=d[j];
d[j]=d[j-1];
d[j-1]=m;
t=a[j];
a[j]=a[j-1];
a[j-1]=t;
t=b[j];
b[j]=b[j-1];
b[j-1]=t;
}
}
}
for(i=0;i<u;i++)
{
printf("(%.0f,%.0f,%.0f)-(%.0f,%.0f,%.0f)=%.2f\n",x[a[i]],y[a[i]],z[a[i]],x[b[i]],y[b[i]],z[b[i]],d[i]);
}
return 0;
}
|
64 | 31857 | int main()
{
int n,i,j,k=0,l;
double B[10][10],a,C[91]={0},A[10][3];
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++)
{
B[i][j]=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]=B[i][j];
k=k+1;
}
}
for (i=0;i<n*(n-1)/2;i++)
{
for (j=0;j<n*(n-1)/2-1;j++)
{
if (C[j]<C[j+1])
{
a=C[j];
C[j]=C[j+1];
C[j+1]=a;
}
}
}
for (i=0;i<n*(n-1)/2;i++)
{
for (k=0;k<n-1;k++)
{
for (l=k+1;l<n;l++)
{
if (B[k][l]==C[i])
{
cout<<fixed<<setprecision(0)<<"("<<A[k][0]<<","<<A[k][1]<<","<<A[k][2]<<")"<<"-"<<"("<<A[l][0]<<","<<A[l][1]<<","<<A[l][2]<<")"<<"=";
cout<<fixed<<setprecision(2)<<B[k][l]<<endl;
B[k][l]=0;
}
}
}
}
return 0;
} |
64 | 31858 | int main()
{
int i,n,k,p=0,f;
int c[100],d[100];
int a[100][50];
double b[200],q,e;
scanf("%d",&n);
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;i++)
{
for(k=i+1;k<n;k++)
{
q=(a[i][0]-a[k][0])*(a[i][0]-a[k][0])+(a[i][1]-a[k][1])*(a[i][1]-a[k][1])+(a[i][2]-a[k][2])*(a[i][2]-a[k][2]);
b[p]=sqrt(q);
c[p]=i;
d[p]=k;
p++;
}
}
for(i=1;i<=p;i++)
{
for(k=0;k<p-i;k++)
{
if(b[k+1]>b[k])
{
e=b[k+1];
b[k+1]=b[k];
b[k]=e;
f=c[k+1];
c[k+1]=c[k];
c[k]=f;
f=d[k+1];
d[k+1]=d[k];
d[k]=f;
}
}
}
for(i=0;i<p;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 | 31859 | struct point
{
int x;
int y;
int z;
}po[10];
struct distance
{
double dist;
int x1;
int y1;
int z1;
int x2;
int y2;
int z2;
};
int main()
{
int n,i,j,k=0;
struct distance dis[50],temp;
cin>>n;
for(i=0;i<n;i++)
{
cin>>po[i].x>>po[i].y>>po[i].z;
}
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
{
dis[k].dist=sqrt((po[i].x-po[j].x)*(po[i].x-po[j].x)+(po[i].y-po[j].y)*(po[i].y-po[j].y)+(po[i].z-po[j].z)*(po[i].z-po[j].z));
dis[k].x1=po[i].x;
dis[k].y1=po[i].y;
dis[k].z1=po[i].z;
dis[k].x2=po[j].x;
dis[k].y2=po[j].y;
dis[k].z2=po[j].z;
k++;
}
for(i=0;i<n*(n-1)/2-1;i++)
{
for(j=0;j<n*(n-1)/2-i-1;j++)
{
if(dis[j].dist<dis[j+1].dist)
{
temp=dis[j+1];
dis[j+1]=dis[j];
dis[j]=temp;
}
}
}
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<<")"<<"="<<fixed<<setprecision(2)<<dis[i].dist<<endl;
}
return 0;
} |
64 | 31860 | int main(){
int a[10][3];
int n;
int i,j,k;
//double ans[100];
double ans[10][10];
cin>>n;
for(i = 0;i<n;++i){
for(j = 0;j<3;++j){
cin>>a[i][j];
}
}
for(i = 0;i<n;++i){
for(j = i+1;j<n;++j){
ans[i][j] = sqrt(pow((double)a[i][0]-a[j][0],2)+pow((double)a[i][1]-a[j][1],2)+pow((double)a[i][2]-a[j][2],2));
//cout<<ans[i *n + j]<<" ";
}
//cout<<endl;
}
int sum = n*(n-1)/2;
while(sum >0){
sum--;
int maxI = 0;
int maxJ = 1;
for(i = 0;i<n;++i){
for(j = i+1;j<n;++j){
if(ans[i][j] > ans[maxI][maxJ]){
maxI = i;
maxJ = j;
}
}
}
//(1,1,0)-(1,1,1)=1.00
cout<<"("<<a[maxI][0]<<","<<a[maxI][1]<<","<<a[maxI][2]<<")-("
<<a[maxJ][0]<<","<<a[maxJ][1]<<","<<a[maxJ][2]<<")="
<<fixed<<setprecision(2)<<ans[maxI][maxJ]<<endl;
ans[maxI][maxJ] = -9999999;
}
cin>>i;
return 0;
} |
64 | 31861 | double juli(int a,int b,int c,int d,int e,int f)
{
double t;
t=sqrt((a-d)*(a-d)+(b-e)*(b-e)+(c-f)*(c-f));
return t;
}
int main()
{
int a[11],b[11],c[11],e[50],f[50],temp1;
double d[50],temp;
int n,i,j,t=0;
scanf("%d",&n);
for(i=0;i<=n-1;i++)
{
scanf("%d%d%d",&a[i],&b[i],&c[i]);
}
for(j=0;j<=n-2;j++)
{
for(i=j;i<=n-2;i++)
{
d[t]=juli(a[j],b[j],c[j],a[i+1],b[i+1],c[i+1]);
e[t]=j;
f[t]=i+1;
t++;
}
}
for(i=0;i<=n*(n-1)/2-2;i++)
{
for(j=0;j<=n*(n-1)/2-2-i;j++)
{
if(d[j]<d[j+1])
{
temp=d[j];
d[j]=d[j+1];
d[j+1]=temp;
temp1=e[j];
e[j]=e[j+1];
e[j+1]=temp1;
temp1=f[j];
f[j]=f[j+1];
f[j+1]=temp1;
}
}
}
for(i=0;i<=n*(n-1)/2-1;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[e[i]],b[e[i]],c[e[i]],a[f[i]],b[f[i]],c[f[i]],d[i]);
}
return 0;
}
|
64 | 31862 | int main (){
int n;
cin>>n;
int x[10],y[10],z[10];
int i,j;
for(i=0;i<=n-1;i++)
cin>>x[i]>>y[i]>>z[i];
float d[45];
int s[45],e[45];
int t=0;
for(i=0;i<=n-2;i++)
for(j=i+1;j<=n-1;j++)
{
d[t]=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]=i,e[t]=j;
t++;
}
float tempd;
int temp;
for(i=0;i<=t-2;i++)
for(j=t-1;j>=i+1;j--)
if(d[j]>d[j-1])
{
tempd=d[j];d[j]=d[j-1];d[j-1]=tempd;
temp=s[j];s[j]=s[j-1];s[j-1]=temp;
temp=e[j];e[j]=e[j-1];e[j-1]=temp;
}
cout<<fixed<<setprecision(2);
for(i=0;i<=t-1;i++)
cout<<"("<<x[s[i]]<<","<<y[s[i]]<<","<<z[s[i]]<<")-("<<x[e[i]]<<","<<y[e[i]]<<","<<z[e[i]]<<")="<<d[i]<<endl;
} |
64 | 31863 | int main(){
int i,x,n,g,l,p,a,b,c;
double e;
double dst[45];
int xz[10];int yz[10];int zz[10];
int dx[45];int dy[45];int dz[45];
int sx[45];int sy[45];int sz[45];
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d %d %d ",&(xz[i]),&(yz[i]),&(zz[i]));
}
g=0;
for(i=0;i<n-1;i++){
for(x=i+1;x<n;x++){
a=((xz[i])-(xz[x]))*((xz[i])-(xz[x]));
b=((yz[i])-(yz[x]))*((yz[i])-(yz[x]));
c=((zz[i])-(zz[x]))*((zz[i])-(zz[x]));
dst[g]=pow((double)(a+b+c),0.5);
dx[g]=xz[i];dy[g]=yz[i];dz[g]=zz[i];
sx[g]=xz[x];sy[g]=yz[x];sz[g]=zz[x];
g=g+1;
}
}
for(i=0;i<g;i++){
for(x=0;x<g-i-1;x++){
if(dst[x]<dst[x+1]){
e=dst[x+1];
dst[x+1]=dst[x];
dst[x]=e;
l=dx[x+1];
dx[x+1]=dx[x];
dx[x]=l;
l=dy[x+1];
dy[x+1]=dy[x];
dy[x]=l;
l=dz[x+1];
dz[x+1]=dz[x];
dz[x]=l;
l=sx[x+1];
sx[x+1]=sx[x];
sx[x]=l;
l=sy[x+1];
sy[x+1]=sy[x];
sy[x]=l;
l=sz[x+1];
sz[x+1]=sz[x];
sz[x]=l;
}
}
}
for(i=0;i<g;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n\n",dx[i],dy[i],dz[i],sx[i],sy[i],sz[i],dst[i]);
}
return 0;
} |
64 | 31864 | int main(){
int x[10],y[10],z[10];
double l[10][10];
double d[100];
double m;
int i,j,k,n;
int s=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-1;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]));
d[s]=l[i][j];
s+=1;
}
}
for(i=0;i<n*n;i++){
for(j=0;j<n*(n-1)/2-1;j++){
if(d[j]<d[j+1]){
m=d[j];
d[j]=d[j+1];
d[j+1]=m;
}
}
}
for(k=0;k<n*(n-1)/2;k++){
while(d[k]==d[k-1]){
k+=1;
}
for(i=0;i<n-1;i++){
for(j=i+1;j<n;j++){
if(l[i][j]==d[k]){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[i],y[i],z[i],x[j],y[j],z[j],d[k]);
}
}
}
}
return 0;
} |
64 | 31865 | /**
* @file homework.cpp
* @author ???
* @date 2011-12-06
* @description
* ??????: ??????
*/
struct juli
{
int a;
int b;
double dis;
}x[45],t;
int main()
{
int n,m=0;
int i,j,k,p=0,l,s,r;
int a[10][3]={0};
cin>>n;
for(i=0;i<n;i++)
{
cin>>a[i][0]>>a[i][1]>>a[i][2];
}
m=n*n/2-n/2;
for(j=0;j<n-1;j++)
{
for(k=j+1;k<n;k++)
{
if(k>j)
{
x[p].a=j;
x[p].b=k;
x[p].dis=sqrt((a[j][0]-a[k][0])*(a[j][0]-a[k][0])
+(a[j][1]-a[k][1])*(a[j][1]-a[k][1])
+(a[j][2]-a[k][2])*(a[j][2]-a[k][2]));
p++;
}
}
}
for(l=0;l<m-1;l++)
{
for(s=0;s<m-l-1;s++)
{
if(x[s].dis<x[s+1].dis)
{
t=x[s];
x[s]=x[s+1];
x[s+1]=t;
}
}
}
for(r=0;r<m;r++)
{
cout<<"("<<a[x[r].a][0]<<","<<a[x[r].a][1]<<","<<a[x[r].a][2]<<")-("
<<a[x[r].b][0]<<","<<a[x[r].b][1]<<","<<a[x[r].b][2]<<")="
<<fixed<<setprecision(2)<<x[r].dis<<endl;
}
return 0;
}
|
64 | 31866 | int main()
{
double cd[1000],s;
struct zuobiao{int x,y,z;}zuobiao[100];
struct jl{int q,w,e,r,t,u;}jl[1000];
int i,j,n,k,a,b,c,d,f,g;
scanf("%d",&n);
k=0;
for(i=0;i<n;i++)
scanf("%d%d%d",&(zuobiao[i].x),&(zuobiao[i].y),&(zuobiao[i].z));
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
cd[k]=sqrt((zuobiao[i].x-zuobiao[j].x)*(zuobiao[i].x-zuobiao[j].x)+(zuobiao[i].y-zuobiao[j].y)*(zuobiao[i].y-zuobiao[j].y)+(zuobiao[i].z-zuobiao[j].z)*(zuobiao[i].z-zuobiao[j].z));
jl[k].q=zuobiao[i].x;
jl[k].w=zuobiao[i].y;
jl[k].e=zuobiao[i].z;
jl[k].r=zuobiao[j].x;
jl[k].t=zuobiao[j].y;
jl[k].u=zuobiao[j].z;
k=k+1;
}
}
for(j=1;j<=k;j++)
{
for(i=0;i<k-j;i++)
{
if(cd[i]<cd[i+1])
{
s=cd[i];cd[i]=cd[i+1];cd[i+1]=s;
a=jl[i].q;
jl[i].q=jl[i+1].q;
jl[i+1].q=a;
b=jl[i].w;
jl[i].w=jl[i+1].w;
jl[i+1].w=b;
c=jl[i].e;
jl[i].e=jl[i+1].e;
jl[i+1].e=c;
d=jl[i].r;
jl[i].r=jl[i+1].r;
jl[i+1].r=d;
f=jl[i].t;
jl[i].t=jl[i+1].t;
jl[i+1].t=f;
g=jl[i].u;
jl[i].u=jl[i+1].u;
jl[i+1].u=g;
}
}
}
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",jl[i].q,jl[i].w,jl[i].e,jl[i].r,jl[i].t,jl[i].u,cd[i]);
return 0;
} |
64 | 31867 | struct twopoint{
float a1[3],a2[3],c;
}b[45];
float a[10][3];
int select(float b[],int n){
int i,j,c;
for(i=0;i<n;i++){ c=0;
for(j=0;j<3;j++)
if(b[j]==a[i][j]) c++;
if(c==3) return(i);
}
}
void selectsort(struct twopoint b[],int n,int m){
int i,j,k,i1,j1;
float d[4];
struct twopoint temp;
for(i=0;i<n;i++){ d[3]=0;
for(j=0;j<3;j++){
d[j]=b[i].a1[j]-b[i].a2[j];
d[j]=d[j]*d[j];
d[3]+=d[j];
}
b[i].c=sqrt(d[3]);
}
for(i=0;i<n-1;i++){
k=i;
for(j=i+1;j<n;j++)
if(b[j].c>b[k].c) k=j;
else if(b[j].c==b[k].c){
i1=select(b[j].a1,m);
j1=select(b[k].a1,m);
if(i1<j1) k=j;
if(i1==j1){
i1=select(b[j].a2,m);
j1=select(b[k].a2,m);
if(i1<j1) k=j;
}
}
if(k!=i){
temp=b[k];
b[k]=b[i];
b[i]=temp;
}
}
}
main(){
int n1,n2,i,j,k,l=0,l1;
scanf("%d",&n1);
k=(n1-1)*n1/2; n2=n1;
for(i=0;i<n1;i++)
for(j=0;j<3;j++)
scanf("%f",&a[i][j]);
i=0;
while(--n2>0){ l1=l;
for(;l<l1+n2;l++)
for(j=0;j<3;j++)
b[l].a1[j]=a[i][j];
i++;
}
n2=n1;l=0;i=0;
while(--n2>0){ l1=l;i++;
for(;l<l1+n2;l++)
for(j=0;j<3;j++)
b[l].a2[j]=a[l-l1+i][j];
}
selectsort(b,k,n1);
for(i=0;i<k;i++)
printf("(%g,%g,%g)-(%g,%g,%g)=%0.2f\n",b[i].a1[0],b[i].a1[1],b[i].a1[2],b[i].a2[0],b[i].a2[1],b[i].a2[2],b[i].c);
}
|
64 | 31868 |
int main(){
int n,x[20],y[20],z[20];
float dis[20][20],a[400];
int k=0;
cin>>n;
for(int i=0;i<n;i++)
cin>>x[i]>>y[i]>>z[i];
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++)
{
a[k]=dis[i][j]=sqrt((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])));
k++;
}
for(int i=0;i<k-1;i++)
for(int j=0;j<k-i;j++)
if(a[j]<a[j+1])
swap(a[j],a[j+1]);
for(int g=0;g<k;g++)
{
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
if (a[g]!=a[g+1]&&a[g]==dis[i][j])
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",x[i],y[i],z[i],x[j],y[j],z[j],a[g]);
}
}
}
}
return 0;
} |
64 | 31869 |
struct point
{
int x;
int y;
int z;
} p[100];
struct line
{
int p1;
int p2;
double len;
} l[1000];
int main()
{
int n, i, j, d[1000], c = 0;
double temp;
cin >> n;
for (i = 0; i < n; i++)
{
cin >> p[i].x >> p[i].y >> p[i].z;
}
for (i = 0; i < n; i++)
{
for (j = i + 1; j < n; j++)
{
l[c].len = sqrt ( (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));
l[c].p1 = i;
l[c].p2 = j;
c++;
}
}
for (i = 0; i < n * (n - 1) / 2; i++)
{
for (j = 0; j < n * (n - 1) / 2 - i; j++)
{
if (l[j].len < l[j + 1].len )
{
temp = l[j].len;
l[j].len = l[j + 1].len;
l[j + 1].len = temp;
temp = l[j].p1;
l[j].p1 = (int) l[j + 1].p1;
l[j + 1].p1 =(int) temp;
temp = l[j].p2;
l[j].p2 = (int) l[j + 1].p2;
l[j + 1].p2 =(int) temp;
}
}
}
for (i = 0; i < n * (n - 1) / 2; i++)
{
cout << "(" << p[l[i].p1].x << "," << p[l[i].p1].y << "," << p[l[i].p1].z << ")-(" << p[l[i].p2].x << "," << p[l[i].p2].y << "," << p[l[i].p2].z << ")=" << fixed << setprecision(2) << l[i].len << setprecision(0) << endl;
}
return 0;
}
|
64 | 31870 | typedef struct Point
{
int x;
int y;
int z;
}Point;
double Distance(Point *p1,Point *p2)
{
int x=(p1->x)-(p2->x);
int y=(p1->y)-(p2->y);
int z=(p1->z)-(p2->z);
double temp=(double)(x*x+y*y+z*z);
return sqrt(temp);
}
void Input(Point *p[],int n)
{
int i;
for(i=0;i<n;i++)
{
p[i]=(Point *)malloc(sizeof(Point));
scanf("%d",&p[i]->x);
scanf("%d",&p[i]->y);
scanf("%d",&p[i]->z);
}
}
void Output(Point *p1,Point *p2)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n\n",p1->x,p1->y,p1->z,p2->x,p2->y,p2->z,Distance(p1,p2));
}
int main()
{
int n,i,j;
scanf("%d",&n);
Point *p[100];
Input(p,n);
double a[100];
int k=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{ int t=0;
while(t<k+1 &&(a[t]-Distance(p[i],p[j])>0.00001 ||Distance(p[i],p[j])-a[t]>0.00001)) t++;
if(t==k+1){ a[k]=Distance(p[i],p[j]); k++; }
}
}
int count=k;
for(i=0;i<count;i++)
{
for(j=i+1;j<count;j++)
{
if(a[i]<a[j])
{ double temp=a[i]; a[i]=a[j]; a[j]=temp; }
}
}
k=0;
while(k<count)
{
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{ if(a[k]>Distance(p[i],p[j]))
{ if(a[k]-Distance(p[i],p[j])<0.000001)
Output(p[i],p[j]);
}
else
{
if(Distance(p[i],p[j])-a[k]<0.000001)
Output(p[i],p[j]);
}
}
}
k++;
}
} |
64 | 31871 | int main()
{
int n,i,s,j;
struct point
{
int a,b,c;
}p[10];
struct distance
{
double d;
int x1,x2,y1,y2,z1,z2;
}dis[45],temp;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d%d%d",&p[i].a,&p[i].b,&p[i].c);
i=0;
j=1;
for(s=0;s<n*(n-1)/2;s++)
{
dis[s].x1=p[i].a;
dis[s].x2=p[j].a;
dis[s].y1=p[i].b;
dis[s].y2=p[j].b;
dis[s].z1=p[i].c;
dis[s].z2=p[j].c;
j++;
if(j==n)
{
i++;
j=i+1;
}
}
for(s=0;s<n*(n-1)/2;s++)
dis[s].d=sqrt((dis[s].x1-dis[s].x2)*(dis[s].x1-dis[s].x2)+(dis[s].y1-dis[s].y2)*(dis[s].y1-dis[s].y2)+(dis[s].z1-dis[s].z2)*(dis[s].z1-dis[s].z2));
for(j=1;j<n*(n-1)/2;j++)
{
for(i=0;i<n*(n-1)/2-j;i++)
{
if(dis[i].d<dis[i+1].d)
{
temp=dis[i];
dis[i]=dis[i+1];
dis[i+1]=temp;
}
}
}
for(s=0;s<n*(n-1)/2;s++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dis[s].x1,dis[s].y1,dis[s].z1,dis[s].x2,dis[s].y2,dis[s].z2,dis[s].d);
return 0;
} |
64 | 31872 | int main(){
int n, xz[100], yz[100], zz[100], xx[100], yy[100];
double jl[100];
double j[100];
int c=0;
int t, m, l;
scanf("%d\n",&n);
for(int i=0;i<n;i++){
scanf("%d %d %d",&xz[i], &yz[i], &zz[i]);
}
for(int a=0;a<n;a++){
for(int b=a+1;b<n;b++){
jl[c]=(zz[b]-zz[a])*(zz[b]-zz[a])+(xz[b]-xz[a])*(xz[b]-xz[a])+(yz[b]-yz[a])*(yz[b]-yz[a]);
xx[c]=a;
yy[c]=b;
c=c+1;
}
}
for(int k=1;k<=c;k++){
for(int i=0;i<c-k;i++){
if(jl[i]<jl[i+1]){
t=jl[i];
jl[i]=jl[i+1];
jl[i+1]=t;
m=xx[i];
xx[i]=xx[i+1];
xx[i+1]=m;
l=yy[i];
yy[i]=yy[i+1];
yy[i+1]=l;
}
}
}
for(int w=0;w<c;w++){
j[w]=sqrt(jl[w]);
}
for(int s=0;s<c;s++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n", xz[xx[s]], yz[xx[s]], zz[xx[s]], xz[yy[s]], yz[yy[s]], zz[yy[s]], j[s]);
}
return 0;}
|
64 | 31873 | int point[MAX][3];
double d;
struct {
int x1,x2,y1,y2,z1,z2;
double d;
}dis[DIS],mid;
int n,m=0,i,j;
int main()
{
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d%d%d",&point[i][0],&point[i][1],&point[i][2]);
}
for(i=0;i<n-1;i++)
{
for(j=i+1;j<n;j++)
{
dis[m].x1=point[i][0];
dis[m].y1=point[i][1];
dis[m].z1=point[i][2];
dis[m].x2=point[j][0];
dis[m].y2=point[j][1];
dis[m].z2=point[j][2];
dis[m].d=sqrt(pow((dis[m].x1-dis[m].x2),2)+pow((dis[m].y1-dis[m].y2),2)+pow((dis[m].z1-dis[m].z2),2));
m++;
}
}
for(i=0;i<m;i++)
{
for(j=0;j<m-1;j++)
{
if(dis[j].d<dis[j+1].d)
{
mid=dis[j];
dis[j]=dis[j+1];
dis[j+1]=mid;
}
}
}
for(i=0;i<m;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",dis[i].x1,dis[i].y1,dis[i].z1,dis[i].x2,dis[i].y2,dis[i].z2,dis[i].d);
}
return 0;
}
|
64 | 31874 |
void main()
{
int i,j,k,n;
int point[10][3];
double dis[10][10];
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&point[i][0],&point[i][1],&point[i][2]);
// for(i=0;i<n;i++)
// printf("%d %d %d\n",point[i][0],point[i][1],point[i][2]);
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
dis[i][j]=(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]);
for(k=n*(n-1)/2;k>0;k--)
{
double max=0;
int s,t;
for (i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(dis[i][j]>max)
{
max=dis[i][j];
s=i;
t=j;
}
max=sqrt(max);
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",point[s][0],point[s][1],point[s][2],point[t][0],point[t][1],point[t][2],max);
dis[s][t]=0;
}
}
|
64 | 31875 |
struct POINT{
int x, y, z;
};
struct DISTANCE{
int pointx, pointy;
double dis;
};
int cmp(const void* e1, const void* e2){
struct DISTANCE* elem1 = (struct DISTANCE*)e1;
struct DISTANCE* elem2 = (struct DISTANCE*)e2;
if(elem1->dis == elem2->dis)
return (elem1->pointx) - (elem2->pointx);
if(elem1->dis > elem2->dis)
return -1;
return 1;
}
int main(){
int n;
struct POINT data[11];
struct DISTANCE distance[10000];
scanf("%d", &n);
int i;
for(i=0; i<n; i++)
scanf("%d %d %d", &(data[i].x), &(data[i].y), &(data[i].z));
int j;
int cnt = 0;
for(i=0; i<n; i++)
for(j=i+1; j<n; j++){
distance[cnt].pointx = i;
distance[cnt].pointy = j;
distance[cnt].dis = sqrt((data[i].x-data[j].x)*(data[i].x-data[j].x)+(data[i].y-data[j].y)*(data[i].y-data[j].y)+(data[i].z-data[j].z)*(data[i].z-data[j].z));
cnt++;
}
qsort(distance, cnt, sizeof(struct DISTANCE), cmp);
for(i=0; i<cnt; i++){
int x=distance[i].pointx;
int y=distance[i].pointy;
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n", data[x].x, data[x].y, data[x].z, data[y].x, data[y].y, data[y].z, distance[i].dis);
}
return 0;
}
|
64 | 31876 | int main()
{
int n,i,k,j,sum=0,l=0;
double di[100],e;
struct i{
int x,y,z;
}a[100],b[100],g,c[100];
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;i++)
{
for(j=i+1;j<n;j++)
{
di[l]=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));
b[l]=a[i];
c[l]=a[j];
l++;
}
}
for(k=1;k<=l;k++)
{
for(i=0;i<l-k;i++)
{
if(di[i]<di[i+1])
{
e=di[i];
di[i]=di[i+1];
di[i+1]=e;
g=b[i];
b[i]=b[i+1];
b[i+1]=g;
g=c[i];
c[i]=c[i+1];
c[i+1]=g;
}
}
}
for(i=0;i<l;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",b[i].x,b[i].y,b[i].z,c[i].x,c[i].y,c[i].z,di[i]);
return 0;
} |
64 | 31877 | int main()
{
int a,c,k,i,m,j,n,x[101],y[101],z[101],xs[101],ys[101],zs[101],xz[101],yz[101],zz[101];
double b,l[10][10],ls[100];
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(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]));
}
}
a=0;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
xs[a]=x[i];
ys[a]=y[i];
zs[a]=z[i];
xz[a]=x[j];
yz[a]=y[j];
zz[a]=z[j];
ls[a]=l[i][j];
a++;
m=a;
}
}
k=0;
while(k<=m){
for(i=0;i<m-1;i++){
if(ls[i]>=ls[i+1]){
ls[i]=ls[i];
ls[i+1]=ls[i+1];
}else{
b=ls[i];
ls[i]=ls[i+1];
ls[i+1]=b;
c=xs[i];
xs[i]=xs[i+1];
xs[i+1]=c;
c=ys[i];
ys[i]=ys[i+1];
ys[i+1]=c;
c=zs[i];
zs[i]=zs[i+1];
zs[i+1]=c;
c=xz[i];
xz[i]=xz[i+1];
xz[i+1]=c;
c=yz[i];
yz[i]=yz[i+1];
yz[i+1]=c;
c=zz[i];
zz[i]=zz[i+1];
zz[i+1]=c;
}
}
k++;
}
for(i=0;i<m;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",xs[i],ys[i],zs[i],xz[i],yz[i],zz[i],ls[i]);
}
return 0;
}
|
64 | 31878 | int main(){
int shu[10][3],i,j,n,a;
double d[1000],e;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%d %d %d",&shu[i][0],&shu[i][1],&shu[i][2]);
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
d[10*i+j]=0;
}
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
a=(shu[i][0]-shu[j][0])*(shu[i][0]-shu[j][0])+(shu[i][1]-shu[j][1])*(shu[i][1]-shu[j][1])+(shu[i][2]-shu[j][2])*(shu[i][2]-shu[j][2]);
d[10*i+j]=sqrt(a);
}
}
while(1){
e=0;
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(d[10*i+j]>e){
e=d[10*i+j];
}
}
}
if(e==0){
break;
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(d[10*i+j]==e){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",shu[i][0],shu[i][1],shu[i][2],shu[j][0],shu[j][1],shu[j][2],e);
d[10*i+j]=0;
}}}
}
return 0;
} |
64 | 31879 | /*
* justexp.cpp
*
* Created on: 2011-11-18
* Author: dell
*/
int main()
{
int n,m,i,j,k,l;
cin>>n;
m=n*(n-1)/2;
int point[n][3];
for(i=0;i<n;i++)
cin>>point[i][0]>>point[i][1]>>point[i][2];
struct data
{
int point1[3];
int point2[3];
float len;
int mark1;
int mark2;
}distance[m],temp;
for(k=i=0;i<n-1;i++)
for(j=i+1;j<n;j++,k++)
{
distance[k].len=0;
for(l=0;l<3;l++)
{
distance[k].mark1=i;
distance[k].mark2=j;
distance[k].point1[l]=point[i][l];
distance[k].point2[l]=point[j][l];
distance[k].len+=(point[i][l]-point[j][l])*(point[i][l]-point[j][l]);
}
distance[k].len=sqrt(distance[k].len);
}
for(i=0;i<m-1;i++)
for(j=i+1;j<m;j++)
{
if(distance[i].len<distance[j].len)
{
temp=distance[i];
distance[i]=distance[j];
distance[j]=temp;
}
if(distance[i].len==distance[j].len)
{
if((distance[i].mark1>distance[j].mark1)||((distance[i].mark1==distance[j].mark1)&&(distance[i].mark2>distance[j].mark2)))
{
temp=distance[i];
distance[i]=distance[j];
distance[j]=temp;
}
}
}
for(i=0;i<m;i++)
{
cout<<'('<<distance[i].point1[0]<<','<<distance[i].point1[1]<<','<<distance[i].point1[2]<<')';
cout<<'-';
cout<<'('<<distance[i].point2[0]<<','<<distance[i].point2[1]<<','<<distance[i].point2[2]<<')';
printf("=%.2f\n",distance[i].len);
}
return 0;
} |
64 | 31880 |
struct zuobiao
{
int x ;
int y ;
int z ;
}s[10] ; //??xyz??????
double d[100] , temp ; //d??????????
int qian[100] , hou[100] , temp1 ; //qian hou ?????????????????????
int i , j , k = 0 ;
void dis(int , int) ;
void paixu() ;
int main()
{
int n ;
cin >> n ;
for (i = 0 ; i < n ; i++)
cin >> s[i].x >> s[i].y >> s[i].z ;
for (i = 0 ; i < n ; i++)
for (j = i + 1 ; j < n ; j++)
dis(i , j) ;
paixu() ;
for (i = 0 ; i < k ; i++)
{
cout << "(" << s[qian[i]].x << "," << s[qian[i]].y << "," << s[qian[i]].z << ")" << "-"
<< "(" << s[hou[i]].x << "," << s[hou[i]].y << "," << s[hou[i]].z << ")" << "=" ;
printf ("%.2f", d[i]) ;
cout << endl ;
}
return 0 ;
}
void dis(int a , int b)
{
int a1 , a2 , a3 ;
a1 = s[a].x - s[b].x ;
a2 = s[a].y - s[b].y ;
a3 = s[a].z - s[b].z ;
d[k] = sqrt(a1 * a1 + a2 * a2 + a3 * a3) ; //????
qian[k] = a ; //?k??????????
hou[k] = b ; //?k??????????
k++ ;
}
void paixu()
{
for (i = 0 ; i < k - 1 ; i++)
for (j = i + 1 ; j < k ; j++)
{
if (d[i] < d[j])
{
temp = d[i] ; //???????????qian hou????
d[i] = d[j] ;
d[j] = temp ;
temp1 = qian[i] ;
qian[i] = qian[j] ;
qian[j] = temp1 ;
temp1 = hou[i] ;
hou[i] = hou[j] ;
hou[j] = temp1 ;
}
else if (d[i] == d[j]) //???????qian hou??????????
if (qian[i] > qian[j] || (qian[i] == qian[j] && hou[i] > hou[j]))
{
temp = d[i] ;
d[i] = d[j] ;
d[j] = temp ;
temp1 = qian[i] ;
qian[i] = qian[j] ;
qian[j] = temp1 ;
temp1 = hou[i] ;
hou[i] = hou[j] ;
hou[j] = temp1 ;
}
}
} |
64 | 31881 |
struct point
{
int x;
int y;
int z;
};
struct dist
{
struct point *p1;
struct point *p2;
double l;
};
void sort(struct dist a[], int n)
{
int i,j;
struct dist t;
for(i=0;i<n-1;i++)
for(j=n;j>i;j--)
if(a[j].l>a[j-1].l)
{
t=a[j];a[j]=a[j-1];a[j-1]=t;
}
}
void main()
{
struct point p[10];
struct dist d[50];
int n,i,j,c=0;
scanf("%d",&n);
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[c].p1=&p[i];
d[c].p2=&p[j];
d[c].l=sqrt((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));
c++;
}
sort(d,c);
for(i=0;i<c;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\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].l);
}
|
64 | 31882 | int main()
{
int n,i,j=0,k=0,len,sum=0;
double di[100],l;
struct i{
int x,y,z;
}a[100],b[100],c[100],e;
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;i++)
{
for(j=i+1;j<n;j++)
{
di[k]=sqrt(1.0*(a[i].x-a[j].x)*(a[i].x-a[j].x)+1.0*(a[i].y-a[j].y)*(a[i].y-a[j].y)+1.0*(a[i].z-a[j].z)*(a[i].z-a[j].z));
b[k]=a[i];
c[k]=a[j];
k++;
}
}
for(i=1;i<=k;i++)
{
for(j=0;j<k-i;j++)
{
if(di[j]<di[j+1])
{
l=di[j];
di[j]=di[j+1];
di[j+1]=l;
e=b[j];
b[j]=b[j+1];
b[j+1]=e;
e=c[j];
c[j]=c[j+1];
c[j+1]=e;
}
}
}
for(i=0;i<k;i++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",b[i].x,b[i].y,b[i].z,c[i].x,c[i].y,c[i].z,di[i]);
}
return 0;
} |
64 | 31883 | int main()
{
struct position
{int x1;
int x2;
int x3;
}pos[10];
struct distance
{int x;
int y;
float distan;
}dis[60],temp;//x??????y??????distan???
int n,i,j,k;
cin>>n;
for(i=0;i<n;i++)
{cin>>pos[i].x1;
cin>>pos[i].x2;
cin>>pos[i].x3;
}//????
k=0;
for(i=0;i<n;i++)
{for(j=i+1;j<n;j++)
{dis[k].x=i;
dis[k].y=j;
dis[k].distan=sqrt((pos[i].x1-pos[j].x1)*(pos[i].x1-pos[j].x1)+(pos[i].x2-pos[j].x2)*(pos[i].x2-pos[j].x2)+(pos[i].x3-pos[j].x3)*(pos[i].x3-pos[j].x3));
k++;}//????????????x,y,?????
}
for(i=0;i<k;i++)
{for(j=0;j<k-1-i;j++)
{if(dis[j].distan<dis[j+1].distan)
{temp=dis[j];
dis[j]=dis[j+1];
dis[j+1]=temp;
}//??????????????
}
}
for(i=0;i<k;i++)
cout<<"("<<pos[dis[i].x].x1<<","<<pos[dis[i].x].x2<<","<<pos[dis[i].x].x3<<")-("<<pos[dis[i].y].x1<<","<<pos[dis[i].y].x2<<","<<pos[dis[i].y].x3<<")="<<fixed<<setprecision(2)<<dis[i].distan<<endl;//?????
return 0;
} |
64 | 31884 | int main()
struct d{
int x;
int y;
int z;};
{
struct d s[10];
int n,i,j,k=0,d;
int x,y,z,b[45],c[45];
double a[45],temp;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d",&s[i].x,&s[i].y,&s[i].z);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{ x=s[i].x-s[j].x;
y=s[i].y-s[j].y;
z=s[i].z-s[j].z;
a[k]=(x*x+y*y+z*z);
a[k]=sqrt(a[k]);
b[k]=i;
c[k]=j;
k++;
}
for(i=0;i<k;i++)
for(j=i+1;j<k;j++)
{if((a[i]<a[j])||((a[i]==a[j])&&(b[i]>b[j]))||((a[i]==a[j])&&(c[i]>c[j])))
{temp=a[j];
a[j]=a[i];
a[i]=temp;
temp=b[j];
b[j]=b[i];
b[i]=temp;
temp=c[j];
c[j]=c[i];
c[i]=temp;
}
}
for(i=0;i<k;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",s[b[i]].x,s[b[i]].y,s[b[i]].z,s[c[i]].x,s[c[i]].y,s[c[i]].z,a[i]);
scanf("%d",&d);
return 0;
} |
64 | 31885 | int main(){
int n,i,j;
scanf("%d",&n);
struct point
{
int x;
int y;
int z;
}
point[10];
for(i=0;i<n;i++){
scanf("%d%d%d",&point[i].x,&point[i].y,&point[i].z);
}
struct len
{
double s;
struct point p1,p2;
}
len[45];
int k=0;
for(j=0;j<n-1;j++){
for(i=j+1;i<n;i++){
len[k].s=sqrt((point[j].x-point[i].x)*(point[j].x-point[i].x)+(point[j].y-point[i].y)*(point[j].y-point[i].y)+(point[j].z-point[i].z)*(point[j].z-point[i].z));
len[k].p1.x=point[j].x;
len[k].p1.y=point[j].y;
len[k].p1.z=point[j].z;
len[k].p2.x=point[i].x;
len[k].p2.y=point[i].y;
len[k].p2.z=point[i].z;
k++;
}
}
double e;
int f,g,h,l,m,o;
for(j=1;j<=k;j++){
for(i=k-1;i>j-1;i--){
if(len[i-1].s<len[i].s){
e=len[i-1].s; f=len[i-1].p1.x; g=len[i-1].p2.x; h=len[i-1].p1.y; l=len[i-1].p2.y; m=len[i-1].p1.z; o=len[i-1].p2.z;
len[i-1].s=len[i].s; len[i-1].p1.x=len[i].p1.x; len[i-1].p2.x=len[i].p2.x; len[i-1].p1.y=len[i].p1.y; len[i-1].p2.y=len[i].p2.y; len[i-1].p1.z=len[i].p1.z;len[i-1].p2.z=len[i].p2.z;
len[i].s=e; len[i].p1.x=f; len[i].p2.x=g; len[i].p1.y=h; len[i].p2.y=l; len[i].p1.z=m; len[i].p2.z=o;
}
}
}
for(i=0;i<k;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",len[i].p1.x,len[i].p1.y,len[i].p1.z,len[i].p2.x,len[i].p2.y,len[i].p2.z,len[i].s);
}
return 0;
} |
64 | 31886 | int main(){
int pointnum,groupnum,i,j,k;
int point[10][3]={0};
cin>>pointnum;
groupnum=pointnum*(pointnum-1)/2;
for(i=0;i<pointnum;i++)
for(j=0;j<3;j++)
cin>>point[i][j];
int group[45][6]={0};
double result[45];
for(i=0;i<45;i++)
result[i]=0;
for(i=k=0;i<pointnum-1;i++)
for(j=i+1;j<pointnum;j++)
{
group[k][0]=point[i][0];
group[k][1]=point[i][1];
group[k][2]=point[i][2];
group[k][3]=point[j][0];
group[k][4]=point[j][1];
group[k][5]=point[j][2];
result[k]=sqrt((double)(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]));
k++;
}
double temp1;
int temp[6];
for(i=0;i<groupnum-1;i++)
for(j=0;j<groupnum-1-i;j++)
if(result[j]<result[j+1])
{
temp1=result[j];
result[j]=result[j+1];
result[j+1]=temp1;
for(k=0;k<6;k++)
temp[k]=group[j][k];
for(k=0;k<6;k++)
group[j][k]=group[j+1][k];
for(k=0;k<6;k++)
group[j+1][k]=temp[k];
}
for(i=0;i<groupnum;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",group[i][0],group[i][1],group[i][2],group[i][3],group[i][4],group[i][5],result[i]);
return 0;
}
|
64 | 31887 | unsigned int com[45][2];
float dis[45];
void swap(int i,int j)
{
unsigned int t_1[2];
float t_2;
t_2=dis[i];
dis[i]=dis[j];
dis[j]=t_2;
t_1[0]=com[i][0];
com[i][0]=com[j][0];
com[j][0]=t_1[0];
t_1[1]=com[i][1];
com[i][1]=com[j][1];
com[j][1]=t_1[1];
}
int main(void)
{
int i,j,n,s=0,coord[10][3];
for(i=0;i<45;i++)
dis[i]=0;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d %d %d ",&coord[i][0],&coord[i][1],&coord[i][2]);
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
com[s][0]=i;
com[s][1]=j;
dis[s]=sqrt(pow(coord[i][0]-coord[j][0],2)+pow(coord[i][1]-coord[j][1],2)+pow(coord[i][2]-coord[j][2],2));
s++;
}
for(i=s;i>0;i--)
for(j=0;j<i-1;j++)
if(dis[j]<dis[j+1])
swap(j,j+1);
for(i=0;i<s;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",coord[com[i][0]][0],coord[com[i][0]][1],coord[com[i][0]][2],coord[com[i][1]][0],coord[com[i][1]][1],coord[com[i][1]][2],dis[i]);
fclose(stdin);
return 0;
} |
64 | 31888 | struct point{
int a;
int b;
int c;
}p[10];
struct dis{
double d;
int i;
int j;
}di[60],x;
int main()
{int k,m,q,n,y;
double z;
scanf("%d",&n);
for(k=0;k<n;k++)
scanf("%d%d%d",&p[k].a,&p[k].b,&p[k].c);
k=0;
for(m=0;m<n;m++)
{q=m+1;
for(;q<n;q++)
{z=((double)p[q].a-(double)p[m].a)*((double)p[q].a-(double)p[m].a)+((double)p[q].b-(double)p[m].b)*((double)p[q].b-(double)p[m].b)+((double)p[q].c-(double)p[m].c)*((double)p[q].c-(double)p[m].c);
di[k].d=(double)sqrt((double)z);
di[k].i=m;
di[k].j=q;
k=k+1;}}
for(y=0;y<n*(n-1)/2-1;y++)
{for(k=0;k<n*(n-1)/2;k++){if(di[k+1].d>di[k].d)
{x=di[k];
di[k]=di[k+1];
di[k+1]=x;}}}
for(k=0;k<n*(n-1)/2;k++)
{printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",p[di[k].i].a,p[di[k].i].b,p[di[k].i].c,p[di[k].j].a,p[di[k].j].b,p[di[k].j].c,di[k].d);}
}
|
64 | 31889 | 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;
}
}
}
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 | 31890 | struct equal{
int i1,j1,k1;
int i2,j2,k2;
double distance;
};
void bubblesort(struct equal d[],int n);
struct node{
int i,j,k;
};
int main(){
int n,i;
scanf("%d",&n);
struct node aa[n];
for( i=0;i<n;i++)
{scanf("%d%d%d",&(aa[i].i),&(aa[i].j),&(aa[i].k));
}
struct equal equal1[1000];
int a,b,c,g,p=0;
for(a=0;a<n;a++){
for(b=a+1;b<n;b++){
equal1[p].i1=aa[a].i;equal1[p].j1=aa[a].j;equal1[p].k1=aa[a].k;
equal1[p].i2=aa[b].i;equal1[p].j2=aa[b].j;equal1[p].k2=aa[b].k;
equal1[p].distance=sqrt(pow((double)(equal1[p].i1-equal1[p].i2),2)+pow((double)(equal1[p].j1-equal1[p].j2),2)+pow((double)(equal1[p].k1-equal1[p].k2),2));
p++;
}
}
bubblesort(equal1,p);
for(g=0;g<p;g++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",equal1[g].i1,equal1[g].j1,equal1[g].k1,equal1[g].i2,equal1[g].j2,equal1[g].k2,equal1[g].distance);
}
return 0;
}
void bubblesort(struct equal d[],int n){
int i,j,m;double t;
for(i=0;i<n;i++){
for(j=n-1;j>i;j--){
if(d[j].distance>d[j-1].distance){
t=d[j].distance;d[j].distance=d[j-1].distance;d[j-1].distance=t;
m=d[j].i1;d[j].i1=d[j-1].i1;d[j-1].i1=m;
m=d[j].i2;d[j].i2=d[j-1].i2;d[j-1].i2=m;
m=d[j].j1;d[j].j1=d[j-1].j1;d[j-1].j1=m;
m=d[j].k1;d[j].k1=d[j-1].k1;d[j-1].k1=m;
m=d[j].j2;d[j].j2=d[j-1].j2;d[j-1].j2=m;
m=d[j].k2;d[j].k2=d[j-1].k2;d[j-1].k2=m;
}
}
}
}
|
64 | 31891 | int main()
{
int syz[10][3];
int i,j,n,d,y,k,r=0;
double result,sy[45];
scanf("%d",&n);
for(i=0;i<n;i++)
{
for(j=0;j<3;j++)
{
scanf("%d",&syz[i][j]);
}
}
for(i=0;i<n-1;i++)
{
for(k=i+1;k<n;k++)
{
result=sqrt(1.0*(syz[k][0]-syz[i][0])*(syz[k][0]-syz[i][0])+1.0*(syz[k][1]-syz[i][1])*(syz[k][1]-syz[i][1])+1.0*(syz[k][2]-syz[i][2])*(syz[k][2]-syz[i][2]));
sy[r]=result;
r++;
}
}
/*
?????sy???double???????e????double??
int e;
*/
double e;
for(d=1;d<=n*(n-1)/2;d++)
{
for(y=0;y<n*(n-1)/2-d;y++)
{
if(sy[y]<=sy[y+1])
{
e=sy[y];
sy[y]=sy[y+1];
sy[y+1]=e;
}
}
}
/*
for(i=1,k=1;j<n*(n-1)/2;i++)
??????????i??????
*/
for(i=1,k=1;i<n*(n-1)/2;i++)
{
for(j=0;j<k;j++)
{
/*
????????==?????????????
if(sy[i]==sy[j])
*/
if(fabs(sy[i]-sy[j]) < 0.000001)
{
break;
}
}
if(j==k)
{
sy[k]=sy[i];
k++;
}
}
/*
???k????????????????
for(y=0;y<k;y++)
*/
int kk = k;
for(y=0;y<kk;y++)
{
for(i=0;i<n-1;i++)
{
for(k=i+1;k<n;k++)
{
/*
????????????????????
if(sqrt(1.0*(syz[k][0]-syz[i][0])*(syz[k][0]-syz[i][0])+1.0*(syz[k][1]-syz[i][1])*(syz[k][1]-syz[i][1])+1.0*(syz[k][2]-syz[i][2])*(syz[k][2]-syz[i][2]))==sy[y])
*/
if(fabs(sqrt(1.0*(syz[k][0]-syz[i][0])*(syz[k][0]-syz[i][0])+1.0*(syz[k][1]-syz[i][1])*(syz[k][1]-syz[i][1])+1.0*(syz[k][2]-syz[i][2])*(syz[k][2]-syz[i][2]))-sy[y])<0.00001)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",syz[i][0],syz[i][1],syz[i][2],syz[k][0],syz[k][1],syz[k][2],sy[y]);
}
}
}
}
return 0;
}
|
64 | 31892 | int main()
{
int n,i,j,k,p=0,q,r,e;
cin>>n;
float s,m1,m2,m3,m4,m5,m6,f,g;
float l[50];//??
float x[10];
float y[10];
float z[10];//??
float a1[50][2];
float a2[50][2];
float a3[50][2];
float b1[50][2];
float b2[50][2];
float b3[50][2];//????????
for(i=0;i<n;i++)
cin>>x[i]>>y[i]>>z[i];//??
for(j=0;j<n-1;j++)
{
for(k=j+1;k<n;k++)
{
l[p]=sqrt((x[j]-x[k])*(x[j]-x[k])+(y[j]-y[k])*(y[j]-y[k])+(z[j]-z[k])*(z[j]-z[k]));
a1[p][0]=x[j];a2[p][0]=y[j];a3[p][0]=z[j];b1[p][0]=x[k];b2[p][0]=y[k];b3[p][0]=z[k];
a1[p][1]=j;a2[p][1]=j;a3[p][1]=j;b1[p][1]=k;b2[p][1]=k;b3[p][1]=k;
p=p+1;
}//????????
}
for(q=0;q<p-1;q++)
{
for(r=q+1;r<p;r++)
{
if(l[q]<l[r])
{
s=l[q];
l[q]=l[r];
l[r]=s;
f=a1[q][1];
a1[q][1]=a1[r][1];
a1[r][1]=f;
g=b1[q][1];
b1[q][1]=b1[r][1];
b1[r][1]=g;
m1=a1[q][0];
a1[q][0]=a1[r][0];
a1[r][0]=m1;
m2=a2[q][0];
a2[q][0]=a2[r][0];
a2[r][0]=m2;
m3=a3[q][0];
a3[q][0]=a3[r][0];
a3[r][0]=m3;
m4=b1[q][0];
b1[q][0]=b1[r][0];
b1[r][0]=m4;
m5=b2[q][0];
b2[q][0]=b2[r][0];
b2[r][0]=m5;
m6=b3[q][0];
b3[q][0]=b3[r][0];
b3[r][0]=m6;
}//??????
if(l[q]==l[r]&&a1[q][1]>=a1[r][1])
{
f=a1[q][1];
a1[q][1]=a1[r][1];
a1[r][1]=f;
g=b1[q][1];
b1[q][1]=b1[r][1];
b1[r][1]=g;
m1=a1[q][0];
m1=a1[q][0];
a1[q][0]=a1[r][0];
a1[r][0]=m1;
m2=a2[q][0];
a2[q][0]=a2[r][0];
a2[r][0]=m2;
m3=a3[q][0];
a3[q][0]=a3[r][0];
a3[r][0]=m3;
m4=b1[q][0];
b1[q][0]=b1[r][0];
b1[r][0]=m4;
m5=b2[q][0];
b2[q][0]=b2[r][0];
b2[r][0]=m5;
m6=b3[q][0];
b3[q][0]=b3[r][0];
b3[r][0]=m6;
}
if(l[q]==l[r]&&b1[q][1]>=b1[r][1])
{
f=a1[q][1];
a1[q][1]=a1[r][1];
a1[r][1]=f;
g=b1[q][1];
b1[q][1]=b1[r][1];
b1[r][1]=g;
m1=a1[q][0];
m1=a1[q][0];
a1[q][0]=a1[r][0];
a1[r][0]=m1;
m2=a2[q][0];
a2[q][0]=a2[r][0];
a2[r][0]=m2;
m3=a3[q][0];
a3[q][0]=a3[r][0];
a3[r][0]=m3;
m4=b1[q][0];
b1[q][0]=b1[r][0];
b1[r][0]=m4;
m5=b2[q][0];
b2[q][0]=b2[r][0];
b2[r][0]=m5;
m6=b3[q][0];
b3[q][0]=b3[r][0];
b3[r][0]=m6;}
//???????????
}
}
for(e=0;e<p;e++)
{
cout<<"("<<a1[e][0]<<","<<a2[e][0]<<","<<a3[e][0]<<")-("<<b1[e][0]<<","<<b2[e][0]<<","<<b3[e][0]<<")=";
printf("%.2f\n",l[e]);//??
}
getchar();
getchar();
return 0;
} |
64 | 31893 | int main()
{
int n, i, j;
int location[11][3];
int (*p)[3];
cin >> n;
for ( i = 1; i <= n; i++ )
{
for ( j = 0; j < 3; j++ )
{
cin >> location[i][j];
}
}
struct team
{
int a1;
int a2;
double distance;
} zu[45], t;
int k = 0;
p = location;
for ( i = 1; i < n; i++ )
{
for ( j = i + 1; j <= n; j++ )
{
zu[k].a1 = i;
zu[k].a2 = j;
int x, y, z;
x = location[i][0] - location[j][0];
y = location[i][1] - location[j][1];
z = location[i][2] - location[j][2];
zu[k].distance = sqrt ( x * x + y * y + z * z );
k++;
}
}
for ( i = 0; i < k - 1; i++ )
{
for ( j = i + 1; j < k; j++ )
{
if ( zu[i].distance - zu[j].distance < -0.01 )
{
t = zu[i];
zu[i] = zu[j];
zu[j] = t;
}
else if ( fabs( zu[i].distance - zu[j].distance ) < 0.01 )
{
if ( zu[i].a1 > zu[j].a1 )
{
t = zu[i];
zu[i] = zu[j];
zu[j] = t;
}
else if ( zu[i].a1 == zu[j].a1 )
{
if ( zu[i].a2 > zu[j].a2 )
{
t = zu[i];
zu[i] = zu[j];
zu[j] = t;
}
}
}
}
}
for ( i = 0; i < k; i++ )
{
cout << "(" << location[zu[i].a1][0] << "," << location[zu[i].a1][1] << "," << location[zu[i].a1][2] << ")-("
<< location[zu[i].a2][0] << "," << location[zu[i].a2][1] << "," << location[zu[i].a2][2] << ")="
<< fixed << setprecision(2) << zu[i].distance << endl;
}
return 0;
} |
64 | 31894 | int main()
{
int a[11][3],i,j,n,k,c[46],d[46],f;
double b[46],t;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>a[i][0]>>a[i][1]>>a[i][2];
}
k=1;
for(i=1;i<n;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++;
}
f=n*(n-1)/2;
for(i=1;i<f;i++)
for(j=f-1;j>=i;j--)
{
if(b[j]<b[j+1])
{
t=b[j];
b[j]=b[j+1];
b[j+1]=t;
t=c[j];
c[j]=c[j+1];
c[j+1]=t;
t=d[j];
d[j]=d[j+1];
d[j+1]=t;
}
}
for(i=1;i<f;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]<<")="<<fixed<<setprecision(2)<<b[i]<<endl;
cout<<'('<<a[c[f]][0]<<','<<a[c[f]][1]<<','<<a[c[f]][2]<<")-("<<a[d[f]][0]<<','<<a[d[f]][1]<<','<<a[d[f]][2]<<")="<<fixed<<setprecision(2)<<b[f];
return 0;
}
|
64 | 31895 |
float ju(int *p,int *q){
float s=0;
int i=0;
for(i=0;i<3;i++){
s=(*(p)-*(q)) * (*(p)-*(q))+s;
p++,q++;}
return s=sqrt(s);}
int main()
{
struct s{
int i;
int j;
float l;
}
s[100],t;
int n,a[11][3]={0},i,j,p=0,k;
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;i++){
for(j=i+1;j<n;j++){
s[p].i=i,s[p].j=j,s[p].l=ju(a[i],a[j]),p++;}
}
for(i=0;i<p;i++){
for(j=i+1;j<p;j++){
if(s[i].l<s[j].l)t=s[i],s[i]=s[j],s[j]=t;
else if(s[i].l==s[j].l){
if(s[i].i>s[j].i)t=s[i],s[i]=s[j],s[j]=t;
else if(s[i].i==s[j].i&&s[i].j>s[j].j)t=s[i],s[i]=s[j],s[j]=t;
}
}
}
for(i=0;i<p;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[s[i].i][0],a[s[i].i][1],a[s[i].i][2],a[s[i].j][0],a[s[i].j][1],a[s[i].j][2],s[i].l);}
} |
64 | 31896 | int main()
{
int n,i,j,r,k=0,a[10][3],c[45],d[45];
double b[45];
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;i++)
{
for(j=i+1;j<n;j++)
{
b[k]=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][0]-a[j][0])*(a[i][0]-a[j][0]));
c[k]=i;
d[k]=j;
k++;
}
}
for(i=1;i<n*(n-1)/2;i++)
{
double tmp=b[i];
for(j=i-1;j>=0;j--)
{
if(tmp>b[j])
{
b[j+1]=b[j];
b[j]=tmp;
r=c[j];
c[j]=c[j+1];
c[j+1]=r;
r=d[j];
d[j]=d[j+1];
d[j+1]=r;
}
else
{
b[j+1]=tmp;
break;
}
}
}
for(k=0;k<n*(n-1)/2;k++)
{
printf("(%d,%d,%d)-(%d,%d,%d)=%.2f\n",a[c[k]][0],a[c[k]][1],a[c[k]][2],a[d[k]][0],a[d[k]][1],a[d[k]][2],b[k]);
}
return 0;
}
|
64 | 31897 | int a[1000];
int b[1000];
int c[1000];
float sum[1000];
float dis[1000];
int x[1000];
int y[1000];
int main(){
int n=0,d=0,i=0,r=0,l=0,f=0,k=0;
float e=0;
for(i=0;i<n;i++){
sum[i]=0;
dis[i]=0;
}
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(r=i+1;r<n;r++){
sum[l]=(a[i]-a[r])*(a[i]-a[r])+(b[i]-b[r])*(b[i]-b[r])+(c[i]-c[r])*(c[i]-c[r]);
dis[l]=sqrt(sum[l]);
x[l]=i;
y[l]=r;
l++;}
}
for(f=0;f<n*(n-1)/2;f++){
for(d=0;d<n*(n-1)/2-1; d++){
if(dis[d]<dis[d+1]){
e=dis[d];
dis[d]=dis[d+1];
dis[d+1]=e;
k=x[d];
x[d]=x[d+1];
x[d+1]=k;
k=y[d];
y[d]=y[d+1];
y[d+1]=k;
}
}
}
for(f=0;f<n*(n-1)/2;f++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[x[f]],b[x[f]],c[x[f]],a[y[f]],b[y[f]],c[y[f]],dis[f]);}
return 0;
} |
64 | 31898 | int main( ){
int i,n,k,t,q=0;
int x[10],y[10],z[10],a[50],b[50];
double s[50],ss[50],j;
scanf("%d\n",&n);
for(i=0;i<n;i++){
scanf("%d %d %d ",&(x[i]),&(y[i]),&(z[i]));
}
for(t=0;t<n-1;t++){
for(i=t+1;i<n;i++){
s[q]=1.0*(x[t]-x[i])*(x[t]-x[i])+1.0*(y[t]-y[i])*(y[t]-y[i])+1.0*(z[t]-z[i])*(z[t]-z[i]);
ss[q]=sqrt(s[q]);
a[q]=t;
b[q]=i;
q++;
}
}
for(k=1;k<=q;k++){
for(i=0;i<q-k;i++){
if(ss[i]<ss[i+1]){
j=ss[i+1];
ss[i+1]=ss[i];
ss[i]=j;
j=a[i+1];
a[i+1]=a[i];
a[i]=j;
j=b[i+1];
b[i+1]=b[i];
b[i]=j;
}
}
}
for(i=0;i<q;i++){
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",x[a[i]],y[a[i]],z[a[i]],x[b[i]],y[b[i]],z[b[i]],ss[i]);
}
return 0;
}
|
64 | 31899 | void main()
{
int n,a[10][3],i,j,x[100][2],k=0,s;
double d[100],t;
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++)
{
d[k]=sqrt((double)((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])));
x[k][0]=i;x[k][1]=j;
k++;
}
for(i=0;i<k;i++)
for(j=0;j<k-i-1;j++)
if(d[j]<d[j+1]) {t=d[j];d[j]=d[j+1];d[j+1]=t;s=x[j][0];x[j][0]=x[j+1][0];x[j+1][0]=s;s=x[j][1];x[j][1]=x[j+1][1];x[j+1][1]=s;}
for(i=0;i<n*(n-1)/2;i++)
printf("(%d,%d,%d)-(%d,%d,%d)=%.2lf\n",a[x[i][0]][0],a[x[i][0]][1],a[x[i][0]][2],a[x[i][1]][0],a[x[i][1]][1],a[x[i][1]][2],d[i]);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.