「分而治之」化大为小

/*************************************************************************
	> File Name: MaximumMinimum.cpp
	> Author: Shaojie Kang
	> Mail: kangshaojie@ict.ac.cn 
	> Created Time: 2015年09月10日 星期四 16时43分54秒 
    > Problem:
        寻找数组中的最大值和最小值
 ************************************************************************/

#include<iostream>
#include<vector>
using namespace std;

// Solution 1: O(2*n)
vector<int> GetMaxMin(const vector<int> &nums)
{
    vector<int> result;
    int size = nums.size();
    if(size == 0) return result;

    int max = nums[0];
    int min = nums[0];
    for(int i = 1; i < size; ++i)
    {
        if(nums[i] < min) 
            min = nums[i];
        if(nums[i] > max)
            max = nums[i];
    }
    result.push_back(min);
    result.push_back(max);
    return result;
}

// Solution 2: Divide and conquer
struct minmax 
{
    int min, max;
    minmax(){}
    minmax(int x, int y): min(x), max(y){}
};

minmax GetMaxMinCore(vector<int> &nums, int begin, int end)
{
    minmax result;
    if(begin == end)
    {
        result.min = nums[begin];
        result.max = nums[begin];
        return result;
    }
    int middle = (begin & end) + ((begin ^ end) >> 1);
    minmax left = GetMaxMinCore(nums, begin, middle);
    minmax right = GetMaxMinCore(nums, middle + 1, end);   
    result.min = (left.min <= right.min ? left.min : right.min);
    result.max = (left.max >= right.max ? left.max : right.max);
    return result;
}

void GetMaxMin2(vector<int> &nums)
{
    minmax result = GetMaxMinCore(nums, 0, nums.size()-1);
    cout<<"Min:"<<result.min<<",Max:"<<result.max<<endl;
}

int main()
{
    int arr[] = {
        2, 1, 8, 4, 6, 3, 7
    };
    vector<int> nums(arr, arr + sizeof(arr)/sizeof(int));
//    vector<int> result = GetMaxMin(nums);
//    if(!result.empty())
//        cout<<"Min:"<<result[0]<<",Max:"<<result[1]<<endl;
    GetMaxMin2(nums);
    return 0;
}

<pre name="code" class="cpp">/*************************************************************************
	> File Name: TheNearestPointPair.cpp
	> Author: Shaojie Kang
	> Mail: kangshaojie@ict.ac.cn 
	> Created Time: 2015年09月10日 星期四 19时29分23秒 
    > Problem:
        寻找最近点对
 ************************************************************************/

#include<iostream>
#include<vector>
#include<cmath>
#include<algorithm>
using namespace std;

const double MAX = 999.0;
struct point 
{
    double x, y;
    point(){}
    point(double a, double b): x(a), y(b){}
};

double GetDistance(const point &p1, const point &p2)
{
    double square = pow(p1.x-p2.x, 2) + pow(p1.y-p2.y, 2);
    return sqrt(square);
}

bool compareX(const point &p1, const point &p2)
{
    return p1.x <= p2.x;
}

bool compareY(const point &p1, const point &p2)
{
    return p1.y <= p2.y;
}

double GetNearestPairCore(vector<point> &points, int begin, int end)
{
    if(begin == end) return MAX;
    if(begin + 1 == end) 
        return GetDistance(points[begin], points[end]);

    int middle = (begin & end) + ((begin ^ end) >> 1);
    // 分治法
    double leftDistance = GetNearestPairCore(points, begin, middle); // 左半步最短距离
    double rightDistance = GetNearestPairCore(points, middle + 1, end); // 右半步最短距离
    double distance = min(leftDistance, rightDistance);
    double divisionX = (points[middle].x + points[middle + 1].x)/2;
    double leftBound = divisionX - distance; // 左边界
    double rightBound = divisionX + distance; // 右边界

    vector<point> vec;
    for(int i = middle; points[i].x >= leftBound; --i)
        vec.push_back(points[i]);
    for(int i = middle + 1; points[i].x <= rightBound; ++i)
        vec.push_back(points[i]);
    sort(vec.begin(), vec.end(), compareY);

    // x = [leftBound, rightBound], |distance|区域内
    for(int i = 0; i < vec.size(); ++i)
    {
        int j = i - 1;
        while(j >=0 && j >= i-7)
        {
            double temp = GetDistance(vec[i], vec[j]);
            distance = min(distance, temp);
            j--;
        }
        j = i + 1;
        while(j < vec.size() && j <= i + 7)
        {
            double temp = GetDistance(vec[i], vec[j]);
            distance = min(distance, temp);
            j++;
        }
    }
    return distance;
}

double GetNearestDistance(vector<point> points)
{
    double distance; 
    distance = GetNearestPairCore(points, 0 , points.size()-1);
    return distance;
}

int main()
{
    point arr[] =  {
        point(1, 0), point(5, 0), point(2, 0), point(4.5, 0)
    };
    vector<point> points(arr, arr + sizeof(arr)/sizeof(point));
    sort(points.begin(), points.end(), compareX);
    cout<<GetNearestDistance(points)<<endl;
    
    return 0;
}