题意：从(0, 5)走到(10, 5)，中间有一些门，走的路是直线，问最短的距离
分析：关键是建图，可以保存所有的点，两点连通的条件是线段和中间的线段都不相交，建立有向图，然后用Dijkstra跑最短路。好题！
/************************************************
* Author :Running_Time
* Created Time :2015/10/24 星期六 09:48:49
* File Name :POJ_1556.cpp
************************************************/ #include <cstdio>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <bitset>
#include <cstdlib>
#include <ctime>
using namespace std; #define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
typedef long long ll;
const int N = 300;
const int E = N * N;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
struct Point { //点的定义
double x, y;
Point (double x=0, double y=0) : x (x), y (y) {}
};
typedef Point Vector; //向量的定义
Point read_point(void) { //点的读入
double x, y;
scanf ("%lf%lf", &x, &y);
return Point (x, y);
}
double polar_angle(Vector A) { //向量极角
return atan2 (A.y, A.x);
}
double dot(Vector A, Vector B) { //向量点积
return A.x * B.x + A.y * B.y;
}
double cross(Vector A, Vector B) { //向量叉积
return A.x * B.y - A.y * B.x;
}
int dcmp(double x) { //三态函数，减少精度问题
if (fabs (x) < EPS) return 0;
else return x < 0 ? -1 : 1;
}
Vector operator + (Vector A, Vector B) { //向量加法
return Vector (A.x + B.x, A.y + B.y);
}
Vector operator - (Vector A, Vector B) { //向量减法
return Vector (A.x - B.x, A.y - B.y);
}
Vector operator * (Vector A, double p) { //向量乘以标量
return Vector (A.x * p, A.y * p);
}
Vector operator / (Vector A, double p) { //向量除以标量
return Vector (A.x / p, A.y / p);
}
bool operator < (const Point &a, const Point &b) { //点的坐标排序
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
bool operator == (const Point &a, const Point &b) { //判断同一个点
return dcmp (a.x - b.x) == 0 && dcmp (a.y - b.y) == 0;
}
double length(Vector A) { //向量长度，点积
return sqrt (dot (A, A));
}
double angle(Vector A, Vector B) { //向量转角，逆时针，点积
return acos (dot (A, B) / length (A) / length (B));
}
double area_triangle(Point a, Point b, Point c) { //三角形面积，叉积
return fabs (cross (b - a, c - a)) / 2.0;
}
Vector rotate(Vector A, double rad) { //向量旋转，逆时针
return Vector (A.x * cos (rad) - A.y * sin (rad), A.x * sin (rad) + A.y * cos (rad));
}
Vector nomal(Vector A) { //向量的单位法向量
double len = length (A);
return Vector (-A.y / len, A.x / len);
}
Point point_inter(Point p, Vector V, Point q, Vector W) { //两直线交点，参数方程
Vector U = p - q;
double t = cross (W, U) / cross (V, W);
return p + V * t;
}
double dis_to_line(Point p, Point a, Point b) { //点到直线的距离，两点式
Vector V1 = b - a, V2 = p - a;
return fabs (cross (V1, V2)) / length (V1);
}
double dis_to_seg(Point p, Point a, Point b) { //点到线段的距离，两点式 if (a == b) return length (p - a);
Vector V1 = b - a, V2 = p - a, V3 = p - b;
if (dcmp (dot (V1, V2)) < 0) return length (V2);
else if (dcmp (dot (V1, V3)) > 0) return length (V3);
else return fabs (cross (V1, V2)) / length (V1);
}
Point point_proj(Point p, Point a, Point b) { //点在直线上的投影，两点式
Vector V = b - a;
return a + V * (dot (V, p - a) / dot (V, V));
}
bool inter(Point a1, Point a2, Point b1, Point b2) { //判断线段相交，两点式
double c1 = cross (a2 - a1, b1 - a1), c2 = cross (a2 - a1, b2 - a1),
c3 = cross (b2 - b1, a1 - b1), c4 = cross (b2 - b1, a2 - b1);
return dcmp (c1) * dcmp (c2) < 0 && dcmp (c3) * dcmp (c4) < 0;
}
bool on_seg(Point p, Point a1, Point a2) { //判断点在线段上，两点式
return dcmp (cross (a1 - p, a2 - p)) == 0 && dcmp (dot (a1 - p, a2 - p)) < 0;
}
double area_poly(Point *p, int n) { //多边形面积
double ret = 0;
for (int i=1; i<n-1; ++i) {
ret += fabs (cross (p[i] - p[0], p[i+1] - p[0]));
}
return ret / 2;
}
struct Edge {
int v, nex;
double w;
Edge () {}
Edge (int v, double w, int nex) : v (v), w (w), nex (nex) {}
bool operator < (const Edge &r) const {
return w > r.w;
}
}edge[E];
double d[N];
int head[N];
bool vis[N];
int n, tot, e; void init(void) {
memset (head, -1, sizeof (head));
e = 0;
} void add_edge(int u, int v, double w) {
edge[e] = Edge (v, w, head[u]);
head[u] = e++;
} void Dijkstra(int s) {
memset (vis, false, sizeof (vis));
for (int i=0; i<tot; ++i) {
d[i] = 1e9;
}
d[s] = 0;
priority_queue<Edge> Q; Q.push (Edge (s, d[s], 0));
while (!Q.empty ()) {
int u = Q.top ().v; Q.pop ();
if (vis[u]) continue;
vis[u] = true;
for (int i=head[u]; ~i; i=edge[i].nex) {
int v = edge[i].v;
double w = edge[i].w;
if (!vis[v] && d[v] > d[u] + w) {
d[v] = d[u] + w;
Q.push (Edge (v, d[v], 0));
}
}
}
} Point P[N]; int main(void) {
while (scanf ("%d", &n) == 1) {
if (n == -1) break;
init ();
tot = 0; double x, y1, y2, y3, y4;
P[tot++] = Point (0, 5);
for (int i=0; i<n; ++i) {
scanf ("%lf%lf%lf%lf%lf", &x, &y1, &y2, &y3, &y4);
P[tot++] = Point (x, y1);
P[tot++] = Point (x, y2);
P[tot++] = Point (x, y3);
P[tot++] = Point (x, y4);
}
P[tot++] = Point (10, 5); for (int i=0; i<tot; ++i) {
for (int j=i+1; j<tot; ++j) {
if (P[i].x == P[j].x) continue;
bool flag = true;
for (int k=i+1; k<j; ++k) {
if (P[k].x == P[i].x || P[k].x == P[j].x) continue;
if (k % 4 == 1) {
if (inter (P[i], P[j], P[k], Point (P[k].x, 0))) {
flag = false; break;
}
}
else if (k % 4 == 0) {
if (inter (P[i], P[j], P[k], Point (P[k].x, 10))) {
flag = false; break;
}
}
else if (k % 4 == 2) {
if (inter (P[i], P[j], P[k], P[k+1])) {
flag = false; break;
}
}
else if (k % 4 == 3) {
if (inter (P[i], P[j], P[k], P[k-1])) {
flag = false; break;
}
}
}
if (flag) {
add_edge (i, j, length (P[j] - P[i]));
}
}
} Dijkstra (0);
printf ("%.2f\n", d[tot-1]);
} return 0;
}