常见距离计算小结

常见距离计算小结
小结啥啊很久之前写的不过现在忘了来复习一下不过这种题写暴力也是很简单啊但是分少啊qwq

1 欧式距离也就是我们常说的欧几里得距离也就是

$z=sqrt{x^2+y^2}$ 然后也就是对应到平面上求两个点的距离的时候用横纵坐标之差然后开根号即可

就是现在在班里学习文化课的同学数学课本上的计算公式很好理解不过这种一般用于题目给定你是这样计算距离

至于优化我没见过什么比较大的优化吧或许是我写题少

那么存在一个例题就是奶酪qwq 奶酪好啊题目

这里定义了一下三维平面的计算公式不过是多了一个维度z 此时距离我们按照题目给定的计算方法

显然我们发现这是一个并查集维护连通性的问题那么怎么联通一定是两个球体中心之间的距离小于等于给定的 2*r 才能相切或者相交

由于我们发现开根号是此类问题的不好处理的地方那么我们不妨考虑此时两边平方即可
```
#include<bits/stdc++.h>
typedef long long ll;
const ll N=1100;
ll T,n,h,r,x[N],y[N],z[N],father[N],d[N],u[N];
template<typename T>inline void read(T &x)
{
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch))  {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
}
inline long long dis(ll i,ll j) {
    return (ll)(x[i]-x[j])*(x[i]-x[j])+(ll)(y[i]-y[j])*(y[i]-y[j])+(ll)(z[i]-z[j])*(z[i]-z[j]); 
}
ll fa[N + 5];
ll find(ll x) {
    return fa[x]==x?x:fa[x]=find(fa[x]);
}
inline void Union(ll x, ll y) {
    fa[find(x)]=find(y);
}

signed main() {
    read(T);
    while(T--) {
        read(n);read(h);read(r);
        memset(x,0,sizeof(x));
        memset(y,0,sizeof(y));
        memset(z,0,sizeof(z));
        memset(u,0,sizeof(u));
        memset(d,0,sizeof(d));
        for(ll i=1;i<=n;++i) fa[i]=i; 
        for(ll i=1;i<=n;++i) read(x[i]), read(y[i]), read(z[i]);
        for(ll i=1;i<=n;++i)
            for(ll j=1;j<i;++j)
                if(dis(i,j)<=(ll)4*r*r)
                    Union(i,j);
        bool flag=0;
        for(ll i=1;i<=n;++i) {
            if(z[i]-r<=0) d[find(i)]=1;
            if(z[i]+r>=h) u[find(i)]=1;
        }
        for(int i=1;i<=n;++i)
        {
            if(d[i]&&u[i])flag=1;
            if(flag)break;
        }
        puts(flag ? "Yes" : "No");
    }
    return 0;
}
```
然后就要提到我们的曼哈顿距离了

定义曼哈顿距离是

在二维空间内，两个点之间的曼哈顿距离为它们横坐标之差的绝对值与纵坐标之差的绝对值之和。

设点 $A($x_1$,$y_1$) B($x_2$,$y_2$)，则 A,B 之间的曼哈顿距离用公式可以表示为：$

$x_1 - x_2 ight | + left | y_1 - y_2 ight |$$

那么我们显然发现一个东西这玩意都是非负的并且自己到自己是0呗（废话

并且我们发现三个点之间的距离存在一个三角不等式

在国际象棋棋盘上，车从一个格子走到另一个格子的最短距离就是曼哈顿距离。

若网格图上的一个点只能到上下左右

让你求若干点对求曼哈顿距离最大的点对 n是5e4的

根据题意，对于式子$d(A,B) = left | x_1 - x_2 ight | + left | y_1 - y_2 ight |$

第一种情况：

第四种情况

那么他们之间的距离就是 x2-x1+y2-y1=（x2+y2）- (x1+y1)

那么我们不免发现距离

要么之和 x+y 有关要么只和 x-y 有关那么答案就是

max{max{xi+yi}−min{xi+yi},max{xi−yi}−min{xi−yi}}
```
#include<bits/stdc++.h>
using namespace std;
int n,x,y;
template<typename T>inline void read(T &x)
{
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch))  {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
}
const int N=(1<<30);
int max1=-N,max2=-N,min1=N,min2=N;
int main() {
    read(n);
    for(int i=1;i<=n;i++) {
        read(x); read(y);
        max1=max(max1,x+y); min1=min(min1,x+y);
        max2=max(max2,x-y); min2=min(min2,x-y);
    }
    cout<<max((max1-min1),(max2-min2));
    return 0;
}
```
要理解一下这个转化

接下来介绍一下切比雪夫距离

在二维空间内，两个点之间的切比雪夫距离为它们横坐标之差的绝对值与纵坐标之差的绝对值的最大值。

设点

$x_1 - x_2 ight | , left | y_1 - y_2 ight | )$$

切比雪夫距离的一般模型：

在国际象棋棋盘上，国王与王后从一个格子走到另一个格子的最短距离都是切比雪夫距离。

若网格图上的一个点只能到周围

二维曼哈顿距离与切比雪夫距离的相互转化

我这里简单证明一下吧

或者我还看过一个比较优秀的证明

假设

