[Poj 2187] 计算几何之凸包(二) {更高效的算法}

{

承上一节

继续介绍点集的凸包 

(下文中所有凸包 若不做特殊说明均指点集的凸包)

这一节介绍相比更高效的算法

}

====================================================================

一.卷包裹算法(Gift Wrapping Algorithm)的特性

前面提到过卷包裹算法的复杂度问题

由于卷包裹算法是两重循环实现的 因此很好分析它的复杂度

  
  

   
    1 
   
   while
   
    true 
   
   do
   
   

   
    2 
   
    
   
   begin
   
   

   
    3 
   
    k:
   
   =
   
   0
   
   ;

   
    4 
   
    inc(m); ch[m]:
   
   =
   
   j;

   
    5 
   
    
   
   for
   
    i:
   
   =
   
   1
   
    
   
   to
   
    n 
   
   do
   
   

   
    6 
   
    
   
   if
   
    (i
   
   <>
   
   j)
   
   and
   
   ((k
   
   =
   
   0
   
   )
   
   or
   
   

   
    7 
   
    cmp(p[j],p[k],p[i]))

   
    8 
   
    
   
   then
   
    k:
   
   =
   
   i;

   
    9 
   
    
   
   if
   
    k
   
   =
   
   temp 
   
   then
   
    break;

   
   10 
   
    j:
   
   =
   
   k;

   
   11 
   
    
   
   end
   
   ;
  
  

内部循环N次 外循环的次数决定于凸包上的点数H

所以卷包裹算法复杂度为O(HN) 这个复杂度很有特点

考虑一个随机点集的凸包上的点数往往很少 但是最坏情况下是O(N)级别的

比如所有的点都在一个圆上的时候

这就决定了卷包裹算法很适合随机的点集 但是如果是刻意构造的数据或是比较特殊的数据

就会达到O(N^2)的最坏复杂度 这是我们不愿意看到的

下面介绍最坏情况下复杂度更好的Graham扫描算法(Graham Scan Algorithm)

====================================================================

二.Graham扫描算法(Graham Scan Algorithm)

Graham扫描算法维护一个凸壳 通过不断在凸壳中加入新的点和去除影响凸性的点 最后形成凸包

The Graham scan is a method of computing the convex hull of a finite set of points in the plane with time complexity O(n log n). It is named after Ronald Graham, who published the original algorithm in 1972.[1] The algorithm finds all vertices of the convex hull ordered along its boundary.

http://en.wikipedia.org/wiki/Graham_scan

算法主体由两部分组成 先是排序 后是扫描 分块讲解一下

----------------------------------------------------------------------------------------------------------

1.点集排序

为了得到加入新点的顺序 Graham扫描法的第一步是对点集排序

排序是对杂乱的点集进行了梳理 这也是这种算法能够得到更高效率的根本原因

排序的方法也有两种 极角坐标排序(极角序) 和 直角坐标排序(水平序)

前者好理解一些 但是在实现的时候 后者更方便

先说极角序 为了极角排序 我们先得得到一个参考点

一般的 我们取最左边(横坐标最小)的点作为参考点 如果有多个这样的点就取最下面的(纵坐标最小)

看这样一个例子 这是一个任意给出的平面点集:

参考点的定义:在横坐标最小的情况下取纵坐标最小的点

所以所有的点只能在这个黄色的半平面中 而且正上方为闭(可取得) 正下方为开(不可取)

这就决定了参考点的性质:点集中任意两点和参考点所成的到角为锐角

这样我们取得参考点 然后再考虑极角排序

极角排序以参考点为极角坐标系原点 各个点的极角为关键字

由于上面我们得到的参考点的性质 我们可以设所有点的极角均在(-90,90]之间

排序完成后应该是这样的:

比较极角我们仍然可以利用向量的叉积

叉积在这里已经介绍了 http://www.cnblogs.com/Booble/archive/2011/02/28/1967179.html

同样由于参考点的性质 所有向量之间的到角都是在180度以内 不会产生错误

----------------------------------------------------------------------------------------------------------

2.Graham的栈扫描

Graham的扫描是一个很优美的过程 用到的数据结构也很简单 仅仅是一个栈而已

核心的思想是按照排好的序 依次加入新点得到新的边

如果和上一条边成左转关系就压栈继续 如果右转就弹栈直到和栈顶两点的边成左转关系 压栈继续

