【算法学习】快包算法

#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <math.h>

坐标数据结构：
typedef struct
{
	float x;
	float y;
}Point;
typedef bool(*Func)(Point, Point, Point);

判断点test是否在a,b组成的直线的上方：
bool Upstair(Point a, Point b, Point test)
{
	double k, d;
	if (fabs(a.x - test.x) < 0.000001 && fabs(a.y - test.y) < 0.000001
		|| fabs(b.x - test.x) < 0.000001 && fabs(b.y - test.y) < 0.000001)
		return false;
	/* 此时test点肯定不符合结果（联想在main函数寻找a,b点时的要求） */
	if (fabs(b.x - a.x) < 0.000001)
		return false;
	k = (b.y - a.y) / (b.x - a.x);
	d = a.y - k * a.x;
	double ret = k*test.x - test.y + d;
	if (ret < -0.000001)	//点在上方
		return true;
	else   //点在线上 和 点在线的下方 
		return false;
}
判断点test是否在a,b组成的直线的下方：
bool Downstair(Point a, Point b, Point test)
{
	double k, d;
	if (fabs(a.x - test.x) < 0.000001 && fabs(a.y - test.y) < 0.000001
		|| fabs(b.x - test.x) < 0.000001 && fabs(b.y - test.y) < 0.000001)
		return false;
		/* 此时test点肯定不符合结果（联想在main函数寻找a,b点时的要求） */
	if (fabs(b.x - a.x) < 0.000001)
		return false;
	k = (b.y - a.y) / (b.x - a.x);
	d = a.y - k * a.x;
	double ret = k*test.x - test.y + d;
	if (ret > 0.000001)	//点在下方
		return true;
	else   //点在线上 和 点在线的上方 
		return false;
}

查找符合的点，递归函数：
void FindPoint(Point point[], int plen, Point a, Point b, Func func)
{
	if (plen == 0)
		return;
	/* 找出 Pmax 点 */
	Point pmax;
	pmax.x = point[0].x;
	pmax.y = point[0].y;
	double k, d;
	k = (b.y - a.y) / (b.x - a.x);
	d = a.y - k * a.x;
	double dist = fabs(k*pmax.x - pmax.y + d);	
	double newdist;
	for (int i = 1; i < plen; ++i)
	{
		newdist = fabs(k*point[i].x - point[i].y + d);
		if (newdist - dist > 0.000001)
		{
			pmax.x = point[i].x;
			pmax.y = point[i].y;
		}
		else if (fabs(newdist - dist) < 0.000001)
		{	//选择使角PmaxPaPb最大的点
			double k_pmax = (pmax.y - a.y) / (pmax.x - a.x);
			double k_point = (point[i].y - a.y) / (point[i].x - a.x);
			if (fabs(k_point - k) - fabs(k_pmax - k) > 0.000001)
			{
				pmax.x = point[i].x;
				pmax.y = point[i].y;
			}
		}
	}
	printf("Point(%f, %f)\n", pmax.x, pmax.y);

	/* 找出各自符合满足 Pmax,Pa 和 Pmax,Pb 的点 */
	Point *p1 = (Point *)malloc((plen / 2 + 1)*sizeof(Point));
	Point *p2 = (Point *)malloc((plen / 2 + 1)*sizeof(Point));
	int p1idx = 0, p2idx = 0;
	for (int i = 0; i < plen; ++i)
	{
		if (func(pmax, a, point[i]))
		{
			p1[p1idx].x = point[i].x;
			p1[p1idx].y = point[i].y;
			p1idx++;
		}
		else if (func(pmax, b, point[i]))
		{
			p2[p2idx].x = point[i].x;
			p2[p2idx].y = point[i].y;
			p2idx++;
		}
	}
	/* 递归寻找Pmax */
	FindPoint(p1, p1idx, pmax, a, func);
	FindPoint(p2, p2idx, pmax, b, func);

	free(p1);
	free(p2);

}主函数：
int _tmain(int argc, _TCHAR* argv[])
{
	int number = 0;
	while (number < 3)
	{
		printf("How much Point do you input(>=3):\n");
		scanf("%d", &number);
	}
	printf("Please input Point:\n");

	Point *p = (Point *)malloc(number * sizeof(Point));
	for (int i = 0; i < number; ++i)
	{
		scanf("%f%f", &(p[i].x), &(p[i].y));
	}

	/* 找出两个顶点 */
	Point a, b;
	a.x = p[0].x;
	a.y = p[0].y;
	b.x = p[0].x;
	b.y = p[0].y;
	for (int i = 1; i < number; ++i)
	{
		if (a.x - p[i].x > 0.000001) //有比a更小的(横坐标)
		{
			a.x = p[i].x;
			a.y = p[i].y;
		}
		else if (fabs(a.x - p[i].x) < 0.000001)
		{ // 存在和a在同一竖直线上的点，此时应该选择最上或最下的点（这里选最上）
			if (p[i].y - a.y > 0.000001)
			{
				a.x = p[i].x;
				a.y = p[i].y;
			}
		}
		if (b.x - p[i].x < -0.000001)
		{
			printf("b change\n");
			b.x = p[i].x;
			b.y = p[i].y;
		}
		else if (fabs(b.x - p[i].x) < 0.000001)
		{ // 存在和b在同一竖直线上的点，此时应该选择最上或最下的点（这里选最下，和a对应，为了更可能的均分上包和下包点数）
			if (p[i].y - a.y < -0.000001)
			{
				b.x = p[i].x;
				b.y = p[i].y;
			}
		}
	}
	/* 所有点在一条竖直的线，则此时已是所求结果 */
	if (fabs(a.x - b.x) < 0.000001)
	{
		printf("Point(%f, %f)\n", a.x, a.y);
		printf("Point(%f, %f)\n", b.x, b.y);
		system("pause");
		return 0;
	}
	
	printf("Point(%f, %f)\n", a.x, a.y);
	printf("Point(%f, %f)\n", b.x, b.y);
	/* 划分点为两个集，即上包 和 下包*/
	Point *p1 = (Point *)malloc((number / 2 + 1)*sizeof(Point));
	Point *p2 = (Point *)malloc((number / 2 + 1)*sizeof(Point));
	int p1idx = 0, p2idx = 0;
	for (int i = 0; i < number; ++i)
	{
		if (Upstair(a, b, p[i]))
		{
			p1[p1idx].x = p[i].x;
			p1[p1idx].y = p[i].y;
			p1idx++;
		}
		else if (Downstair(a, b, p[i])) 
		{
			p2[p2idx].x = p[i].x;
			p2[p2idx].y = p[i].y;
			p2idx++;
		}
	}
	FindPoint(p1, p1idx, a, b, Upstair);
	FindPoint(p2, p2idx, a, b, Downstair);

	free(p);
	free(p1);
	free(p2);
	system("pause");
	_tmain(0, NULL);

	return 0;

算法分析：

在输入数中分上包和下包时时间复杂度为O(n)，两个递归函数的调用规模下降为n/2.

故可得T(n) = 2T(n/2) + n,递归函数遍历元素时间复杂度为n，然后同样道理递归， 最好的效率是刚好上包和下包元素相等或差一的情况。

由T(n) = 2T(n/2) + n ，得T(2^k) = 2T(2^k-1) + 2^k

T(2^k) = 2(2T(2^k-2) + 2^k-1) + 2^k

  = 2^2T(2^k-2) + 2*2^k

  = 2^kT(1) + k*2^k

由T(1) = 1,k = logn

T(n) = n + logn*n

所以，时间复杂度是nlogn.