我的第一篇博客

于 2019-03-02 19:59:52 发布
阅读量193 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40192591/article/details/88080456
版权

UVa1111 - Trash Removal快速凸包o(nlogn)解决

Source: ACM/ICPC 2011WorldFinal
第一篇博客，唯独想表达的是我对算法的崇拜。 相比暴力算法，快速算法具很高的性能。在刷题的过程中寻找快速算法来解题是一件很有乐趣的事情。
在这里插入图片描述
题意：求一个能使输入的连线点集连成的封闭图形能够通过的最小距离。方法大致为求凸包，然后对凸包进行边遍历求凸包上到此边的最远顶点的最小值。
以下图形输入为A到Q的封闭图形
在这里插入图片描述

解法

快包算法（时间复杂度nlogn）

  1. 把所有的点都放在二维坐标系里面。那么横坐标最小的和最大的多个点一定是凸包上 的点。直线 AE, QI 把点集分成了三部分，中间部分舍弃，其他两部分分别叫做上包和下包。
  2. 对上包：求距离直线 AE 最远的点，即上图中的点 D 。
  3. 作直线 AD 、DE，把直线 AD左侧的点当成是上包，把直线 DE 右侧的点也当成是上包。
  4. 重复步骤 2、3。
  5. 对下包也作类似操作。

最终黑色的点表示被选中的凸包顶点即：ADEIKLMPQ
对凸包进行边遍历（二分法时间复杂度logn, 有n条边所以总共nlogn）
观察到从选定边开始的连续的点到此边的距离先递增再递减，故可以使用二分法查找最远点，即最远点满足：距离选定边的距离大于等于其相邻两点的距离，最后求n个最大距离的最小值就是答案。
c++代码实现如下（快凸包新代码）：时间复杂度o(n * log n)

#include <bits/stdc++.h>
using namespace std;

struct node
{
	double x, y;
	bool is_node;//是凸包顶点之一，默认不是 
	node(double x = 0, double y = 0, bool is_node = 0): x(x), y(y), is_node(is_node) {}
};
const double eps = 1e-8; 
const int maxn = 1000;
vector<node> nodeset;// 作为输入点组并排序 
vector<node> upset;// 上点组 
vector<node> downset;// 下点组 
vector<node> newset;// 凸包点组 
int size;
node t;//暂时点
//double answer[maxn];
// 比较double 
int cmp2(double a, double b)
{
	if (abs(a - b) <= eps)
		return 0;
	else if (a - b >= eps)
		return 1;
	else
		return -1;
}
// x优先，y其次 
bool cmp(node a, node b)
{
	if (cmp2(a.x, b.x) == 0)
		return a.y < b.y;
	return a.x < b.x;
}
// 放大距离的与逻辑值  
double line_node_s(int n, int i, int j, vector<node> a, bool omit)
{
	double x1, x2, y1, y2, x, y, val, mod;
	bool tap = a[n].x > a[i].x;
	x = a[j].x;
	y = a[j].y;
	x2 = tap ? a[n].x : a[i].x;
	y2 = tap ? a[n].y : a[i].y;
	x1 = tap ? a[i].x : a[n].x;
	y1 = tap ? a[i].y : a[n].y;
	val = (x2 - x1) * y - (y2 - y1) * x + x1 * y2 - x2 * y1;
	mod = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
	return omit ? val : (val * val / mod);
}
// 递归标记顶点 ，快速凸包算法 
void search_node(int b, int e, vector<node>& a, int loc) 
{
	double num = 0;
	int begin = 0, end = 0;
	if (e - b <= 2)
		return;
	for (int i = b + 1; i < e - 1; ++i)
	{
		double temp = loc * line_node_s(b, e - 1, i, a, 1);
		if (cmp2(temp, 0) == 1)
		{
			if (cmp2(temp,num) == 1)
			{
				begin = i;
				num = temp;
				end = 0;
			}
			else if (cmp2(temp, num) == 0)
			{
				end = i;
			}
		}
	}
	if (begin)
	{
		a[begin].is_node = 1;
		search_node(b, begin + 1, a, loc);
	}
	if (end)
	{
		a[end].is_node = 1;
		search_node(end, e, a, loc);
	}
	else if (begin)
		search_node(begin, e, a, loc); 
}
// 判定是否为最远点，嵌入二分法查找：寻找一个凸包中距离某线段最远的点
int best_far_node(int i, int j)// i是顺时针的线段，j是选定做比较的点 
{
	double left = line_node_s((i - 1 + size) % size, i, (i + j - 1 + size) % size, newset, 0);
	double mid = line_node_s((i - 1 + size) % size, i, (i + j) % size, newset, 0);
	double right = line_node_s((i - 1 + size) % size, i, (i + j + 1) % size, newset, 0);
	if (left <= mid && right <= mid)
		return 0;
	if (left < mid && mid < right)
		return 1;
	if (left > mid && mid > right)
		return -1;
} 