实现的时候我们不用存边 只需要含顺序在栈里存点 相邻两点就是一条边

由于我们时时刻刻都保证栈内是一个凸壳 所以最后扫描完毕 就得到了一个凸包

下面还是继续上面的那个样例 演示一下栈扫描的过程

这样Graham扫描算法基本完成

复杂度是排序O(Nlog2N) 扫描O(N) {每个点仅仅出入栈一次}

合起来是一个O(Nlog2N)的算法 很优秀

 ----------------------------------------------------------------------------------------------------------

3.双重共线点难题

和卷包裹算法一样 我们同样还要考虑共线点问题

而且Graham扫描算法的共线问题更复杂 所以需要仔细考虑

i).排序时的共线问题

如果极角相同 我们应该怎么定先后呢?

我们得加上第二关键字距离 比如极角相同 距离参考点近的先

不过不管是近的先还是 远的先 开始和结束的两条边总是矛盾的

我们必须对其中一条特殊处理 除了结束边外距离近的先 结束边上距离远的先

这就是为什么极角排序不是很好实现的原因了 下面会介绍一下水平序

ii).扫描时的共线问题

这个和卷包裹算法的处理放法如出一辙

如果需要保留共线的点就在到角相同时取距离最近的

如果仅仅需要凸包极点就取距离最远的

----------------------------------------------------------------------------------------------------------

4.直角坐标排序(水平序)

直角坐标排序方法没有了极角排序的不足

以横坐标为第一关键字 纵坐标为第二关键字 排序点集

然后从第一个点开始 分别利用Graham扫描生成左链和右链

需要注意以下两点:

i).左链和右链的旋转方向是相反的

ii).注意生成第二条链要忽略第一条链上的点

由于水平序的CMP函数比较简单 代码也更短

还有一件有意思的事 Graham扫描算法是1972年提出的 卷包裹算法是1973年提出的

其实不奇怪 这两个算法本来也没有优劣 所用的思想不同 各自善于处理不同的情况

Graham扫描所用时间在点集随机时 还不如卷包裹算法快

正如第一节所说 卷包裹算法已经可以处理大部分情况 也是一个可取的算法

实际应用中点集更趋向于均匀 而不是集中在凸包上

----------------------------------------------------------------------------------------------------------

最后给一下比较难实现的极角排序代码

GrahamScan

   
   

    
    {
    
    $inline on
    
    }
    
    

    
    const
    
     zero
    
    =
    
    1e-6
    
    ; maxn
    
    =
    
    100000
    
    ;

    
    type
    
     point
    
    =
    
    record
    
     x,y:extended; 
    
    end
    
    ;

    
    var
    
     p,ch:
    
    array
    
    [
    
    1
    
    ..maxn]
    
    of
    
     point;
 i,j,n,m,temp:longint;

    
    function
    
     sgn(x:extended):longint; inline;

    
    begin
    
    

    
    if
    
     abs(x)
    
    <
    
    zero 
    
    then
    
     exit(
    
    0
    
    );

    
    if
    
     x
    
    <
    
    0
    
     
    
    then
    
     sgn:
    
    =-
    
    1
    
     
    
    else
    
     sgn:
    
    =
    
    1
    
    ;

    
    end
    
    ;

    
    function
    
     cross(a,b,c,d:point):extended; inline;

    
    begin
    
    
cross:
    
    =
    
    (b.x
    
    -
    
    a.x)
    
    *
    
    (d.y
    
    -
    
    c.y)
    
    -
    
    (d.x
    
    -
    
    c.x)
    
    *
    
    (b.y
    
    -
    
    a.y);

    
    end
    
    ;

    
    function
    
     dist(a,b:point):extended; inline;

    
    begin
    
    
dist:
    
    =
    
    sqr(a.x
    
    -
    
    b.x)
    
    +
    
    sqr(a.y
    
    -
    
    b.y);

    
    end
    
    ;

    
    function
    
     cmp1(a,b,c:point):boolean; inline;

    
    var
    
     temp:longint;

    
    begin
    
    
temp:
    
    =
    
    sgn(cross(a,b,a,c));

    
    if
    
     temp
    
    <>
    
    0
    
     
    
    then
    
     exit(temp
    
    >
    
    0
    
    ); 
    
    {
    
    *B
    
    }
    
    
