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 = 65535;

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

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

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 = 0; i < N; i++)
        cin >> G[i].x >> G[i].y;

    bool first = true;
    vector<int> path, minPath;
    for (i = 0; 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 << 0; //岸边不可达
    else if (7.5 + D >= 50) //直接跳到岸边
        cout << 1;
    else {
        cout << minPath.size() + 1 << endl;
        for (i = minPath.size() - 1; i >= 0; i--)
        {
            int id = minPath[i];
            cout << G[id].x << " " << G[id].y << endl;
        }
    }
    return 0;
}

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

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

bool toBank(int i)
{
    int x = G[i].x, y = G[i].y;
    return (x <= D - 50 || x >= 50 - D || y <= D - 50 || y >= 50 - 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() - 1];
        int b = path2[path2.size() - 1];
        return pow(G[a].x, 2) + pow(G[a].y, 2) <= pow(G[b].x, 2) + pow(G[b].y, 2);
    }
}

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

    bool success = false;
    int v, w;
    while (!isEmpty(q))
    {
        v = deQueue(q);
        if (toBank(v)) //可以到岸边
        {
            success = true;
            break;
        }
        for (w = 0; 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 != -1)
    {
        vec.push_back(v);
        v = pathTo[v];
    }
    p = vec;
    return true;
}

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

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

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