UVa1111 - Trash Removal快速凸包o(nlogn)解决
Source: ACM/ICPC 2011WorldFinal
第一篇博客,唯独想表达的是我对算法的崇拜。 相比暴力算法,快速算法具很高的性能。在刷题的过程中寻找快速算法来解题是一件很有乐趣的事情。
题意:求一个能使输入的连线点集连成的封闭图形能够通过的最小距离。方法大致为求凸包,然后对凸包进行边遍历求凸包上到此边的最远顶点的最小值。
以下图形输入为A到Q的封闭图形
解法
快包算法(时间复杂度nlogn)
- 把所有的点都放在二维坐标系里面。那么横坐标最小的和最大的多个点一定是凸包上 的点。直线 AE, QI 把点集分成了三部分,中间部分舍弃,其他两部分分别叫做上包和下包。
- 对上包:求距离直线 AE 最远的点,即上图中的点 D 。
- 作直线 AD 、DE,把直线 AD左侧的点当成是上包,把直线 DE 右侧的点也当成是上包。
- 重复步骤 2、3。
- 对下包也作类似操作。
最终黑色的点表示被选中的凸包顶点即: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快得多。