cmp1:
    
    =
    
    dist(a,b)
    
    <
    
    dist(a,c);

    
    end
    
    ;

    
    function
    
     cmp2(a,b,c:point):boolean; inline;

    
    var
    
     temp:longint;

    
    begin
    
    
temp:
    
    =
    
    sgn(cross(a,b,b,c));

    
    if
    
     temp
    
    <>
    
    0
    
     
    
    then
    
     exit(temp
    
    <
    
    0
    
    ); 
    
    {
    
    *B
    
    }
    
    
cmp2:
    
    =
    
    dist(a,b)
    
    <
    
    dist(a,c); 
    
    {
    
    *A
    
    }
    
    

    
    end
    
    ;

    
    procedure
    
     swap(
    
    var
    
     a,b:point); inline;

    
    var
    
     temp:point;

    
    begin
    
    
temp:
    
    =
    
    a; a:
    
    =
    
    b; b:
    
    =
    
    temp;

    
    end
    
    ;

    
    procedure
    
     sort(l,r:longint);

    
    var
    
     i,j:longint;
 x:point;

    
    begin
    
    
i:
    
    =
    
    l; j:
    
    =
    
    r;
x:
    
    =
    
    p[(l
    
    +
    
    r)
    
    >>
    
    1
    
    ];

    
    repeat
    
    

    
    while
    
     cmp1(p[
    
    1
    
    ],p[i],x) 
    
    do
    
     inc(i);

    
    while
    
     cmp1(p[
    
    1
    
    ],x,p[j]) 
    
    do
    
     dec(j);

    
    if
    
     
    
    not
    
    (i
    
    >
    
    j)
 
    
    then
    
     
    
    begin
    
    
 swap(p[i],p[j]);
 inc(i); dec(j);
 
    
    end
    
    ;

    
    until
    
     i
    
    >
    
    j;

    
    if
    
     i
    
    <
    
    r 
    
    then
    
     sort(i,r);

    
    if
    
     l
    
    <
    
    j 
    
    then
    
     sort(l,j);

    
    end
    
    ;

    
    begin
    
    
assign(input,
    
    '
    
    Hull.in
    
    '
    
    ); reset(input);
assign(output,
    
    '
    
    Hull2.out
    
    '
    
    ); rewrite(output);
readln(n);

    
    for
    
     i:
    
    =
    
    1
    
     
    
    to
    
     n 
    
    do
    
    
 
    
    begin
    
    
 readln(p[i].x,p[i].y);
 
    
    if
    
     (p[i].x
    
    <
    
    p[
    
    1
    
    ].x)
    
    or
    
    
 (sgn(p[i].x
    
    -
    
    p[
    
    1
    
    ].x)
    
    =
    
    0
    
    )
    
    and
    
    (p[i].y
    
    <
    
    p[
    
    1
    
    ].y)
 
    
    then
    
     swap(p[
    
    1
    
    ],p[i]);
 
    
    end
    
    ;
sort(
    
    2
    
    ,n);

    
    while
    
     i
    
    >
    
    2
    
     
    
    do
    
    
 
    
    begin
    
    
 
    
    if
    
     sgn(cross(p[
    
    1
    
    ],p[i],p[
    
    1
    
    ],p[i
    
    -
    
    1
    
    ]))
    
    <>
    
    0
    
    
 
    
    then
    
     break; dec(i);
 
    
    end
    
    ;
temp:
    
    =
    
    (i
    
    +
    
    n
    
    +
    
    1
    
    )
    
    >>
    
    1
    
    ;

    
    for
    
     j:
    
    =
    
    n 
    
    downto
    
     temp 
    
    do
    
    
 swap(p[j],p[i
    
    +
    
    n
    
    -
    
    j]);
m:
    
    =
    
    1
    
    ; ch[
    
    1
    
    ]:
    
    =
    
    p[
    
    1
    
    ];
inc(n); p[n]:
    
    =
    
    p[
    
    1
    
    ];

    
    for
    
     i:
    
    =
    
    2
    
     
    
    to
    
     n 
    
    do
    
    
 
    
    begin
    
    
 
    
    while
    
     m
    
    >
    
    1
    
     
    
    do
    
    
 
    
    begin
    
    
 
    
    if
    
     
    
    not
    
     cmp2(ch[m
    
    -
    
    1
    
    ],ch[m],p[i])
 
    
    then
    
     break; dec(m);
 
    
    end
    
    ;
 inc(m); ch[m]:
    
    =
    
    p[i];
 
    
    end
    
    ;

    
    for
    
     i:
    
    =
    
    1
    
     
    
    to
    
     m
    
    -
    
    1
    
     
    
    do
    
    
 writeln(ch[i].x:
    
    0
    
    :
    
    2
    
    ,
    
    '
    
     
    
    '
    
    ,ch[i].y:
    
    0
    
    :
    
    2
    
    );
