分治法解决凸包问题（快包）

最新推荐文章于 2024-09-05 18:24:54 发布

zp1008611

最新推荐文章于 2024-09-05 18:24:54 发布

阅读量770

点赞数

分类专栏： # 算法-分治算法文章标签：算法

本文链接：https://blog.csdn.net/weixin_45699092/article/details/120647166

版权

算法同时被 2 个专栏收录

33 篇文章 0 订阅

订阅专栏

算法-分治

4 篇文章 0 订阅

订阅专栏

假设集合 $S$ 是平面上 $n > 1$ 个点 $p_1(x_1,y_1),...,p_n(x_n,y_n)$ 构成的。我们还假设这些点是按照它们的 $x$ 轴坐标升序排列的，如果 $x$ 轴坐标相同，则按照 $y$ 轴坐标升序排列。
算法步骤：

排序后找到最左边的点 $p_1$ 和最右边的点 $p_2$ （因为这两个点经过证明是凸包的顶点）。
利用向量 $\overrightarrow{p_1p_n}$ 将点分成上包 $S_1$ 和下包 $S_2$ ，对于点 $p_r$ （ $p_r$ 不能是 $\overrightarrow{p_1p_n}$ 上的点，因为 $\overrightarrow{p_1p_n}$ 上的点不可能再为凸包的顶点）：
- 如果 $\overrightarrow{p_1p_n}\times\overrightarrow{p_1p_r}>0$ ，则 $\overrightarrow{p_1p_r}$ 在 $\overrightarrow{p_1p_n}$ 的左侧，即 $p_r$ 是上包 $S_1$ 内的点。
- 如果 $\overrightarrow{p_1p_n}\times\overrightarrow{p_1p_r}<0$ ，则 $\overrightarrow{p_1p_r}$ 在 $\overrightarrow{p_1p_n}$ 的右侧，即 $p_r$ 是下包 $S_2$ 内的点。
  注：这里进行的是向量的叉积运算，设二维向量 $\vec{a}=(a_1,a_2)$ ， $\vec{b}=(b_1,b_2)$ ，那么 $a\times b=a_1b_2-a_2b_1$ （具体内容见高数的解析几何部分）
将点分类到上包和下包后，分别在其中找出顶点 $p_{max}$ ，它是使三角形 $\triangle p_1p_{max}p_n$ 面积最大的点。如果 $q_1(x_1,y_1),q_2(x_2,y_2),q_3(x_3,y_3)$ 是平面上的任意三个点，那么三角形 $\triangle q_1q_2q_3$ 的面积等于下面这个行列式绝对值的二分之一
$\left| \begin{array}{cccc} x_1 & y_1 & 1 \\ x_2 & y_2 & 1 \\ x_3 & y_3 & 1 \end{array} \right|=x_1y_2+x_3y_1+x_2y_3-x_3y_2-x_2y_1-x_1y_3$
找到 $p_{max}$ 之后，这里以上包举例，可以证明
- $p_{max}$ 是上包的顶点
- 包含在 $\triangle p_1p_{max}p_n$ 之中的点不可能是上包的顶点（因此在后面不必考虑）。
- 同时位于 $\overrightarrow{p_1p_{max}}$ 和 $\overrightarrow{p_{max}p_n}$ 的左边的点是不存在的
然后利用向量 $\overrightarrow{p_1p_{max}}$ 找到位于 $\overrightarrow{p_1p_{max}}$ 左侧的点，然后返回第3步的做法找到顶点；利用向量 $\overrightarrow{p_{max}p_n}$ 找到位于 $\overrightarrow{p_{max}p_n}$ 右侧的点，然后返回第3步的做法找到顶点，依次类推，最后找出上包的所有顶点，下包的做法也类似。

实现代码(C++)

#include<vector>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
#define Up true
#define Down false
// 输出包围pts的凸包

