凸包的几种算法 主要Graham-Scan算法的水平序法 另加poj113 wall的解题

在说这个题目之前，我想给大家介绍一些这几天我了解到的有关凸包的知识：

1、Gift-Wrapping（卷包裹算法）

这个算法在《算法艺术》上说的很清楚了（p391-393），如果理解的还不是很清楚，在这里讲解的特别好，特别清楚，由于这个很简单，所以就不谈论它了。我对这个算法的理解是：时间复杂度是O(N*H),N是点的个数，H是在凸包上点的个数。所以卷包裹算法很适合凸包上的点很少的时候，通常情况下，随机数据会很快。但是如果构造出的凸包上的点很多的时候，它就会很慢了，不如说，所有点都在一个园上的时候。

2、Graham-Scan算法

《算法艺术》（p393-396）。我觉得上面讲的很详细很详细了。同样，如果理解的不好可以看看这里。

这个算法是基于一个有序的点，所以必须要排序的。关键就在这里，排序分两种：极角排序和水品排序。估计大多数人都会第一种。

先说第一种。首先要找到一个一定在凸包上的点p0，这个点怎么找？自己想想吧。然后就以这个点为基点，对所有点按照极角大小排序。这里注意一下，如果极角相等，那么就按距离从小到大排序。这个是防止共线问题，关于这个下面好好讨论。然后把排序后的p0，p1，p2放入栈中，接着就是遍历每个点了，始终保证非“右手”方向就好了，具体实现去网上搜，很多。

然后就是第二种的水平序。排序准则是先按y大小排序，如果y相等，就按x排序。相对于第一种，这个排序简单的多。然后和上面的思想一样，只不过要分两步，右链和左链，先做右链，从0到排序最后点，然后再反过来，进行左链。具体的细节可以参考下面的代码。可能你在想这样有什么好处呢，我要说的是，这样可以很完美的解决共线问题。

我对这个算法的理解是：对于随机数据，可能没有卷包裹算法快。但是也是可以接受的。之所以喜欢的原因是，它可以完美的解决共线这个一直让人头大的问题。

3、Melkman算法

首先要说的是：很多人都认为这个是最好的算法。这个算法可以在个点有序的前提下，每次获得一个点就可以将先前的凸包改造成新的凸包，因此，这个是一个在线算法，它有着其他算法无法比拟的优势。1987年Melkman提出的的凸包算法，它不再使用堆栈了，转而使用双向表，这为凸包算法的历史掀开了崭新的一夜。

具体实现我就不说了，相信看过上面几句话的，现在都已经忍不住要学习了。

今天看了一下午《算法艺术》和网上的一些资料，终于又有了一些理解，那就补充一下吧。之前都是模模糊糊的，现在明白了，可能我现在理解的还是错误的，但是我还是要说出来：Melkman算法的前提是“各个点有序”。所以melkman是用来求简单多边形的凸包算法，可以在线性时间求出最小凸包。而其他两种则可以求点集的凸包的算法。如果要用Melkman算法来求点集的凸包，那么首先也是要排序的，通过排序可以形成一个简单的多边形，然后才可以在线性的时间求出最小凸包。

所以最终得到的结论是：求点集的凸包，时间复杂度的底线是O(nlogn)。

最后讨论一下共线的问题：

假设有这么几个点

0 0

0 1

0 2

2 2

1 1

和这几个点

1 1

2 2

3 3

4 4

对于上面的两组数据，如果用卷包裹算法和Graham-Scan的极角排序法做，要求只输出凸包上的定点，会出现什么样的问题？？

如果用Graham-Scan的水平序来写，会不会出现同样的问题？？

大家可以好好想想！！！！

还有很多凸包方面的算法，比如Jarvis步进法、增量、溶解、QuickHull等，这些多用于数学中，实践意义不大，所以就不说了。有兴趣了解凸包算法的发展史，可以看看蓝点大神的《漫话二维凸包》。。

现在说poj1113 wall：

题目：poj1113 wall

意思就是给一个城堡的墙角的坐标，让你用最短的围墙围起来，并且围墙离城堡的距离不能少于L。

说白了就是一个很裸的凸包问题。对于那个不能小于L，等作出了凸包，然后把边向外移动L，自己画画就看出来了，每个角处的弧，加起来刚好是一个半径为L的圆，所以最终结果就是圆的周长加上凸包的周长。

值得注意的是：由于精度问题，对于那些共线的点，应该取最远处那个计算长度，不然可能会一直WA，这个就体现了Graham-Scan算法的水平序的优势了。大家好好品味。。