close(input); close(output);

    
    end
    
    .


    
    *
    
    A Change Direction

    
    *
    
    B Remove Colinear Points
   
   

====================================================================

三.快速凸包算法(Quickhull Algorithm)

对比Graham扫描算法和卷包裹算法

我们发现 Graham扫描算法在凸包上的点很密集时仍然适用

卷包裹算法在凸包上点集随机分布时是很高效的

那么有没有两个优点都具备的算法呢?

是有的! 快速凸包算法(Quickhull Algorithm)就是这样的一个算法

快速凸包算法是一个和快速排序(Quicksort Algorithm)神似的算法

尽管快速排序的最坏复杂度可以达到O(N^2)

但是有着极小的常数 实现方便 思路优美 绝大多数情况特别高效的快速排序 还是赢得了更多人的青睐

快速凸包算法也是这样 尽管可以构造一个数据使之达到O(N^2)的复杂度

但这需要刻意针对程序经过分析 才能做到 是实际应用中根本不会碰到的情况

在点集均匀分布时 快速凸包的复杂度更是达到了O(N) 是上面两种算法难以企及的

在绝大多数情况下 平均复杂度是O(Nlog2N) 也很高效

快速凸包继承了快速排序分治的思想 这是一个递归的过程

------------------------------------------------------------------------------------

伪代码如下:

 

  
  

   
    1 
   
   void
   
    快速凸包(P:点集 , S:向量 
   
   /*
   
   S.p,S.q:点)
   
   */
   
    ){

   
    2 
   
   　　
   
   /*
   
    P 在 S 左侧
   
   */
   
   

   
    3 
   
   　　选取 P 中距离 S 最远的 点 Y ;

   
    4 
   
   　　向量 A 
   
   <-
   
    { S.p , Y } ; 向量 B 
   
   <-
   
    { Y , S.q } ;

   
    5 
   
   　　点集 Q 
   
   <-
   
    在 P 中 且在 A 左侧的点 ;

   
    6 
   
   　　点集 R 
   
   <-
   
    在 P 中 且在 B 左侧的点 ; 
   
   /*
   
    划分 
   
   */
   
   

   
    7 
   
   　　快速凸包 ( Q , A ) ; 
   
   /*
   
    分治 
   
   */
   
   

   
    8 
   
   　　输出 (点 Y) ; 
   
   /*
   
    按中序输出 保证顺序
   
   */
   
   

   
    9 
   
   　　快速凸包 ( P , B ) ; 
   
   /*
   
    分治 
   
   */
   
   

   
   10 
   
   }
  
  

初始化就选取 最左下和最右上的点 划分好 然后调用两次快速凸包函数分别求上下凸包

其中 选取和划分都需要用到向量的叉乘 注意方向

另外 存储点集可以用数组里的连续一段 传参的时候就传左右下标

划分的时候就是给数组交换元素 使新的点集 变成连续的一段

这里有一个很好的演示

http://www.cs.princeton.edu/courses/archive/spr10/cos226/demo/ah/QuickHull.html

还要补充说明一下

快速凸包在所有点都在圆周上的时候还是O(Nlog2N) 不过会比Graham扫描算法慢一些

可以说 这种数据是Graham扫描法的最好情况 一遍走完就行了

构造快速凸包的最坏情况就是使划分不均等 和构造快速排序最坏情况一样

贴以下我很辛苦写出来的代码吧 为了好看些 还心血来潮用cpp写了...

QuickHull

   
   

    
    #include 
    
    <
    
    iostream
    
    >
    
    
