【二维凸包模板】USA5.1——圈奶牛Fencing the Cows

最新推荐文章于 2022-01-19 09:51:47 发布

顾玥_浅笑

最新推荐文章于 2022-01-19 09:51:47 发布

阅读量323

点赞数

分类专栏：二维凸包文章标签：二维凸包

本文链接：https://blog.csdn.net/qq_36294918/article/details/103012877

版权

二维凸包专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言

一看这个专有名词“二维凸包”，我以为是和“卡壳”、“树链剖分”一样的毒瘤题qwq...

还好还好，它还很善良，我自己无压力打出来了

题目

题目描述

农夫约翰想要建造一个围栏用来围住他的奶牛，可是他资金匮乏。他建造的围栏必须包括他的奶牛喜欢吃草的所有地点。对于给出的这些地点的坐标，计算最短的能够围住这些点的围栏的长度。

输入格式

输入数据的第一行包括一个整数 N。N（0 <= N <= 10,000）表示农夫约翰想要围住的放牧点的数目。接下来 N 行，每行由两个实数组成，Xi 和 Yi,对应平面上的放牧点坐标（-1,000,000 <= Xi,Yi <= 1,000,000）。数字用小数表示。

输出格式

输出必须包括一个实数，表示必须的围栏的长度。答案保留两位小数。

输入输出样例

输入

输出

12.00

说明/提示

题目翻译来自NOCOW。

USACO Training Section 5.1

分析

（一）凸包是什么

形象来说就是【一条刚好包着所有点的橡皮圈】

例如本题有一组数据，我画出了对应的图像：

（二）怎么求凸包上的点、周长等等

参考：https://www.luogu.org/blog/Sagittarius/tu-bao-xue-xi-bi-ji-p2742-mu-ban-er-wei-tu-bao-usaco51-juan-nai-niu

求凸包，最核心的就是求出凸包上的点，我们分“下凸包”和“上凸包”处理，其实本质差不多，只是判断入栈出栈的条件不同

1.我们先将点按照X-Y排序（x为第一关键字，y为第二关键字）

这样做的目的是让最左下角的点和最右上角的点都被包含，就能保证所有点都被凸包包含啦

2.分别求上凸包和下凸包，最后像盖锅盖一样上下一拼，就是所求的凸包了

【下凸包】

1）栈定义的结构体，id为存入的点的编号，k为该点与前一个栈中点的直线斜率

2）第一个点，编号为1，斜率设为 - INF，入栈

因为1需要保留下来算答案，而下凸包形成时条件为斜率越小越好，所以设为 -INF 使得点1不会被踢出栈

第二个点，编号为2，斜率为2和1两坐标算出的结果，入栈

3）枚举3~n的点，若当前点 i 与栈顶元素 j 的斜率小于 j 之前形成的斜率，就把 j 踢出栈，

直到 i 斜率大于等于栈顶元素，i 入栈

【上凸包】和下凸包差不多

1）栈定义的结构体，id为存入的点的编号，k为该点与前一个栈中点的直线斜率

2）第一个点，编号为1，斜率设为 INF，入栈

因为1需要保留下来算答案，而下凸包形成时条件为斜率越大越好，所以设为 INF 使得点1不会被踢出栈

第二个点，编号为2，斜率为2和1两坐标算出的结果，入栈

3）枚举3~n的点，若当前点 i 与栈顶元素 j 的斜率大于 j 之前形成的斜率，就把 j 踢出栈，

直到 i 斜率小于等于栈顶元素，i 入栈

STL代码

大家都用数组模拟，就我用STL=。=...

