hdu 2823 The widest road (Convex Hull)

http://acm.hdu.edu.cn/showproblem.php?pid=2823

　　应该是经典的凸包间最短距离的题目吧。印象中是用旋转卡壳来过的，不过我在hdu水了一下，一个暴力O(n^2)算法直接撸过。

　　我的做法很简单，就是先判断两个凸包是否相交或包含，然后就用点到线段距离枚举凸包间距离，加了一个遇到距离增加的时候剪枝就过了。

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

struct Point {
    double x, y;
    Point() { x = y = 0.0;}
    Point(double x, double y) : x(x), y(y) {}
} ;
template <class T> T sqr(T x) { return x * x;}
inline double ptDis(Point a, Point b) { return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));}

typedef Point Vec;
Vec operator + (Vec a, Vec b) { return Vec(a.x + b.x, a.y + b.y);}
Vec operator - (Vec a, Vec b) { return Vec(a.x - b.x, a.y - b.y);}
Vec operator * (Vec a, double p) { return Vec(a.x * p, a.y * p);}
Vec operator / (Vec a, double p) { return Vec(a.x / p, a.y / p);}

const double EPS = 1e-8;
const double PI = acos(-1.0);
inline int sgn(double x) { return fabs(x) < EPS ? 0 : (x < 0 ? -1 : 1);}
bool operator < (Point a, Point b) { return a.x < b.x || a.x == b.x && a.y < b.y;}
bool operator == (Point a, Point b) { return !sgn(a.x - b.x) && !sgn(a.y - b.y);}

inline double dotDet(Vec a, Vec b) { return a.x * b.x + a.y * b.y;}
inline double crossDet(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}
inline double crossDet(Point o, Point a, Point b) { return crossDet(a - o, b - o);}
inline double vecLen(Vec x) { return sqrt(dotDet(x, x));}

struct Line {
    Point s, t;
    Line() {}
    Line(Point s, Point t) : s(s), t(t) {}
} ;

inline int onSeg(Point x, Point a, Point b) { return sgn(crossDet(x, a, b)) == 0 && sgn(dotDet(a - x, b - x)) < 0;}

int segIntersect(Point a, Point c, Point b, Point d) {
    Vec v1 = b - a, v2 = c - b, v3 = d - c, v4 = a - d;
    int a_bc = sgn(crossDet(v1, v2));
    int b_cd = sgn(crossDet(v2, v3));
    int c_da = sgn(crossDet(v3, v4));
    int d_ab = sgn(crossDet(v4, v1));
    if (a_bc * c_da > 0 && b_cd * d_ab > 0) return 1;
    if (onSeg(b, a, c) && c_da) return 2;
    if (onSeg(c, b, d) && d_ab) return 2;
    if (onSeg(d, c, a) && a_bc) return 2;
    if (onSeg(a, d, b) && b_cd) return 2;
    return 0;
}

int andrew(Point *pt, int n, Point *ch) {
//    cout << "sort!!" << n << endl;
    sort(pt, pt + n);
    int m = 0;
//    cout << "here??" << endl;
    for (int i = 0; i < n; i++) {
        while (m > 1 && crossDet(ch[m - 2], ch[m - 1], pt[i]) <= 0) m--;
        ch[m++] = pt[i];
    }
    int k = m;
    for (int i = n - 2; i >= 0; i--) {
        while (m > k && crossDet(ch[m - 2], ch[m - 1], pt[i]) <= 0) m--;
        ch[m++] = pt[i];
    }
    if (n > 1) m--;
    return m;
}

int ptInPoly(Point p, Point *poly, int n) {
    int wn = 0;
    poly[n] = poly[0];
    for (int i = 0; i < n; i++) {
        if (onSeg(p, poly[i], poly[i + 1])) return -1;
        int k = sgn(crossDet(poly[i], poly[i + 1], p));
        int d1 = sgn(poly[i].y - p.y);
        int d2 = sgn(poly[i + 1].y - p.y);
        if (k > 0 && d1 <= 0 && d2 > 0) wn++;
        if (k < 0 && d2 <= 0 && d1 > 0) wn--;
    }
    if (wn != 0) return 1;
    return 0;
}

const int N = 1111;
Point pt[2][N], ch[2][N];

bool polyApart(Point *a, int n, Point *b, int m) {
    a[n] = a[0], b[m] = b[0];
    for (int i = 0; i < n; i++) if (ptInPoly(a[i], b, m)) return false;
    for (int i = 0; i < m; i++) if (ptInPoly(b[i], a, n)) return false;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (segIntersect(a[i], a[i + 1], b[j], b[j + 1])) return false;
        }
    }
    return true;
}

double pt2Line(Point x, Point a, Point b) {
    Vec v1 = b - a, v2 = x - a;
    return crossDet(v1, v2) / vecLen(v1);
}

double pt2Seg(Point x, Point a, Point b) {
    if (a == b) return vecLen(x - a);
    Vec v1 = b - a, v2 = x - a, v3 = x - b;
    if (sgn(dotDet(v1, v2)) < 0) return vecLen(v2);
    if (sgn(dotDet(v1, v3)) > 0) return vecLen(v3);
    return fabs(crossDet(v1, v2)) / vecLen(v1);
}

const double FINF = 1e100;

double polyDis(Point *a, int n, Point *b, int m) {
    if (!polyApart(a, n, b, m)) return 0.0;
    a[n] = a[0], b[m] = b[0];
    double mini = FINF;
    for (int i = 0; i < n; i++) {
        double last, cur;
        for (int j = 0; j < m; j++) {
            cur = pt2Seg(b[j], a[i], a[i + 1]);
            mini = min(mini, cur);
            if (j && last < cur) break;
            last = cur;
        }
    }
    for (int i = 0; i < m; i++) {
        double last, cur;
        for (int j = 0; j < n; j++) {
            cur = pt2Seg(a[j], b[i], b[i + 1]);
            mini = min(mini, cur);
            if (j && last < cur) break;
            last = cur;
        }
    }
    return mini;
}

int main() {
//    freopen("in", "r", stdin);
    int n[2];
    while (~scanf("%d%d", &n[0], &n[1])) {
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < n[i]; j++) {
                scanf("%lf%lf", &pt[i][j].x, &pt[i][j].y);
            }
            n[i] = andrew(pt[i], n[i], ch[i]);
        }
        printf("%.4f\n", polyDis(ch[0], n[0], ch[1], n[1]));
    }
    return 0;
}

——written by Lyon