中国大学MOOC-数据结构基础习题集、06-1、Saving James Bond

题目链接：http://www.patest.cn/contests/mooc-ds/06-1

题目分析：这是一道考察图的广度优先遍历，同时也要借助于Dijstra算法的一道题。题目的背景与上周的05-2是相同的：007被困在一个孤岛上，孤岛的直径是15，池塘的范围是[±50, ±50]。池塘中鳄鱼的条数及坐标，007的跳跃半径通过输入给出。问007能否借助于池塘中的鳄鱼逃出生天？和上周要求不同的是，需要把最短路径长度及最短路径输出，在有多条最短路径的情况下，输出第一跳最近的那条。

特别说明：

　　1. 是否建立图随意，用若干个数组表示也可以。博主最开始是没有建的，但是这次贴的代码是建好图的（邻接表）。一方面是为了练习自己的编码能力，一方面也是给对建图不熟悉的同学们举个“栗子”。感兴趣的同学可以关注下103~158行。

　　2. 题目中要求“多条最短路径输出第一跳最近的那条”，博主查找了许多别的资料，最后使用的优先级队列。使用时需要重载小于运算符（即operator<）。将在孤岛上能踩到的所有鳄鱼结点，以距孤岛中心的距离为优先级，放入优先级队列中。然后依次取出，做广度优先遍历。这部分在165~180+行。

　　3. 在做广度优先遍历时，如果已经可以逃脱，要确定当前是否为最短路径，是则记录路径。可以关注一下198~215行。

　　4. 求两点间距离的函数，要判断其中一点是不是“岛屿”，如果是的话，结果要加上孤岛的半径。函数的定义在63~78行。

　　5. 如果Case4过不去的朋友，请试一下我的用例1。如果是Case5过不去的朋友，请试一我的用例2。

建议测试如下数据：　

　　4 20 -27 0 -41 0 0 26 0 40

　　博主这里输出结果是：3 0 26 0 40

　　1 42.5

　　博主这里输出结果是：1

代码分析：

　　注释写的非常详细，大家可以阅读一下：

#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>

using namespace std;

/*
 * 所用结构体的声明
 * pos 坐标结构体
 * vexNode 邻接表中的结点
 */
struct pos;
template <class T> struct vexNode;

/*
 * 宏定义的声明
 * FIRSTSTEP 小岛的半径，固定为7.5
 * BORDER 边界的大小，固定为50
 * MAXNUM 无穷大
 */

#define FIRSTSTEP 7.5
#define BORDER 50
#define MAXNUM 100000000

/*
 * 全局变量的声明
 * vec 存储鳄鱼的坐标
 * eVec 邻接表存储图
 * pathVec 用来存储路径
 */

vector<pos> vec;
vector<vexNode<int> > eVec;
vector<int> pathVec;

struct pos
{
    double x;
    double y;
    pos(double a, double b):x(a),y(b) {}
};

template <class T>
struct vexNode
{
    T data;
    vexNode<T> *next;
    vexNode(T d, vexNode<T> *n = NULL):data(d), next(n) {}
    bool friend operator<(const vexNode &a, const vexNode &b)
    {
        int V = a.data;
        int W = b.data;
        int dV = vec[V].x * vec[V].x + vec[V].y * vec[V].y;
        int dW = vec[W].x * vec[W].x + vec[W].y * vec[W].y;
        return dV < dW; // 出队先出大的，再出小的
    }
};

/*
 * 计算两点之间的距离
 */
double Distance(pos p1, pos p2, int dis)
{
    double xx = (p1.x - p2.x) * (p1.x - p2.x);
    double yy = (p1.y - p2.y) * (p1.y - p2.y);
    if((p1.x == 0 && p1.y == 0) || (p2.x == 0 && p2.y == 0))
    {
        return dis + FIRSTSTEP - sqrt(xx + yy);
    }
    else
    {
        return dis - sqrt(xx + yy);
    }
}

/*
 * 获得路径
 */
vector<int> getPath(int t, int p[])
{
    vector<int> path;
    for(; t!=-1; t=p[t])
        path.push_back(t);
    reverse(path.begin(),path.end());
    return path;
}

