中國大學MOOC-數據結構基礎習題集、06-1、Saving James Bond - Hard Version

題目鏈接：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成果：