pta编程题19 Saving James Bond 2

其它pta数据结构编程题请参见：pta

题目

和简单版本不同的是，简单版本只需判断能否到达岸边，而这个版本要求求出最少跳数的路径。

简单版本用dfs实现，而这道题用BFS实现。

注意：

岛半径为7.5，而不是15。另外注意一步跳到岸边的情况。

 #include <iostream>
 #include <vector>
 #include <math.h>
 using namespace std;
 const int maxInt = ;

 int N, D;
 struct point
 {
     int x, y;
 }G[];

 struct queue
 {
     int arr[];
     int head = ;
     int tail = ;
 };

 void enQueue(int i, queue& q);
 int deQueue(queue& q);
 bool isEmpty(queue q);

 bool firstJump(int i);
 bool jump(int i, int j);
 bool toBank(int i);
 bool bfs(int s, vector<int>& p);
 bool shorter(vector<int> path1, vector<int> path2);

 int main()
 {
     int i;
     cin >> N >> D;
     for (i = ; i < N; i++)
         cin >> G[i].x >> G[i].y;

     bool first = true;
     vector<int> path, minPath;
     for (i = ; i < N; i++)
     {
         if (firstJump(i) && bfs(i, path))
         {
             if (first) //第一个可达到岸边的鳄鱼
             {
                 minPath = path;
                 first = false;
             }
             else if (shorter(path, minPath))
                 minPath = path;
         }
     }

     if (first) cout << ; //岸边不可达
     else if (7.5 + D >= ) //直接跳到岸边
         cout << ;
     else {
         cout << minPath.size() +  << endl;
         for (i = minPath.size() - ; i >= ; i--)
         {
             int id = minPath[i];
             cout << G[id].x << " " << G[id].y << endl;
         }
     }
     return ;
 }

 bool firstJump(int i)
 {
     bool a = pow(G[i].x, ) + pow(G[i].y, ) <= pow((7.5 + D), );
     return a;
 }

 bool jump(int i, int j)
 {
     return pow(G[i].x - G[j].x, ) + pow(G[i].y - G[j].y, ) <= D * D;
 }

 bool toBank(int i)
 {
     int x = G[i].x, y = G[i].y;
     return (x <= D -  || x >=  - D || y <= D -  || y >=  - D);
 }

 bool shorter(vector<int> path1, vector<int> path2)
 {
     if (path1.size() != path2.size())
         return path1.size() < path2.size();
     else {
         int a = path1[path1.size() - ];
         int b = path2[path2.size() - ];
         return pow(G[a].x, ) + pow(G[a].y, ) <= pow(G[b].x, ) + pow(G[b].y, );
     }
 }

 bool bfs(int s, vector<int>& p)
 {
     queue q;
     enQueue(s, q);
     bool marked[] = {};
     int pathTo[];
     marked[s] = true;
     pathTo[s] = -;

     bool success = false;
     int v, w;
     while (!isEmpty(q))
     {
         v = deQueue(q);
         if (toBank(v)) //可以到岸边
         {
             success = true;
             break;
         }
         for (w = ; w < N; w++)
         {
             if (!marked[w] && jump(v, w))
             {
                 enQueue(w, q);
                 marked[w] = true;
                 pathTo[w] = v;
             }
         }
     }

     if (!success) return false;
     vector<int> vec;
     while (v != -)
     {
         vec.push_back(v);
         v = pathTo[v];
     }
     p = vec;
     return true;
 }

 void enQueue(int i, queue& q)
 {
     q.tail = (q.tail + ) % ;
     q.arr[q.tail] = i;
 }

 int deQueue(queue& q)
 {
     q.head = (q.head + ) % ;
     return q.arr[q.head];
 }

 bool isEmpty(queue q)
 {
     return q.head == q.tail;
 }