int main()
{
    int nNum;
    double dis;
    cin >> nNum >> dis;
    // 考虑特殊情况，能否一步迈出
    if(dis + FIRSTSTEP >= BORDER)
    {
        cout << "1" << endl;
        return 0;
    }
    // 起始点（小岛）也算一个点
    vec.push_back(pos(0, 0));
    eVec.push_back(vexNode<int>(0));
    nNum ++;
    // 用邻接表存储图
    for(int i=1; i<nNum; i++)
    {
        double a, b;
        cin >> a >> b;
        vec.push_back(pos(a,b));
        eVec.push_back(vexNode<int>(i));
    }
    // 开始建图
    for(int i=0; i<nNum; i++)
    {
        for(int j=0; j<nNum; j++)
        {
            if(i != j)
            {
                if(Distance(vec[i], vec[j], dis) >= 0)
                {
                    // 查一查有没有重复的
                    bool myIFlag = false;
                    vexNode<int> *p = &eVec[i];
                    while(p -> next != NULL)
                    {
                        p = p -> next;
                        if(p -> data == j)
                        {
                            myIFlag = true;
                            break;
                        }
                    }
                    // 如果没有重复的，就插在最后边
                    if(myIFlag == false)
                        p -> next = new vexNode<int>(j);

                    // 因为是无向图，也就是双向图，所以另一侧也要插
                    bool myJFlag = false;
                    vexNode<int> *q = &eVec[j];
                    while(q -> next != NULL)
                    {
                        q = q -> next;
                        if(q -> data == i)
                        {
                            myJFlag = true;
                            break;
                        }
                    }
                    // 如果没有重复的，就插在最后边
                    if(myJFlag == false)
                        q -> next = new vexNode<int>(i);
                }
            }
        }
    }
    // 相关数据结构的申请
    int *dist = new int[nNum];
    int *path = new int[nNum];
    priority_queue<vexNode<int> > myQueue;

    // 算法开始
    // 1. 在相同的最短路里找第一步最小的放入优先级队列中

    vexNode<int> *p = &eVec[0];
    while(p -> next != NULL)
    {
        p = p -> next;
        myQueue.push(eVec[p->data]);
        path[p->data] = 0;
    }
    int flag = 1;   // flag用来标记是否是第一次
    int minDist;    // minDist记录最小的dist值

    // 2. 从岛屿开始，能到达的所有结点做循环

    while(!myQueue.empty())
    {
        // 2.1 初始化
        for(int i=0; i<nNum; i++)
        {
            dist[i] = -1;
            path[i] = -1;
        }
        // 2.2 从队列中弹出一个结点，从这个结点开始，借助另一个队列，进行BFS
        vexNode<int> vN = myQueue.top();
        myQueue.pop();
        path[vN.data] = 0;      // 从myQueue队列中取出的结点，parent一定为岛屿(0,0)
        queue<int> bfsQueue;    // 进行BFS所需要的队列
        bfsQueue.push(vN.data);
        dist[vN.data] = 0;      // 初始的dist值为0
        while(!bfsQueue.empty())
        {
            int W = bfsQueue.front();
            bfsQueue.pop();
            // 2.3 判定是不是已经可以上岸了
            if(fabs(vec[W].x-BORDER)<=dis || fabs(vec[W].x+BORDER)<=dis
                    ||fabs(vec[W].y-BORDER)<=dis ||(vec[W].y+BORDER)<=dis)
            {
                // 2.3.1 如果是第一次，更新minDist值，并记录路径
                if(flag&&W!=0)
                {
                    minDist = dist[W];
                    flag = 0;
                    pathVec = getPath(W, path);
                }
                // 2.3.2 如果不是第一次，则比较minDist值与dist值，并更新路径
                else if(W!=0 && dist[W] <= minDist)
                {
                    minDist = dist[W];
                    pathVec = getPath(W, path);
                }
            }
            // 2.4 如果没有上岸，则将其邻接结点放入队列中，并更新dist与path的值
            else
            {
                for(int i=1; i<=nNum; i++)
                {
                    if(Distance(vec[W], vec[i], dis) >= 0 && dist[i] == -1)
                    {
                        bfsQueue.push(i);
                        dist[i]=dist[W]+1;
                        path[i]=W;
                    }
                }
            }

        }
    }

    // 3. 输出最终结果

    if(pathVec.size() == 0)
        cout << "0" << endl;
    else
    {
        // 3.1 因为我们把(0,0)也当成结点了，这里不用+1
        cout << pathVec.size() << endl;
        for(int i=0; i<pathVec.size(); i++)
            // 3.2 因为我们把(0,0)也当成结点了，但是不能让它输出，所以特殊考虑
            if(vec[pathVec[i]].x == 0 and vec[pathVec[i]].y == 0)
                ;
            else
                cout << vec[pathVec[i]].x << " " << vec[pathVec[i]].y << endl;
    }
    return 0; 
}

AC成果：