void helper(vector<pair<int,int>> pts,pair<int,int>A,pair<int,int>B,bool up,vector<pair<int,int>>& res) {
	if (pts.size()==0) return;
	vector<pair<int,int>> LeftPts;
    vector<pair<int,int>> RightPts;
	pair<int,int> AB = make_pair(B.first-A.first, B.second-A.second);
	int maxArea = 0;
	pair<int, int> Pmax;
    bool flag = false;
    if(up){
        // 找到使得APmaxB面积最大的点
		for(auto p:pts) {
            int Area = abs(A.first*p.second + B.first*A.second + p.first*B.second - B.first*p.second - p.first*A.second - A.first*B.second)/2; 
            if(Area > maxArea) {
                Pmax = p;
                maxArea = Area;
                flag = true;
            }
		}
        pair<int,int> APmax = make_pair(Pmax.first-A.first, Pmax.second-A.second);
        pair<int,int> PmaxB = make_pair(B.first-Pmax.first, B.second-Pmax.second);
        for(auto p:pts) {
            pair<int,int> AP = make_pair(p.first-A.first, p.second-A.second);
            pair<int,int> PmaxP = make_pair(p.first-Pmax.first, p.second-Pmax.second);
            // 找出APmax左边的点
            if((APmax.first * AP.second - AP.first * APmax.second) > 0) {
                LeftPts.push_back(p);   
            }
            // 找出PmaxB右边的点
            else if(PmaxB.first * PmaxP.second - PmaxP.first * PmaxB.second > 0) {
                RightPts.push_back(p);
            }
        }
	}
	
    else {
        // 找到使得APmaxB面积最大的点
        for(auto p:pts) {
            int Area = abs(A.first*p.second + B.first*A.second + p.first*B.second - B.first*p.second - p.first*A.second - A.first*B.second)/2; 
            if(Area > maxArea) {
                Pmax = p;
                maxArea = Area;
                flag = true;
            }
		}
        pair<int,int> APmax = make_pair(Pmax.first-A.first, Pmax.second-A.second);
        pair<int,int> PmaxB = make_pair(B.first-Pmax.first, B.second-Pmax.second);
        for(auto p:pts) {
            pair<int,int> AP = make_pair(p.first-A.first, p.second-A.second);
            pair<int,int> PmaxP = make_pair(p.first-Pmax.first, p.second-Pmax.second);
            // 找出APmax左边的点
            if((APmax.first * AP.second - AP.first * APmax.second) < 0) {
                LeftPts.push_back(p);   
            }
            // 找出PmaxB右边的点
            else if(PmaxB.first * PmaxP.second - PmaxP.first * PmaxB.second < 0) {
                RightPts.push_back(p);
            }
        }

	}
    if(flag) {
        res.push_back(Pmax);
        helper(LeftPts, A, Pmax, up, res);
        helper(RightPts, Pmax, B, up, res);
    }


}
void quickHull(vector<pair<int,int>> pts, vector<pair<int,int>>&res) {
	// 少于三点直接返回点集合
	if(pts.size()<=3) {
		res = pts;
	}
	// 点按x坐标排序
	sort(pts.begin(),pts.end());
	// 最左边的点和最右边的点就是凸包的顶点
    pair<int,int> A = pts.front();
    pair<int,int> B = pts.back();
    res.push_back(A);
	
	
    vector<pair<int, int>> UpPts;
    vector<pair<int, int>> DownPts;
    pair<int,int> AB = make_pair(B.first-A.first, B.second-A.second);
    for(auto p:pts) {
        pair<int,int> AP = make_pair(p.first-A.first, p.second-A.second);
        // 找出上凸包的里面的点
        if((AB.first * AP.second - AP.first * AB.second) > 0) {
            UpPts.push_back(p);
        }
        // 找出下凸包的里面的点
        else {
            DownPts.push_back(p);
        }
    }
	helper(UpPts,A,B,Up,res);
	// 找出下凸包的顶点
	helper(DownPts,A,B,Down,res);
    res.push_back(B);
}
int main() {
    vector<int> xpts = {0, 1, 5, 12, 17, 21, 24, 6, 19, 3, 9, 15, 7, 11, 6, 16};
    vector<int> ypts = {4, 9, 11, 12, 12, 9, 7, 0, 1, 8, 9, 8, 6, 6, 2, 2};
    vector<pair<int, int>> pts;
    for (int i = 0; i < xpts.size(); ++i) {
        pts.push_back(make_pair(xpts[i], ypts[i]));
    }
    vector<pair<int, int>> res;
    quickHull(pts, res);
    for(auto r:res) {
        cout << "(" << r.first << "," << r.second << ")" << endl;
    }
    system("pause");
    return 0;
}

绘图程序(python)：

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns

ptsdata=[[0, 4],[1, 9],[5, 11],[12, 12],
[17, 12],
[21, 9],
[24, 7],
[6, 0],
[19, 1],
[3, 8],
[9, 9],
[15, 8],
[7, 6],
[11, 6],
[6, 2],
[16, 2]]
data=pd.DataFrame(ptsdata).rename(columns={0:'x',1:'y'})

res=[(0,4),(24,7),(12,12),(1,9),(5,11),(17,12),(19,1),(6,0)]
res.sort()

def frange(start, stop, step):
     x = start
     while x < stop:
        yield x
        x += step

fig, ax = plt.subplots()
sns.scatterplot(x='x',y='y',data=data)
uppts=[]
downpts=[]
pts=[]
A=res[0]
B=res[-1]
uppts.append(A)
downpts.append(A)
AB=(B[0]-A[0],B[1]-A[1])
for i in range(len(res)):
    AP=(res[i][0]-A[0],res[i][1]-A[1])
    if((AB[0] * AP[1] - AP[0] * AB[1]) > 0):
        uppts.append(res[i])
    elif((AB[0] * AP[1] - AP[0] * AB[1]) < 0):
        downpts.append(res[i])
uppts.append(B)
downpts.append(B)
pts=uppts+downpts
for i in range(len(pts)-1):
    X=np.array(list(frange(pts[i][0],pts[i+1][0],0.01)))
    Y=pts[i][1]+((pts[i][1]-pts[i+1][1])/(pts[i][0]-pts[i+1][0]))*(X-pts[i][0])
    ax.plot(X,Y,'b-')
plt.show()