## Description:

Two experienced climbers are planning a first-ever attempt: they start at two points of the equal altitudes on a mountain range, move back and forth on a single route keeping their altitudes equal, and finally meet with each other at a point on the route. A wise man told them that if a route has no point lower than the start points (of the equal altitudes) there is at least a way to achieve the attempt. This is the reason why the two climbers dare to start planning this fancy attempt.

The two climbers already obtained altimeters (devices that indicate altitude) and communication devices that are needed for keeping their altitudes equal. They also picked up a candidate route for the attempt: the route consists of consequent line segments without branches; the two starting points are at the two ends of the route; there is no point lower than the two starting points of the equal altitudes. An illustration of the route is given in Figure E.1 (this figure corresponds to the first dataset of the sample input).

Figure E.1: An illustration of a route

The attempt should be possible for the route as the wise man said. The two climbers, however, could not find a pair of move sequences to achieve the attempt, because they cannot keep their altitudes equal without a complex combination of both forward and backward moves. For example, for the route illustrated above: a climber starting at p1 (say A) moves to s, and the other climber (say B) moves from p6 to p5; then A moves back to t while B moves to p4; finally A arrives at p3 and at the same time B also arrives at p3. Things can be much more complicated and thus they asked you to write a program to find a pair of move sequences for them.

There may exist more than one possible pair of move sequences, and thus you are requested to find the pair of move sequences with the shortest length sum. Here, we measure the length along the route surface, i.e., an uphill path from (0, 0) to (3, 4) has the length of 5.

## Input:

The input is a sequence of datasets.

The first line of each dataset has an integer indicating the number of points N (2 ≤ N ≤ 100) on the route. Each of the following N lines has the coordinates (xi, yi) (i = 1, 2, ... , N) of the points: the two start points are (x1, y1) and (xN, yN); the line segments of the route connect (xi, yi) and (xi+1, yi+1) for i = 1, 2, ... , N - 1. Here, xi is the horizontal distance along the route from the start point x1, and yi is the altitude relative to the start point y1. All the coordinates are non-negative integers smaller than 1000, and inequality xi < xi+1holds for i = 1, 2, .. , N - 1, and 0 = y1 = yN ≤ yi for i = 2, 3, ... , N - 1.

The end of the input is indicated by a line containing a zero.

## Output:

For each dataset, output the minimum sum of lengths (along the route) of move sequences until the two climbers meet with each other at a point on the route. Each output value may not have an error greater than 0.01.

## Sample Input:

6

0 0

3 4

9 12

17 6

21 9

33 0

5

0 0

10 0

20 0

30 0

40 0

10

0 0

1 2

3 0

6 3

9 0

11 2

13 0

15 2

16 2

18 0

7

0 0

150 997

300 1

450 999

600 2

750 998

900 0

0

## Sample Output:

52.5

40.0

30.3356209304689

10078.072814085803

### 题目链接

n个点组成一段折线，折现两端(均为折线最低点)有两个人，要求两人每时每刻都必须处于同一高度，求两人碰面所走的最短路程之和。

在n个点的高度上做水平线，求出与折线中所有线段的交点加入点集之中，将点集按照横坐标升序排序，之后从左右两点bfs寻找相遇路径，对于左右两点来说每次可走点集中相邻点或者不移动(同时不移动没有意义)，若两点移动后高度相同即可移动，直到搜索到左右两点相同即可。

## AC代码:

```
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 5;
struct Point {
double X, Y;
void Input() {
scanf("%lf%lf", &X, &Y);
}
void Output() {
printf("(%lf,%lf)", X, Y);
}
Point operator - (const Point &B) const {
return Point {X - B.X, Y - B.Y};
}
double operator * (const Point &B) const {
return X * B.X + Y * B.Y;
}
double operator ^ (const Point &B) const {
return X * B.Y - Y * B.X;
}
bool operator < (const Point &B) const {
return X < B.X;
}
};
double Distance(Point A, Point B) {
return sqrt((B - A) * (B - A));
}
struct Line {
Point S, T;
void Input() {
S.Input();
T.Input();
}
Point operator & (const Line &B) const {
double Temp = ((S - B.S) ^ (B.S - B.T)) / ((S - T) ^ (B.S - B.T));
return Point {S.X + (T.X - S.X) * Temp, S.Y + (T.Y - S.Y) * Temp};
}
};
struct Statu {
int Left, Right;
double Length;
bool operator < (const Statu &B) const {
return Length > B.Length;
}
};
int N;
int Tot;
Point points[maxn];
set<pair<int, int> > Vis;
void Init() {
for (int i = 0; i < N; ++i) {
double Height = points[i].Y;
Line SkyLine = Line {Point {-1005.0, Height}, Point {1005.0, Height}};
for (int j = 0; j < N - 1; ++j) {
if ((Height - points[j].Y) * (Height - points[j + 1].Y) < 0) {
points[Tot++] = SkyLine & Line {points[j], points[j + 1]};
}
}
}
sort(points, points + Tot);
}
double Bfs() {
Vis.clear();
priority_queue<Statu> Que;
Que.push(Statu {0, Tot - 1, 0.0});
while (!Que.empty()) {
Statu Cur = Que.top(); Que.pop();
if (Cur.Left == Cur.Right) {
return Cur.Length;
}
if (Vis.find(make_pair(Cur.Left, Cur.Right)) != Vis.end()) {
continue;
}
Vis.insert(make_pair(Cur.Left, Cur.Right));
for (int i = -1; i < 2; ++i) {
for (int j = -1; j < 2; ++j) {
if (i || j) {
int LeftIndex = Cur.Left + i, RightIndex = Cur.Right + j;
if (LeftIndex >= 0 && LeftIndex < Tot && RightIndex >= 0 && RightIndex < Tot) {
if (points[LeftIndex].Y == points[RightIndex].Y) {
Que.push(Statu {LeftIndex, RightIndex, Cur.Length + Distance(points[Cur.Left], points[LeftIndex]) + Distance(points[Cur.Right], points[RightIndex])});
}
}
}
}
}
}
return 0.0;
}
int main(int argc, char *argv[]) {
while (~scanf("%d", &N) && N) {
Tot = 0;
for (int i = 0; i < N; ++i) {
points[Tot++].Input();
}
Init();
printf("%.10lf\n", Bfs());
}
return 0;
}
```