/*
ID:lunasmi2
TASK:fc
LANG:C++                 
*/
#include<cstdio>
#include<cmath>
#include<stack>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAXN=10000,INF=0x3f3f3f3f; 
double ans;
int n;
struct node
{
	int id;
	double k;
};
stack<node> s1,s2;
struct Node
{
	double x,y;
}a[MAXN+5];
bool cmp(Node a,Node b)//双关键字排序 
{
	if(a.x==b.x)
		return a.y<b.y;
	return a.x<b.x;
}
double Cal(int s,int t)//计算距离 
{
	return sqrt((a[s].x-a[t].x)*(a[s].x-a[t].x)+(a[s].y-a[t].y)*(a[s].y-a[t].y));
}
double Calk(int s,int t)//计算斜率 
{
	if(a[t].x-a[s].x==0)
		return INF;
	return (a[t].y-a[s].y)/(a[t].x-a[s].x);
}
void Solve1()//下凸包 
{
	if(n==0||n==1)
		return ;
	s1.push((node){1,-INF});//点1会参与答案的计算，k设特殊值将其保留 
	s1.push((node){2,Calk(1,2)});
	for(int i=3;i<=n;i++)
	{
		double k1=-INF,k2;
		while(!s1.empty())
		{
			k1=Calk(s1.top().id,i);
			k2=s1.top().k;
			if(k1<k2)
				s1.pop();
			else
				break;
		}
		if(k1!=-INF)
			s1.push((node){i,k1});
	}
}
void Solve2()//上凸包 
{
	if(n==0||n==1)
		return ;
	s2.push((node){1,INF});//点1会参与答案的计算，k设特殊值将其保留 
	s2.push((node){2,Calk(1,2)});
	for(int i=3;i<=n;i++)
	{
		double k1=-INF,k2;
		while(!s2.empty())
		{
			k1=Calk(s2.top().id,i);
			k2=s2.top().k;
			if(k1>k2)
				s2.pop();
			else
				break;
		}
		if(k1!=-INF)
			s2.push((node){i,k1});
	}
}
int main()
{
    //freopen("fc.in","r",stdin);
    //freopen("fc.out","w",stdout);
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    	scanf("%lf%lf",&a[i].x,&a[i].y);
    sort(a+1,a+n+1,cmp);
    //形成凸包 ： 
    Solve1();
	Solve2();
	//计算答案： 
	node t1,t2;
	t1.id=INF;
	while(!s1.empty()) 
	{
		t2=s1.top();s1.pop();
		if(t1.id==INF)
		{
			t1=t2;
			continue;
		}
		ans+=Cal(t1.id,t2.id);
		t1=t2;
	}
	t1.id=INF;
	while(!s2.empty()) 
	{
		t2=s2.top();s2.pop();
		if(t1.id==INF)
		{
			t1=t2;
			continue;
		}
		ans+=Cal(t1.id,t2.id);
		t1=t2;
	}
	printf("%.2f\n",ans);
	return 0;
}

数组模拟栈代码

咕掉惹QAQ...最近在打（非常恶心的）搜索题

其实实现应该差不多，只是好像老师说数组会比用STL快，考试、比赛时尽量用数组模拟

某大佬的叉积代码

来源：https://www.luogu.org/blog/DanKuroto/solution-p2742

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
struct node{
    double x,y;
}p[10005],s[10005];
int n;
double ans,mid;
double CJ(node a1,node a2,node b1,node b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}//叉积大于0，则a左转后到b 
double dis(node p1,node p2)
{
    return sqrt( (double)(p2.y-p1.y)*(p2.y-p1.y)*1.0+(double)(p2.x-p1.x)*(p2.x-p1.x)*1.0 );
}//两点距离公式 
bool cmp(node p1,node p2)
{
    double tmp=CJ(p[1],p1,p[1],p2);
    if(tmp>0) return 1;
    if(tmp==0 && dis(p[0],p1)<dis(p[0],p2)) return 1;
    return 0;
}//按照夹角的大小排序 
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%lf%lf",&p[i].x,&p[i].y);
        if(i!=1&&p[i].y<p[1].y)
        {
            mid=p[1].y;p[1].y=p[i].y;p[i].y=mid;
            mid=p[1].x;p[1].x=p[i].x;p[i].x=mid;
        }
    } 
    //init 

    sort(p+2,p+1+n,cmp);//按照夹角大小 
    s[1]=p[1];
    int tot=1;//因为最低点一定在凸包内 
    for(int i=2;i<=n;i++)
    {
        while(tot>1&&CJ(s[tot-1],s[tot],s[tot],p[i])<=0) tot--;
        tot++;
        s[tot]=p[i];
    }
    s[tot+1]=p[1];
    for(int i=1;i<=tot;i++) ans+=dis(s[i],s[i+1]);
    printf("%.2lf\n",ans);
    return 0;
}