int main()
{//实现Trash Removal利用快排、快凸包算法、二分法查找算法实现o(nlogn)的时间复杂度 
	int n, number = 0;
	while (cin >> n, n)
	{//---------------------------------------------------------------------------输入加排序 
		nodeset.clear();
		upset.clear();
		downset.clear();
		newset.clear();
		while (n--)
		{
			cin >> t.x >> t.y;
			nodeset.push_back(t);
		}
		sort(nodeset.begin(), nodeset.end(), cmp);//---------------------------------------快排时间复杂度nlogn 
		n = nodeset.size();//------对付左右竖直边界多点的情况，分割图形形成上点组与下点组
		int start = 0, end = n - 1, up, down;
		while (cmp2(nodeset[++start].x, nodeset[0].x) == 0);//使两条线偏移 
		while (cmp2(nodeset[--end].x, nodeset[n - 1].x) == 0);
		
		nodeset[0].is_node = 1;
		downset.push_back(nodeset[0]);//加入左顶点 
		nodeset[start - 1].is_node = 1;//做标记 
		upset.push_back(nodeset[start - 1]);
		for (int i = start; i <= end; ++i)
			if (cmp2(line_node_s(start - 1, n - 1, i, nodeset, 1), 0) == 1)
				upset.push_back(nodeset[i]);
			else if (cmp2(line_node_s(0, end + 1, i, nodeset, 1), 0) == -1)
				downset.push_back(nodeset[i]);
		nodeset[end + 1].is_node = 1;
		downset.push_back(nodeset[end + 1]);//加入右顶点 
		nodeset[n - 1].is_node = 1;
		upset.push_back((nodeset[n - 1]));//-------------------------------------------------开始nlogn的快包算法
		int upn = upset.size(), downn = downset.size();
		if (upn > 2)//上点组点数大于2时可能存在凸包顶点 
			search_node(0, upn, upset, 1);
		if (downn > 2)//与上点组同理 
			search_node(0, downn, downset, -1);//---------------上下点组合并 
		for (int i = 0; i < upn; ++i)// 上点组凸包顶点加入凸包点组 
			if (upset[i].is_node)
				newset.push_back(upset[i]);
		if (end + 1 != n - 1)// 如果上下凸包边界不偏移则不重复加入右顶点 
			newset.push_back(nodeset[end + 1]);
		for (int i = downn - 2; i >= 1; --i)
			if (downset[i].is_node)
				newset.push_back(downset[i]);
		if (start - 1 != 0)// 如果上下凸包边界不偏移则不重复加入左顶点 
			newset.push_back(nodeset[0]);//-------------开始计算夹住凸包的两条平行线间最短距离
		size = newset.size();// 凸包尺寸 
		double maxl, minl = 1.79769e+308;
		for (int i = 0; i < size; ++i)//------------------------------------------------------n个二分法查找nlogn
		{
			int low = 1, high = size - 2, j = (low + high) / 2, is_b_n;
			while (is_b_n = best_far_node(i, j), is_b_n != 0)//二分法找最远点 
			{
				if (is_b_n == 1)
					low = j + 1;
				else
					high = j - 1;
				j = (low + high) / 2;
			}
			minl = min(minl, line_node_s((i - 1 + size) % size, i, (i + j) % size, newset, 0));
		}
		//answer[number++] = minl;
		printf("Case %d: %.2f\n", ++number, ceil(sqrt(minl) * 100) / 100);
	}/*
	for (int i = 0; i < number; ++i)
		printf("Case %d: %.2f\n", i + 1, ceil(sqrt(answer[i]) * 100) / 100);
	return 0;*/
}

