leetcode 587. Erect the Fence 凸包的计算

leetcode.587.Erect the Fence

凸包问题。好像是我在leetcode做的第一个凸包问题吧。

第一次做，涉及到的东西还是蛮多的。有一个东西很重要，就是已知一个点和一个矢量，求这个点在这个矢量的左边还是右边。网上都是用一个点对于已知直线的位置的描述，用矢量代替直线更准确，直观。

http://blog.csdn.net/modiz/article/details/9928955一个是用面积法描述的

http://blog.csdn.net/modiz/article/details/9928553一个用矢量的叉积描述的

其实我看上去感觉都是一样的貌似的。。其实都是用矢量的叉积描述的。

定义：平面上的三点A(x1,y1),B(x2,y2),C(x3,y3)组成三角形的面积是：

S(A,B,C)=|y1 y2 y3|= [(x1-x3)*(y2-y3)-(y1-y3)*(x2-x3)]/2

这是用向量的混合积表示的面积，

就像这样。。绘图潦草。。 这个求出来的面积应该就是这样的，x轴为矢量AB的方向，所以可以理解为x轴上面的面积为S，下面的面积为-S，所以S为负数，点C就在矢量AB的右侧，S为正数，C就在矢量AB的左侧。这样理解不是很直观嘛。

然后我就写一下我的思路，也是从leetcode上的Sloution上借鉴的，Sloution也是来源于http://www.algorithmist.com/index.php/Monotone_Chain_Convex_Hull.cpp

思路：

1.把points按x轴上的坐标由小到大（有大到小也可以）进行排序，相等就按y轴

2.先放入两个点，

3.开始遍历points，每放入一个point         //为了构造凸包下面的边界    

4.判断以栈顶两个元素组成的向量，判断这个点是否在向量的左侧或者线上，若是，则放入栈，若在右侧，出栈一个元素，重新执行步骤4；直到遍历完points

5.反向遍历points，执行步骤3                  //为了构造凸包上面的边界

6.去除栈中相同的points

构造下面边界时的情况，当发现下一个点是C并且在栈顶AB的右侧，此时B出栈，构造向量OA，这里不画了，可以发现C在OA的左侧，所以C进栈。

然后遍历到点D，构造向量AC，发现D就在AC的左侧，所以直接进栈。通过这种方式，一点一点确定边界范围。同理确定上面的边界的时候也是这个方式，自己手动画一下就很直观地明白了。

贴一下AC代码吧，注释相当详细

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
class Solution {
public:
    typedef int coord_t;
    //防止计算量太大
    typedef long long coord2_t;
    
    //通过判断向量的点积正负来确定点位于矢量左侧还是右侧    
    coord2_t cross(const Point &O,const Point &A,const Point &B){
        return (A.x-O.x)*(coord2_t)(B.y-O.y)-(A.y-O.y)*(coord2_t)(B.x-O.x);
    }
    
    //按x轴坐标排序，相等时用y轴坐标排序    
    static bool cmp(Point &p1,Point &p2){
        return p1.x<p2.x||(p1.x==p2.x&&p1.y<p2.y);
    }
    
    //去除duplicate的辅助函数    
    static bool equ(Point &p1,Point &p2){
        return p1.x==p2.x&&p1.y==p2.y;
    }
    
    vector<Point> outerTrees(vector<Point>& points) {
       int n=points.size(),k=0;
       //遍历两轮，所以size为2n
       //因为要用栈的顶部两个元素，所以用vector比要方便一些
       vector<Point> res(2*n);
       
       //排序
       sort(points.begin(),points.end(),cmp);
       
       //正向遍历
       for(int i=0;i<n;i++){
           //若在矢量的右侧，出栈
           while(k>=2&&cross(res[k-2],res[k-1],points[i])<0) k--;
           res[k++]=points[i];
       }
       
       //反向遍历
       for(int i=n-2,t=k+1;i>=0;i--){
           //若在矢量的右侧，出栈
           while(k>=t&&cross(res[k-2],res[k-1],points[i])<0) k--;
           res[k++]=points[i];
       }
       
       //重新resize并排序
       res.resize(k);
       sort(res.begin(),res.end(),cmp);
       //除去相同的元素，unique函数的方法是吧相同的元素都放到vector的尾部，并返回一个这些相同元素起始的iterator
       res.erase(unique(res.begin(),res.end(),equ),res.end());
       return res;
    }
};

另外删除vector中的重复数据(unique)，这个技巧也是我刚学的。

凸包有很多计算方法http://www.7zhang.com/index/cms/read/id/327304.html，这个博主讲了很多，我选了一个最好理解的写了。

因为最近在学python，所以特地用python实现了一遍

# Definition for a point.
# class Point(object):
#     def __init__(self, a=0, b=0):
#         self.x = a
#         self.y = b

class Solution(object):
    def outerTrees(self, points):
        """
        :type points: List[Point]
        :rtype: List[Point]
        """
        def sign(p,q,r):
            #cmp函数比较a，b大小，a<b return -1,a==b return 0,a>b return 1
            return cmp((p.x-r.x)*(q.y-r.y),(p.y-r.y)*(q.x-r.x))
            
        def drive(hull,r):
            hull.append(r)
            # *hull[-3:]表示尾部三个元素
            while len(hull)>=3 and sign(*hull[-3:])<0:
                hull.pop(-2);
            return hull;
        
        #lambda表示临时写的一个函数    
        points.sort(key=lambda p:(p.x,p.y))
        #reduce（f,list,可以作为计算的初始值）
        lower=reduce(drive,points,[])
        #points[::-1]表示反转list
        upper=reduce(drive,points[::-1],[]);
        return list(set(lower+upper))

很多python的东西还不熟悉。。顺便熟悉一下。。