URAL 1205 By the Underground or by Foot (建图 + Dijkstra + 堆优化)

#include <stdio.h>
#include <math.h>
#define INF (1 << 30)

double footSpeed, undergroundSpeed;
int numOfStations;
int start, end;
typedef struct Coordinates{
double x;
double y;
}Cooridnates;
Coordinates CoordinatesArray[300];
double timeArray[300][300];
double minTimeArray[300];
int stack[300];
int top;
int pre[300];
int heapSize;
typedef struct Node{
double minTime;
int location;
}Node;
Node heap[300];

double getDistance(Coordinates one, Coordinates another){
double deltaX = one.x - another.x;
double deltaY = one.y - another.y;
return sqrt(deltaX * deltaX + deltaY * deltaY);
}

void swap(Node *a, Node *b){
Node c = *a;
*a = *b;
*b = c;
}

void heapDecreaseKey(int NodeIndex,double minTime){
heap[NodeIndex].minTime = minTime;
while (NodeIndex > 1 && heap[NodeIndex].minTime < heap[ NodeIndex >> 1 ].minTime){
swap(&heap[NodeIndex], &heap[ NodeIndex >> 1 ]);
NodeIndex = NodeIndex >> 1;
}
}

void minHeapify(int parent){
int least = parent;
int left = parent << 1;
if (left <= heapSize && heap[left].minTime < heap[least].minTime)
least = left;
int right = (parent << 1) + 1;
if (right <= heapSize && heap[right].minTime < heap[least].minTime)
least = right;
if (least != parent){
swap(&heap[parent], &heap[least]);
minHeapify(least);
}
}

void buildMinHeap(){
int to;
for (to = heapSize >> 1; to >= 1; to--)
minHeapify(to);
}

double getMinTimeByDijkstra(){
heapSize = 0;
int to;
for (to = 1; to <= end; to++){
if (to != start){
heapSize++;
heap[heapSize].minTime = timeArray[start][to];
heap[heapSize].location = to;
}
}

buildMinHeap();

int numOfMinTimesFound;
for (numOfMinTimesFound = 2; numOfMinTimesFound <= end; numOfMinTimesFound){
double minTime = heap[1].minTime;
int location = heap[1].location;
if (location == end)
return minTime;
swap(&heap[1], &heap[heapSize]);
heapSize--;
int NodeIndex;
for (NodeIndex = 1; NodeIndex <= heapSize; NodeIndex++){
Node tempNode = heap[NodeIndex];
if (minTime + timeArray[location][tempNode.location] < tempNode.minTime){
heapDecreaseKey(NodeIndex, minTime + timeArray[location][tempNode.location]);
pre[tempNode.location] = location;
}
}
minHeapify(1);
}

}

int main(){

scanf("%lf%lf", &footSpeed, &undergroundSpeed);

scanf("%d", &numOfStations);
int station;
for (station = 1; station <= numOfStations; station++){
Coordinates tempCoordinates;
scanf("%lf%lf", &tempCoordinates.x, &tempCoordinates.y);
CoordinatesArray[station] = tempCoordinates;
}

int from, to;
for (from = 1; from <= numOfStations; from++)
for (to = from + 1; to <= numOfStations; to++)
//注意：默认可以从一个车站步行到另一个车站
timeArray[from][to] = timeArray[to][from] = getDistance(CoordinatesArray[from], CoordinatesArray[to]) / footSpeed;

while (scanf("%d%d", &from, &to) != EOF && (from != 0 && to != 0) )
timeArray[from][to] = timeArray[to][from] = getDistance(CoordinatesArray[from], CoordinatesArray[to]) / undergroundSpeed;

start = numOfStations + 1;
end = numOfStations + 2;
scanf("%lf%lf", &CoordinatesArray[start].x, &CoordinatesArray[start].y);
scanf("%lf%lf", &CoordinatesArray[end].x, &CoordinatesArray[end].y);
int location;
for (location = 1; location <= end; location++){
timeArray[start][location] = timeArray[location][start] = getDistance(CoordinatesArray[start], CoordinatesArray[location]) / footSpeed;
timeArray[end][location] = timeArray[location][end] = getDistance(CoordinatesArray[end], CoordinatesArray[location]) / footSpeed;
}

//注意输出精度
printf("%.10lf\n", getMinTimeByDijkstra());

int preLocation = pre[end];
while (preLocation != 0){
stack[++top] = preLocation;
preLocation = pre[preLocation];
}

printf("%d", top);
while (top > 0)
printf(" %d", stack[top--]);
printf("\n");

return 0;
}