/*
		cout << "\n";
		for (int i = 0; i < nodeset.size(); ++i)//--------------------------输出排序好的点组 
			cout << nodeset[i].x << " " << nodeset[i].y << "\n";
		cout << "\n";//*/ 
/* 
		for (int i = 0; i < upset.size(); ++i)//-------------------输出上点组 
			cout << upset[i].x << " " << upset[i].y << "\n";
		cout << "\n";
		for (int i = 0; i < downset.size(); ++i)//-----------------输出下点组 
			cout << downset[i].x << " " << downset[i].y << "\n";
		cout << "\n";//*/
/*
		for (int i = 0; i < size; ++i)
		{
			cout << newset[i].x << " " << newset[i].y << "\n";//-----------------------输出凸包 
		}//*/

旧代码（暴力慢凸包）：时间复杂度o(n^3)

#include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#include <math.h>
using namespace std;
#define max_n 102
#define int_max 2147483645
#define eps 1e-8

int rim[max_n][2]; // 生成最小凸多边形 
int con[max_n]; // 标记把用过做边的点，再求边时不使用 
int gra[max_n][2]; // 多边形坐标集 
int N; //原始图形点数
int N2;// 最小凸多边形点数  
// 返回j点在直线ni上方的逻辑值 
int line_point(int n, int i, int j);
// 两点间的距离的平方 
double point_dist(int m, int n);
// 判定n点是否可以作为最小凸多边形一边的一点，返回这一边的下一个点
int is_rim(int n); 
// 返回j点在直线ni上方的距离
double line_wid(int n, int i, int j);
// 以一边为基准，求其他所有点到这一边的最大距离
double rim_wid(int n);


int main()
{
	double val[600];
	int i, loca, count = 0, num;
	while (scanf("%d", &N), N)
	{
		int n = 0;
		double wid, min_wid = int_max;
		for (i = 0; i < N; ++i)
			scanf("%d %d", &gra[i][0], &gra[i][1]);
		for (i = 0; i < N; ++i)// 找到第一个合法点 
			if (loca = is_rim(i), loca != -1)
			{
				rim[n][0] = gra[i][0];
				rim[n][1] = gra[i][1];
				++n;
				con[i] = 1;
				break;
			}
		while (loca != -1)// 从一个合法点找到下一个合法点 
		{
			rim[n][0] = gra[loca][0];//迭代寻找直到找不到——与起点围成一个封闭图形 
			rim[n][1] = gra[loca][1];
			++n;
			con[i] = 1;
			loca = is_rim(loca);
			if (loca == -1) break;
		}
		N2 = n;
		for (i = 0; i < n; ++i)
		{
			wid = rim_wid(i);
			min_wid = min(min_wid, wid);
		}
		val[count] = sqrt(min_wid);
		++count;
		memset(rim, 0, sizeof(rim));
		memset(con, 0, sizeof(con));
		memset(con, 0, sizeof(gra));
	}
	for (i = 0; i < count; ++i)
	{
		printf("Case %d: %.2f\n", i + 1, ceil(val[i] * 100) / 100);
	}
	return 0;
} 

// 返回j点在直线ni的逻辑值 
int line_point(int n, int i, int j)
{
	int x1, x2, y1, y2, x, y, log;
	double val;
	x = gra[j][0];
	y = gra[j][1];
	if (gra[n][0] >= gra[i][0])
	{
		x2 = gra[n][0];
		y2 = gra[n][1];
		x1 = gra[i][0];
		y1 = gra[i][1];
	}
	else
	{
		x2 = gra[i][0];
		y2 = gra[i][1];
		x1 = gra[n][0];
		y1 = gra[n][1];
	}
	val = (x2 - x1) * y - (y2 - y1) * x + x1 * y2 - x2 * y1;
	if (val > eps)
		log = 1;
	else if (val < -eps)
		log = -1;
	else
		log = 0;
	return log;
}

// 两点间的距离的平方 
double point_dist(int m, int n)
{
	double xd, yd;
	xd = gra[m][0] - gra[n][0];
	yd = gra[m][1] - gra[n][1];
	return xd * xd + yd * yd;
}

