POJ 3608 puente a través de islas (paquete distancia más corta entre dos convexa de rotación mermelada +)

Título: Portal

 

clásico título

 

La mayor parte del código de referencia: kuangbin

 

#include <iostream> 
#include <stdio.h> 
#include < string .h> 
#include <algoritmo> 
#include <cola> 
#include <mapa> 
#include <vector> 
#include < conjunto > 
#include < string > 
# incluir <math.h>
 #define LL largo largo
 #define mem (i, j) memset (i, j, sizeof (i))
 #define rep (i, j, k) for (int i = j; i <= k; i ++)
 #define dep (i, j, k) for (int i = k; i> = j; i--)
 #define pb push_back
 #definela make_pair la marca
 #define INF INT_MAX
 #define INF LLONG_MAX
 #define la PI ACOS (-1)
 el uso de  espacio de nombres STD; 

const  int N = 5E5 + . 5 ; 

struct Point {
     Doble X, Y; 
    Point ( Doble X = 0 , Doble Y = 0 ) : X (X), Y (Y) {} /// constructor 
}; 

typedef punto el vector; 
/// vector + vector = vector + vector = punto de vector 
del vector operador + (el vector A, el vector B) { volver el vector (+ Ax de Bx, Ay + By);}
/// punto - punto = vector de 
la Vector operador - (Punto A, Punto B) { devolver el vector (Ax de - Bx, Ay - By);}
 /// vector * número vector = 
el Vector operador * (el vector A, Doble P) { volver el vector (Ax de P *, Ay * P);}
 /// vector / vector de número = 
el vector de operador / (el vector A, doble P) { volver el vector (Ax de / P, Ay / P);} 

const  doble EPS = 1E- . 8 ;
 int dCMP ( doble X) {
     IF (FABS (X) <EPS) de retorno 0 ; otra  vuelta x < 0 ? - 1 : 1 ; 
} 

Bool  operador <( const Point & a, const Point & b) {
     retorno ax bx ==? ay <por: ax < bx; 
} 

Bool  operador == ( const Point & a, const Point & b) {
     retorno DCMP (ax - bx) == 0 && DCMP (ay - por) == 0 ; 
} 

Doble Dot (Vector A, Vector B) { regreso Ax * Bx + Ay * Por; }// producto de punto 
doble de la longitud (el vector A) { retorno sqrt ( 1,0 * Dot (A, A));} /// calculado vector longitud 
doble ángulo (el vector A, el vector B) { retorno ACOS (Dot (A, B ) / la longitud (A) / de la longitud (B));} /// vector A, el ángulo B 
Double Cross (el vector A, el vector B) { regreso Ax de * By - Ay * Bx;} /// producto cruzado 

int , ConvexHull (Point * P, int n-, Point * CH) { 
    Sort (P, P + n-);
     int m = 0 ; 
    REP (I, 0 , n-- . 1 ) {
        mientras que (m> 1 && Cross (ch [m - 1 ] - ch [m - 2 ], p [i] - ch [m - 2 ]) <= 0 ) M-- ; 
        ch [m ++] = p [i]; 
    } 
    Int k = m; 
    dep (i, 0 , n - 2 ) {
         mientras que (m> k && Cross (ch [m - 1 ] - ch [m - 2 ], p [i] - ch [m - 2 ]) <= 0 ) m - ; 
        ch [m ++] = p [i]; 
    } 
    Si (n> 1 ) M-- ;
    retorno m; 
} 

doble del (p Point, Punto A, Punto B) PTS { /// encontrar el punto p al segmento de línea AB distancia más corta 
    SI (A == B) devolver la longitud (P - A); 
    Punto V1 = B - A , V2 = P - A, V3 = P - B;
     IF (dCMP (Dot (V1, V2)) < 0 ) devolver la longitud (V2);
     el otro  IF (dCMP (Dot (V1, V3))> 0 ) devolver la Longitud (V3);
     else  retorno FABS (Cross (V1, V2)) / el cuerpo entero (V1); 
} 
/ * distancia paralela al segmento de línea B1B2 A1A2 y * / 
dobleDS (a1 Point, punto a2, Point b1, Point b2) {
     retorno min (PTS (b1, a1, a2), min (PTS (b2, a1, a2), min (PTS (a1, b1, b2), PTS (a2, b1, b2)))); 
} 

/ * 得到向量A1A2和B1B2的位置关系* / 
doble Get_angle (Point a1, a2 Point, Punto de b1, b2 Point) { 
    Point t = b1 - (b2 - a1);
    retorno de la Cruz (A2 - A1, t - a1); 
} 

Dobles Rotating_calipers (Point P [], int n, Point Q [], int m) {
     int POSP = 0 , posq = 0 ; 

    rep (i, 0 , n - 1 ) si(DCMP (P [i] .y - P [POSP] .y) < 0 ) POSP = i; 
    rep (i, 0 , m - 1 ) si (DCMP (Q [i] .y - Q [posq] .y)> 0 ) posq = i; 

    doble tmp, ans = 1E99; 

    rep (i, 0 , n - 1 ) {
         mientras que (DCMP (tmp = Get_angle (P [POSP], P [(POSP + 1 )% n], Q [posq], Q [(posq + 1 )% m] )) < 0 ) 
            posq = (posq + 1 )% m;
        si (DCMP (TMP) == 0 ) 
            ans= Min (ans, DS (P [POSP], P [(POSP + 1 )% n], Q [posq], Q [(posq + 1 )% m]));
        más 
            ans = min (ans, PTS (Q [posq], P [POSP], P [(POSP + 1 )% n])); 
        POSP = (POSP + 1 )% n; 
    } 

    Devolver ans; 
} 

Point P [N], Q [N], p [N], q [N]; 

int main () {
     int n, m;
    mientras que (scanf ( " d% d% " , y n, y m) && n + m) { 

        rep (i, 0 , n - 1 ) scanf ( "% Si% LF "& p [i] .x, y p [i] .y); 
        rep (i, 0 , m - 1 ) scanf ( " % lf% LF " , y q [i] .x, y q [i] .y); 

        n = ConvexHull (p, n, P); 
        m = ConvexHull (q, m, q); 

        doble ans = min (Rotating_calipers (P, N, q, m), Rotating_calipers (q, m , P, n)); 

        printf ( " % .5f \ n " , ans); 

    } 
    retorno  0 ; 
}