POJ1556 The Doors（线段与线段相交，Dijkstra）

题目链接：

　　http://poj.org/problem?id=1556

题目描述：

The Doors

 

Description

You are to find the length of the shortest path through a chamber containing obstructing walls. The chamber will always have sides at x = 0, x = 10, y = 0, and y = 10. The initial and final points of the path are always (0, 5) and (10, 5). There will also be from 0 to 18 vertical walls inside the chamber, each with two doorways. The figure below illustrates such a chamber and also shows the path of minimal length. 

Input

The input data for the illustrated chamber would appear as follows. 

2 
4 2 7 8 9 
7 3 4.5 6 7 

The first line contains the number of interior walls. Then there is a line for each such wall, containing five real numbers. The first number is the x coordinate of the wall (0 < x < 10), and the remaining four are the y coordinates of the ends of the doorways in that wall. The x coordinates of the walls are in increasing order, and within each line the y coordinates are in increasing order. The input file will contain at least one such set of data. The end of the data comes when the number of walls is -1. 

Output

The output should contain one line of output for each chamber. The line should contain the minimal path length rounded to two decimal places past the decimal point, and always showing the two decimal places past the decimal point. The line should contain no blanks.

Sample Input

1
5 4 6 7 8
2
4 2 7 8 9
7 3 4.5 6 7
-1

Sample Output

10.00
10.06

题目大意：

　　给定一块（0，0）与（10，10）之间的区域，中间有垂直的挡板，问从（0，5）到（10，5）的最短路径

思路：

　　把起点终点和各挡板端点作为顶点建图，对点之间两两建线段，判断是否与挡板（线段）有交点，若无交点则建一条有向边，最后Dijkstra求最短路

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <utility>
#include <functional>
using namespace std;

typedef pair<double, int> pii;

const int INF = 0x3f3f3f3f;
const int N = 10010;

const double EPS = 1e-10;    //精度系数

struct Edge {
    int v, next;
    double val;
    Edge(int v = 0, double val = 0, int next = 0) :v(v), val(val), next(next) {}
}e[N];

struct Point {
    double x, y;
    Point(double x = 0, double y = 0) :x(x), y(y) {}
};    //点的定义

typedef Point Vector;    //向量的定义

Vector operator - (Vector A, Vector B) { return Vector(A.x - B.x, A.y - B.y); }    //向量减法

int head[N], id, ED;
bool vis[N];
Point P[N];
double x[N], y[N][4], d[N];

inline void addedge(int u, int v, double val) {
    e[++id].v = v;
    e[id].val = val;
    e[id].next = head[u];
    head[u] = id;
}

void Dijkstra_heap(int s) {
    priority_queue<pii, vector<pii>, greater<pii> > Q;
    for (int i = 0; i <= ED; ++i)d[i] = INF;
    d[s] = 0;
    memset(vis, false, sizeof(vis));
    Q.push(make_pair(d[s], s));
    while (!Q.empty()) {
        pii tmp = Q.top();
        Q.pop();
        int x = tmp.second;
        if (vis[x]) continue;
        vis[x] = true;
        if (x == ED)return;
        for (int i = head[x]; i; i = e[i].next)
            if (d[e[i].v] > d[x] + e[i].val) {
                d[e[i].v] = d[x] + e[i].val;
                Q.push(make_pair(d[e[i].v], e[i].v));
            }
    }
}

int dcmp(double x) {
    if (fabs(x) < EPS)return 0; else return x < 0 ? -1 : 1;
}    //与0的关系

double Cross(Vector A, Vector B) { return A.x*B.y - A.y*B.x; }    //向量叉乘

bool SegmentProperIntersection(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;
}    //判断两线段相交（恰有一个公共点且不在端点）

double Dis(Point& a, Point& b) {
    return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}    //两点距离

bool ok(int k, int m, int t) {
    double l = P[k].x, r = P[m].x;
    for (int i = 0; i < t; ++i)if (l < x[i] && x[i] < r) {
        bool flag = false;
        flag |= SegmentProperIntersection(P[k], P[m], Point(x[i], 0), Point(x[i], y[i][0]));
        flag |= SegmentProperIntersection(P[k], P[m], Point(x[i], y[i][1]), Point(x[i], y[i][2]));
        flag |= SegmentProperIntersection(P[k], P[m], Point(x[i], y[i][3]), Point(x[i], 10));
        if (flag)return false;
    }
    return true;
}    //两点之间是否有线段

int main() {
    int n;
    while (cin >> n && n != -1) {
        memset(head, 0, sizeof(head));
        id = 0;
        ED = 4 * n + 1;
        P[0] = Point(0, 5);
        P[ED] = Point(10, 5);
        for (int i = 0; i < n; ++i) {
            scanf("%lf", &x[i]);
            for (int j = 0; j < 4; ++j) {
                int m = 4 * i + j + 1;
                scanf("%lf", &y[i][j]);
                P[m].x = x[i], P[m].y = y[i][j];
                for (int k = 0; k < 4 * i + 1; ++k)    //判断之前的点到当前点是否有边
                    if (ok(k, m, i))addedge(k, m, Dis(P[k], P[m]));
            }
        }
        for (int k = 0; k < 4 * n + 1; ++k)    //判断之前的点到终点是否有边
            if (ok(k, ED, n))addedge(k, ED, Dis(P[k], P[ED]));
        Dijkstra_heap(0);    //Dijkstra求最短路
        printf("%.2lf\n", d[ED]);
    }
}