比如上面提到的第一组数据，计算的顶点应该是0 0，0 2和2 2，而不是所有的点，即使所有的点都在凸包上，如果计算所有的点，误差就会大很多，肯能就是一直WA的。

代码如下：

//突然想用类写个模板，由于ｃ＋＋没学好，所以弄了一上午才弄万，不好的地方欢迎大家指点。。。。。
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <math.h>

using namespace std;
const int N=1100;

struct Node{
	int x,y;
	bool operator<(Node a)const{
	return y<a.y||(y==a.y&&x<a.x);
	}
};

class Graham_Scan{
public:

	Graham_Scan(int r){
		num_node=r;
		for(int i=0;i<=num_node;i++)
			visit[i]=true;
	}
	bool judg(){//判断给的点是否符合条件能够成凸包
		if(num_node<2)
			return 0;
	}
	void init();
	void fun();
	void print_node(bool jud);//输出凸包上的点，如果jud真就输出所有点，否则就输出定点
	double print_per();//输出凸包的周长
private:
	int num_node,stack_all[N],stack[N],top_all,top;
	Node node[N];
	double dis(Node a,Node b);
	void Graham_scan();//Graham_Scan算法水平序的实现
	bool visit[N];
	int turn(int a,int b,int c);
};

void Graham_Scan::init()
{
	for(int i=0;i<num_node;i++)
		scanf("%d%d",&node[i].x,&node[i].y);
}

double Graham_Scan::dis(Node a,Node b)
{
	double c;
	c=(b.x-a.x)*(b.x-a.x)+(b.y-a.y)*(b.y-a.y);
	return sqrt(c);
}

int Graham_Scan::turn(int a,int b,int c)
{
	return (node[b].x-node[a].x)*(node[c].y-node[a].y)-(node[b].y-node[a].y)*(node[c].x-node[a].x);
}

void Graham_Scan::fun()
{
	Graham_scan();
}

void Graham_Scan::Graham_scan()
{
	int i;
	sort(node,node+num_node);
	stack_all[0]=stack[0]=0;
	stack_all[1]=stack[1]=1;
	top=top_all=1;
	visit[1]=false;
	//执行右链，同时标记已经在右链上的点
	for(i=2;i<num_node;i++)
	{
		while(top>0&&turn(stack[top-1],stack[top],i)<=0)	
			top--;
		stack[++top]=i;

		while(top_all>0&&turn(stack_all[top_all-1],stack_all[top_all],i)<0)
		{
			visit[stack_all[top_all]]=true;
			top_all--;
		}
		stack_all[++top_all]=i;
		visit[i]=false;
	}
	//现在的top，top_all点一定是最上边，最右边的那个点
	//执行左链，逃过在右链上已经在凸包上的点，看别人写的时候没有跳过，不过算法书上说是要跳过的，所以还是跳过吧
	int top1=top,top1_all=top_all;
	stack[++top]=num_node-2;
	stack_all[++top_all]=num_node-2;
	for(i=num_node-3;i>=0;i--)
	{
		while(visit[i]&&top>top1&&turn(stack[top-1],stack[top],i)<=0)
			top--;
		stack[++top]=i;

		while(visit[i]&&top_all>top1_all&&turn(stack_all[top_all-1],stack_all[top_all],i)<0)
			top_all--;
		stack_all[++top_all]=i;
	}	
	//现在的top,top_all点一定是0点
}

void Graham_Scan::print_node(bool jud)
{
	if(jud)
	{
		for(int i=0;i<top_all;i++)
			cout<<node[stack_all[i]].x<<" "<<node[stack_all[i]].y<<endl;
	}
	else
		for(int i=0;i<top;i++)
			cout<<node[stack[i]].x<<" "<<node[stack[i]].y<<endl;
}

double Graham_Scan::print_per()
{
	double ans=0.0;
	for(int i=1;i<=top;i++)
	{
		ans+=dis(node[stack[i]],node[stack[i-1]]);
	}
	return ans;
}

int main()
{
	int n,l;
	while(~scanf("%d%d",&n,&l))
	{
		double ans=acos(-1.0)*2*l;
		Graham_Scan solve(n);
		if(solve.judg())
		{
			cout<<"No\n"<<endl;
			continue;
		}
		solve.init();
		solve.fun();
		ans+=solve.print_per();
		printf("%0.lf\n",ans);
	}
}

参考资料：

《算法艺术与信息学竞赛》  刘汝佳 黄亮

《算法导论》 Thomas H.Cormen、Charles E.Leiserson、Ronald L.Rivest、Clifford Stein 潘金贵 顾铁成等人译