// 判定n点是否可以作为最小凸多边形一边的一点，返回这一边的下一个点
int is_rim(int n)
{
	int i, j, fro = n + N, first, tap, loca1;
	int Tap[max_n];
	for (i = n + 1; i < N; ++i)
	{
		first = 1;
		double nid = point_dist(n, i);
		for (j = n; j < fro; ++j)
		{
			loca1 = j % N;
			Tap[loca1] = line_point(n, i, loca1);
			if (Tap[loca1] == 0)
			{
				if ((n != j && i != j) && (point_dist(n, j) > nid + eps || point_dist(i, j) > nid + eps))
					break;
			}
			else if (first)
			{
				tap = Tap[loca1];
				first = 0;
			}
			else if (Tap[loca1] != tap)
			{
				break;
			}
		}
		if (j == fro)
		{
			return i;
		}
	}
	return -1;
}

// 返回j点在直线ni的距离的平方 
double line_wid(int n, int i, int j)
{
	int x1, x2, y1, y2, x, y, log;
	double val;
	x = rim[j][0];
	y = rim[j][1];
	x2 = rim[n][0];
	y2 = rim[n][1];
	x1 = rim[i][0];
	y1 = rim[i][1];
	val = (x2 - x1) * y - (y2 - y1) * x + x1 * y2 - x2 * y1;
	val *= val;
	val /= ((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	return val;
}

// 以一边为基准，求其他所有点到这一边的最大距离
double rim_wid(int n)
{
	int j, fro, loca2;
	double max_wid = 0;
	fro = n + N2 - 1; //终止点，点n的前一个点(实际点还要取余) 
	for (j = n + 2; j <= fro; ++j)
	{
		loca2 = j % N2;
		max_wid = max(line_wid(n % N2, (n + 1) % N2, loca2), max_wid);
	}
	return max_wid;
}

本人能力欠缺，对比过别人的代码，如果是使用暴力算法貌似都比我写得短得多。
新代码是最近掌握了快排思想和分治思想， 闲暇时写出来的。对比时间复杂度确实很悬殊。虽然n^3的复杂度也能过，但精益求精总是好的。
这一次没时间，下次试试用python写个题目玩玩，其实排除包的影响外，做题重要的还是算法而不是语言，况且如果仅仅只是做题的话c++比python快得多。

妖怪无面男
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
我的第一篇博客文章
12-22
文章的元数据如标题、日期、置顶级别等，可以使用YAML头信息来定义，如在描述中看到的`title: 我的第一篇博客文章` 和 `top: 1`。 Markdown的简洁性和易读性使其成为撰写博客、文档和笔记的理想选择。通过掌握这些...
我的第一篇博客文章.md
03-26
综上所述，通过分析这篇博客文章的相关信息，我们可以了解到关于资源共享、数据通信的基础概念，Markdown语言及其编辑工具MarkdownPad2的使用方法，以及撰写技术博客的重要意义和个人品牌建立的方法。这些知识点对于...
第一篇博客（The First Blog）
Random的灯塔
11-30 447
这是我的第一篇博客！！！其实我就是测试一下……#include<iostream> int main() { std::cout<<"Hello CSDN!"; return 0; }
第一篇博客
远行客的博客
09-27 446
新人报道，希望以后多更
第一篇博客.doc
10-08
这是一篇不忘初心的博客。第一次写博客的我还是不那么从容。
我的CSDN博客md源码(第1~50篇)
05-05
这个资源中的内容，是我自己写的CSDN博客的前50篇的MarkDown源码，是为了方便需要转载的人对我的博客进行转载而创建的。 因为许多人转载后的博客都是直接暴力的复制粘贴，像LaTeX公式就失去了原来博客的效果（况且我...
我的第一博客
02-12
【标题】"我的第一博客"通常指的是初学者创建的第一个个人博客项目，这通常是学习Web开发技术，特别是前端设计的一个重要步骤。在这个项目中，开发者会接触到HTML、CSS以及可能的JavaScript，来构建一个简单的网页并...
倾斜一篇关于Matplotlib的博客
最新发布
03-25
# 在第一个子图中绘制一条线 axs[0, 0].plot(x, y) # 在第二个子图中绘制散点图 axs[0, 1].scatter(x, y) # 在第三个子图中绘制条形图 axs[1, 0].bar(x, y) # 在第四个子图中绘制饼图 axs[1, 1].pie(y) ``` 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值