#include 
    
    <
    
    math.h
    
    >
    
    

    
    #define
    
     maxn 100000
    
    

    
    #define
    
     zero 1e-12
    
    

    
    #define
    
     sgn(x) (fabs(x)<zero?0:(x>0?1:-1))
    
    

    
    #define
    
     cross(a,b,c) ((b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x))
    
    

    
    #define
    
     cmp(a,b) (a.x<b.x || sgn(a.x-b.x)==0 && a.y<b.y)
    
    


    
    using
    
     
    
    namespace
    
     std;

    
    struct
    
     point{
 
    
    double
    
     x,y;
}p[maxn];

    
    double
    
     s[maxn];


    
    void
    
     hull(
    
    int
    
     l,
    
    int
    
     r,point a,point b){
 
    
    int
    
     x
    
    =
    
    l,i
    
    =
    
    l
    
    -
    
    1
    
    ,j
    
    =
    
    r
    
    +
    
    1
    
    ,k;
 
    
    for
    
     (k
    
    =
    
    l;k
    
    <=
    
    r;k
    
    ++
    
    ){
 
    
    double
    
     temp
    
    =
    
    sgn(s[x]
    
    -
    
    s[k]);
 
    
    if
    
     (temp
    
    <
    
    0
    
     
    
    ||
    
     temp
    
    ==
    
    0
    
     
    
    &&
    
     cmp(p[x],p[k])) x
    
    =
    
    k;
 }
 point y
    
    =
    
    p[x];
 
    
    for
    
     (k
    
    =
    
    l;k
    
    <=
    
    r;k
    
    ++
    
    ){
 s[
    
    ++
    
    i]
    
    =
    
    cross(p[k],a,y);
 
    
    if
    
     (sgn(s[i])
    
    >
    
    0
    
    ) swap(p[i],p[k]); 
    
    else
    
     i
    
    --
    
    ;
 }
 
    
    for
    
     (k
    
    =
    
    r;k
    
    >=
    
    l;k
    
    --
    
    ){
 s[
    
    --
    
    j]
    
    =
    
    cross(p[k],y,b);
 
    
    if
    
     (sgn(s[j])
    
    >
    
    0
    
    ) swap(p[j],p[k]); 
    
    else
    
     j
    
    ++
    
    ;
 }
 
    
    if
    
     (l
    
    <=
    
    i) hull(l,i,a,y);
 printf(
    
    "
    
    %.4lf %.4lf\n
    
    "
    
    ,y.x,y.y);
 
    
    if
    
     (j
    
    <=
    
    r) hull(j,r,y,b);
}


    
    int
    
     main(){
 freopen(
    
    "
    
    CH2D.in
    
    "
    
    ,
    
    "
    
    r
    
    "
    
    ,stdin);
 freopen(
    
    "
    
    CH2D1.out
    
    "
    
    ,
    
    "
    
    w
    
    "
    
    ,stdout);
 
    
    int
    
     n,i,x
    
    =
    
    0
    
    ;
 scanf(
    
    "
    
    %d
    
    "
    
    ,
    
    &
    
    n);
 
    
    for
    
     (i
    
    =
    
    1
    
    ;i
    
    <=
    
    n;i
    
    ++
    
    ){
 scanf(
    
    "
    
    %lf %lf
    
    "
    
    ,
    
    &
    
    p[i].x,
    
    &
    
    p[i].y);
 
    
    if
    
     (x
    
    ==
    
    0
    
     
    
    ||
    
     cmp(p[i],p[x])) x
    
    =
    
    i;
 }
 swap(p[
    
    1
    
    ],p[x]);
 printf(
    
    "
    
    %.4lf %.4lf\n
    
    "
    
    ,p[
    
    1
    
    ].x,p[
    
    1
    
    ].y);
 hull(
    
    2
    
    ,n,p[
    
    1
    
    ],p[
    
    1
    
    ]);
 
    
    return
    
     
    
    0
    
    ;
}
   
   

====================================================================

四.凸包算法复杂度下界

(引自<算法艺术与信息学竞赛>)

====================================================================

五.高效算法的应用

这里有一个平面最远点对的问题 可以利用凸包解决

Poj 2187 http://poj.org/problem?id=2187

由于最远点对必然在凸包上

我们先求凸包 然后枚举凸包上的点 不过这个复杂度最坏是O(N^2)的

不过凸包在很多情况下会改善问题的平均复杂度

凸包上的点通常很少 所以这个问题也可以过

篇幅关系 在下一节会介绍降低最坏复杂度的旋转卡壳算法

====================================================================

文中部分图片来源

http://westhoffswelt.de/blog/0040_quickhull_introduction_and_php_implementation.html

http://en.wikipedia.org/wiki/Graham_scan