两数组最短距离 acm

最新推荐文章于 2023-12-04 13:54:53 发布

星zai

最新推荐文章于 2023-12-04 13:54:53 发布

阅读量2.1k

点赞数

分类专栏： OpenCV 文章标签： OpenCV周末提高

本文链接：https://blog.csdn.net/STELLAR0/article/details/8740530

版权

OpenCV 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

该博客讨论了如何计算两个已按升序排列的数组之间的最短距离，即找到两个数组中差值绝对值最小的元素。输入包括两个数组的长度和元素，目标是输出最短距离。博主提出了一个时间复杂度为O(n+m)的算法挑战。

摘要由CSDN通过智能技术生成

转载自：http://blog.csdn.net/onezeros

两数组最短距离

Time Limit(Common/Java):1000MS/10000MS Memory Limit:65536KByte
Total Submit: 86 Accepted: 41

Description

已知元素从小到大排列的两个数组x[]和y[]，请写出一个程序算出两个数组彼此之间差的绝对值中最小的一个，这叫做数组的距离。

Input

第一行为两个整数m, n(1≤m, n≤1000)，分别代表数组f[], g[]的长度。
第二行有m个元素，为数组f[]。
第三行有n个元素，为数组g[]。

Output

数组的最短距离

Sample Input

5 5
1 2 3 4 5
6 7 8 9 10

Sample Output

Hint

你能想出O(n+m)的算法吗?^_^

我的答案：

int miniDistance(int* a,int* b,int aLen,int bLen)
{    
    int aPos,int bPos;
    int miniDistance;
    int aPointer=0;
    int bPointer=0;
    int dist=pow(2,sizeof(int)-1)-1;//big enough
    //at any time ,increase pointer of the small number side,
    //because increase pointer of big number side only can increase the distance
    //which is not helpful to our goal
    while(aPointer<aLen&&bPointer<bLen){
        int tmp=0;
        if(*(a+aPointer)<*(b+bPointer)){        
            tmp=*(b+bPointer)-*(a+aPointer);   
            if(tmp<dist){
                dist=tmp;
                aPos=aPointer;
                bPos=bPointer;
            }
            aPointer++;
        }else if(*(a+aPointer)>*(b+bPointer)){
            tmp=*(a+aPointer)-*(b+bPointer);
            if(tmp<dist){
                dist=tmp;
                aPos=aPointer;
                bPos=bPointer;
            }
            bPointer++;
        }else{//equal
            aPos=aPointer;
            bPos=bPointer;
            miniDistance=0;
            return;
        }
    }
    //shortest distance found for the moment
    miniDistance=dist;
    
    //situation(aPointer==aLen&&bPointer==bLen)&&
    //situation(aPointer<aLen&&bPointer<bLen) do not exist
    if(aPointer==aLen){
        while(*(a+aPointer-1)>*(b+bPointer)&&bPointer<bLen){
            bPointer++;
        }
        if(bPointer==bLen){            
            bPos=bPointer;
            miniDistance=*(a+aPointer-1)-*(b+bPointer);
        }else{
            int latter=*(b+bPointer)-*(a+aPointer-1);
            int former=*(a+aPointer-1)-*(b+bPointer-1);
            if(latter<former&&latter<dist){
                bPos=bPointer;
                miniDistance=latter;
            }else if(former<dist){
                bPos=bPointer-1;
                miniDistance=former;
            }
        }        
    }else{//bPointer==bLen
        while(*(a+aPointer)<*(b+bPointer-1)&&aPointer<aLen){
            aPointer++;
        }
        if(aPointer==aLen){            
            aPos=aPointer;
            miniDistance=*(b+bPointer)-*(a+aPointer-1);
        }else{            
            int latter=*(a+aPointer)-*(b+bPointer-1);
            int former=*(b+bPointer-1)-*(a+aPointer-1);
            if(latter<former&&latter<dist){
                aPos=aPointer;
                miniDistance=latter;
            }else if(former<dist){
                aPos=aPointer-1;
                miniDistance=former;
            }
        }
    }
    return miniDistance;
}