我们很容易发现，这就是

所以将每一个点

同理

而这就是 $displaystyle left( frac{x_1+y_1}{2},frac{x_1-y_1}{2} ight),left( frac{x_2+y_2}{2},frac{x_2-y_2}{2} ight)$

所以将每一个点 $displaystyle left( frac{x+y}{2},frac{x-y}{2} ight)$

也就是两个东西可以相互转化那么对于有些题目我们就要注意到怎么计算简单了

在观察上面那个问题求曼哈顿距离最大的点对我们考虑转化成切比雪夫距离那么就是（x，y）转化成（x+y,x-y）

所求的答案就变为 max{max{∣xi−xj∣,∣yi−yj∣}}

在所有点中，横坐标之差的最大值和纵坐标之差的最大值都有可能成为答案，

所以我们只需要预处理出

我们发现直接切比雪夫计算是比较麻烦的因为处理max 都是至少n^2 的

所以我们考虑转化为曼哈顿距离将每一个点

考虑这个时候我们进行的就是若干求和考虑都是绝对值那么存在大小关系

所以我们不妨考虑排序！

枚举所选的点

如果某个点

这样就可以分两种情况讨论了。

设前

$lower_bound 就是一个不错的选择呢$
```
#include<bits/stdc++.h>
using namespace std;
#define N 100100 
typedef long long ll;
ll n,a,b,p[N],x[N],y[N],q[N],prex[N],prey[N],ans=0x7fffffffffffffff;
template<typename T>inline void read(T &x)
{
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch))  {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
}
int main() {
    read(n);
    for(int i=1;i<=n;i++) {
        read(a); read(b);
        x[i]=p[i]=a+b; y[i]=q[i]=a-b;
    }
    sort(p+1,p+n+1); sort(q+1,q+n+1);
    for(int i=1;i<=n;i++) {
        prex[i]=prex[i-1]+p[i]; prey[i]=prey[i-1]+q[i];
    }
    for(int i=1;i<=n;i++) {
        int posx=lower_bound(p+1,p+n+1,x[i])-p;
        int posy=lower_bound(q+1,q+n+1,y[i])-q;
        ll sumx=0,sumy=0;
        sumx=(ll)posx*x[i]-prex[posx]+prex[n]-prex[posx]-(ll)(n-posx)*x[i];
        sumy=(ll)posy*y[i]-prey[posy]+prey[n]-prey[posy]-(ll)(n-posy)*y[i];
        ans=min(ans,sumx+sumy);
    }
    cout<<(ans/2)<<endl;
    return 0;
}
```
当然这里我也有一个手写二分的代码有同学抬杠stl慢

Q次询问每次给出一个点(s,t) 求所有点到它的切比雪夫距离
```
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
template<typename T>inline void read(T &x) {
    x=0;T f=1,ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch))  {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    x*=f;
}
const int N=1010000;
ll T,n,w,s,t,a,b,X[N],Y[N],p[N],q[N],prex[N],prey[N]; 
inline int find(int x)
{
    if(p[n]<=x)return n;
    if(p[1]>=x)return 0;
    int l=1,r=n;
    while(l+1<r)
    {
        int mid=(l+r)>>1;
        if(p[mid]>=x)r=mid;
        else l=mid;
    }
    if(p[r]<=x)return r;
    return l;
}
inline int calc(int x)
{
    if(q[n]<=x)return n;
    if(q[1]>=x)return 0;
    int l=1,r=n;
    while(l+1<r)
    {
        int mid=(l+r)>>1;
        if(q[mid]>=x)r=mid;
        else l=mid;
    }
    if(q[r]<=x)return r;
    return l;
}
int main() {
    read(T);
    while(T--) {
        read(n); read(w);
        for(int i=1;i<=n;i++) {
            read(a); read(b);
            X[i]=p[i]=a+b,Y[i]=q[i]=a-b;
        }
        sort(p+1,p+n+1); sort(q+1,q+n+1);
        for(int i=1;i<=n;i++) {
            prex[i]=prex[i-1]+p[i]; prey[i]=prey[i-1]+q[i];
        }
        for(int i=1;i<=w;i++) {
            read(s); read(t);
            ll xx=s+t,yy=s-t;
            int posx=find(xx);
            int posy=calc(yy);
            ll sumx=0,sumy=0;
            //cout<<posx<<' '<<posy<<endl;
            sumx=(ll)posx*xx-prex[posx]+prex[n]-prex[posx]-(ll)(n-posx)*xx;
            sumy=(ll)posy*yy-prey[posy]+prey[n]-prey[posy]-(ll)(n-posy)*yy;
            printf("%lld
",(sumx+sumy)/2);
        }
    }
    return 0;
} 
```
相关阅读:
tcl基本语法
 linux hostid与lmhostid
linux下uptime命令
 介绍一下 WebApplicationContext？
Spring 由哪些模块组成?
怎样开启注解装配？
解释不同方式的自动装配？
@Qualifier 注解有什么用？
解释 Spring 框架中 bean 的生命周期？
如何在 spring 中启动注解装配？
原文地址：https://www.cnblogs.com/Tyouchie/p/11769313.html

常见距离计算 小结

常见距离计算小结