Saving James Bond - Easy Version

Saving James Bond - Easy Version

This time let us consider the situation in the movie "Live and Let Die" in which James Bond, the world's most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape -- he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head... Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers N (≤ 100), the number of crocodiles, and D, the maximum distance that James could jump. Then N lines follow, each containing the (x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.

Output Specification:

For each test case, print in a line "Yes" if James can escape, or "No" if not.

Sample Input 1:

14 20
25 -15
-25 28
8 49
29 15
-35 -2
5 28
27 -29
-8 -28
-20 -35
-25 -20
-13 29
-30 15
-35 40
12 12

Sample Output 1:

Yes

Sample Input 2:

4 13
-12 12
12 12
-12 -12
12 -12

Sample Output 2:

No

 

解题思路

　　这道题目有两种不同的思路。一种是用并查集，另外一种是用DFS。

并查集

　　就是把每两个点进行一次比较，如果他们对应的圆是相切或者是相交，就把他们合并到同一个集合。同时我们还要另外设两个集合，一个是用来存放一开始与原点对应范围相切或者是相交的圆所对应的点。另外一个集合是用来存放与边界相切或者是相交的圆所对应的点。最后比较一下这两个集合的代表元素是否相同，也就是这两个集合是否属于同一个集合。如果最后这两个集合的代表元素相同，说明找到了逃生路线；如果最后这两个集合的代表元素不同，就没有找到逃生路线。

　　AC代码如下：

#include <cstdio>
#include <cmath>
#include <iostream>

struct Point {
    int x, y;
};

void merge(int *set, int a, int b);
int findRoot(int *set, int x);

int main() {
    int n, dist;                        // n是鳄鱼的数量，dist是可以跳跃的距离 
    scanf("%d %d", &n, &dist);
    int set[n + 2];                     // 多出两个位置，其中set[n]用来存放与原点范围相邻的点，set[n+1]用来存放与边界相邻的点 
    std::fill(set, set + n + 2, -1);    // 初始化set，每一个元素为-1，代表每一个点都是一个独立的集合 
    
    Point point[n];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &point[i].x, &point[i].y);
        // 如果这个点对应的圆与原点范围相切或相交，就把这个点合并到集合set[n]中 
        if (point[i].x * point[i].x + point[i].y * point[i].y <= (7.5 + dist) * (7.5 + dist)) {
            merge(set, i, n);
        }
        // 如果这个点对应的圆与边界相切或相交，就把这个点合并到集合set[n+1]中
        if (50 - abs(point[i].x) <= dist || 50 - abs(point[i].y) <= dist) {
            merge(set, i, n + 1);
        }
    }
    
    // 每两个点进行一次比较检测 
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // 如果这两个点对应的圆相切或相交，就把这两个点合并到同一个集合中 
            if ((point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y) <= dist * dist) {
                merge(set, i, j);
            }
        }
    }
    
    // 最后判断set[n]和set[n+1]这两个集合的代表元素是否相同，如果相同说明这两个集合已合并为同一个集合，有逃生路径，否则没有 
    printf("%s", findRoot(set, n) == findRoot(set, n + 1) ? "Yes" : "No");
    
    return 0;
}

// 按秩归并。按规模大小，把规模小的集合并到规模大的集合 
void merge(int *set, int a, int b) {
    int root1 = findRoot(set, a), root2 = findRoot(set, b);
    if (root1 != root2) {
        if (set[root1] < set[root2]) {
            set[root1] += set[root2];
            set[root2] = root1;
        }
        else {
            set[root1] += set[root2];
            set[root2] = root1;
        }
    }
}

// 查找，同时路径压缩 
int findRoot(int *set, int x) {
    return set[x] < 0 ? x : (set[x] = findRoot(set, set[x]));
}

DFS

　　就是从原点出发，先找到第一个可以跳跃的点，然后从这个点开始深度遍历，找到符合的点，也就是找到能够相切或相交的圆对应的点，然后继续DFS。如果发现某一个点对应的圆与边界相切或相交，就说明有逃生路径，退出DFS。否则把剩余的点进行遍历，来找逃生路径。

　　AC代码如下：

#include <cstdio>
#include <cmath>
#include <iostream>

struct Point {
    int x, y;
};

int n, dist;    // n是鳄鱼的数量，dist是可以跳跃的距离，定义为全局变量 

bool isSave(Point *point, bool *vis);
int firstJumpPos(Point *point, bool *vis);
bool isJump(Point *point, int i, int j);
bool DFS(Point *point, bool *vis, int src);

int main() {
    scanf("%d %d", &n, &dist);
    bool vis[n] = {false};
    Point point[n];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &point[i].x, &point[i].y);
    }
    
    printf("%s", isSave(point, vis) ? "Yes" : "No");    // 返回true代表可以获救，否则不可以获救 
    
    return 0;
}

bool isSave(Point *point, bool *vis) {
    bool ret = false;       // ret代表是否可以获救，true可以，false，不可以 
    while (ret == false) {  // 当还没有找到逃生路径时，进入循环来找逃生路径 
        int pos = firstJumpPos(point, vis); // 找到第一个可以逃生的点，返回这个点对应的数组下标位置 
        if (pos == -1) break;               // 如果返回-1说明已经把可以第一次跳跃的点都找一遍了，已经没有逃生路径了，退出循环 
        
        ret = DFS(point, vis, pos);         // 否则对这个点进行深度遍历，返回是否有逃生路径 
    }
    
    return ret;
}

int firstJumpPos(Point *point, bool *vis) {
    for (int i = 0; i < n; i++) {
        // 如果这个点没有被访问过，并且对应的圆与原点范围相切或相交，就回这个点对应的数组下标位置 
        if (!vis[i] && point[i].x * point[i].x + point[i].y * point[i].y <= (7.5 + dist) * (7.5 + dist)) return i;
    }
    
    return -1;
}

bool isJump(Point *point, int i, int j) {
    // 判断这两个点对应的圆是否相切或相交 
    return (point[i].x - point[j].x) * (point[i].x - point[j].x) + (point[i].y - point[j].y) * (point[i].y - point[j].y) <= dist * dist;
}

bool DFS(Point *point, bool *vis, int src) {
    bool ret = false;
    vis[src] = true;
    // 如果这个点与边界相切或相交，就说明找到逃生路径了，返回true 
    if (50 - abs(point[src].x) <= dist || 50 - abs(point[src].y) <= dist) ret = true; 
    for (int i = 0; i < n && ret == false; i++) {   // 否则继续找
        if (!vis[i] && isJump(point, src, i)) {     // 如果这个点没有被访问并且可以从前一个点跳到这个点，也就是与前一个点对应的圆相切或相交 
            ret = DFS(point, vis, i);               // 就从这个点进行深度遍历，继续找逃生路径 
        }
    }
    
    return ret;
}