无线网络 (Ver. I)

题目描述

在东南亚发生了地震。 ACM（Asia Cooperated Medical team）已经用笔记本建立了无线网络，但是由于一次余震，网络中的所有计算机都损坏了。 计算机一个接一个地修复，网络逐渐开始工作。 由于硬件限制，每台计算机只能直接与距离它不远的计算机进行通信。 但是，每台计算机都可以被视为两台计算机之间通信的中介，也就是说，如果计算机A和计算机B可以直接通信，计算机C可以与计算机A进行通信，则计算机C和计算机B可以进行通信。
在修复网络的过程中，工作人员先后进行两种操作，先修复计算机，再测试两台计算机是否可以通信。 你的任务是回答所有的测试操作。

输入

输入数据只有一组

第一行包含两个整数N和d（1 <= N <= 100,0 <= d <= 20000）。 这里N是计算机的数量，编号从1到N，D是两台计算机可以直接通信的最大距离。 在接下来的N行中，每行包含两个整数xi，yi（0 <= xi，yi <= 10000），这是N台计算机的坐标。 从第（N + 1）行到输入结束，有一些操作，这些操作是一个接一个地执行的。 每行包含以下两种格式之一的操作：

1.“O p”（1 <= p <= N），修复计算机p
2.“S p q”（1 <= p，q <= N），测试计算机p和q是否可以通信

其中所有的修复操作都在测试操作之前

输入不会超过3000行

输出

对于每个测试操作，如果两台计算机可以通信则输出“SUCCESS”，否则输出“FAIL”。

样例输入

4 1 0 1 0 2 0 3 0 4 O 1 O 2 O 4 S 1 2 S 1 4 S 1 3 S 2 3

样例输出

SUCCESS FAIL FAIL FAIL

思路：

用一个邻接矩阵来存每个电脑之间连通的信息，1代表连通，0代表不连通

每次输入O时就更新邻接矩阵

每次输入S时，就调用BFS，看能否在结点1上用BFS找到结点2，如果可以，就输出SUCCESS，反之输出FAIL

具体细节：代码注释

代码：

#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
const int MaxLen =110;
class Map{
private:
    bool Visit[MaxLen];
    int Matrix[MaxLen][MaxLen];
    int Vexnum;
    bool BFS(int q,int p);
public:
    void SetMatrix(int vnum,int **mx);
    bool BFSTraverse(int q,int p);
};
bool Map::BFSTraverse(int q,int p)
{
    Visit[q]=true;
    bool res=BFS(q,p);
    for(int i=0;i<Vexnum;i++)        //每次调用完BFS后要将Visit重置，方便下一次使用
        Visit[i]=false;
    return res;
}
bool Map::BFS(int q,int p)
{
    if(Matrix[q][p]==1)             //如果可以判断出2个结点相连，就直接返回1表示找到
        return 1;
    queue<int> Q;
    for(int i=0;i<Vexnum;i++))      //如果无法判断，则将此结点上所连的结点入队，继续递归BFS
    {
        if(Matrix[q][i]!=0 &&!Visit[i])
        {
            Visit[i]=true;
            Q.push(i);
        }
    }
    while(!Q.empty())
    {
        if(BFS(Q.front(),p))        //但凡有一个结点可以连通，都代表可以找到，所以直接返回1
            return 1;
        Q.pop();
    }
    return 0;                //都没连通的话，就是找不到了，返回0
}
void Map::SetMatrix(int vnum,int **mx)        //初始化图
{
    for(int i=0;i<Vexnum;i++)
        Visit[i]=false;
    int i,j;
    Vexnum =vnum;
    for(i=0;i<MaxLen;i++)
        for(j=0;j<MaxLen;j++)
            Matrix[i][j]=0;
    for(i=0;i<Vexnum;i++)
        for(j=0;j<Vexnum;j++)
            Matrix[i][j]=mx[i][j];
}
int distance(int x1,int y1,int x2,int y2)
{
    return ((x1 - x2)*(x1 - x2) + (y1 - y2)*(y1 - y2));
}
void test(int n)
{
    int d;
    cin>>d;
    struct P{
        int x;
        int y;
    }point[n];
    for(int i=0;i<n;i++)                //输入每个点的坐标
        cin>>point[i].x>>point[i].y;
    int **m;
    m=new int*[n];
    int *flag=new int[n];            //用一个flag数组表示计算机是否修复，初始化为0表示未修复
    for(int i=0;i<n;i++)
    {
        flag[i]=0;
        m[i]=new int[n];
        for(int j=0;j<n;j++)
        {
            m[i][j]=0;               //二维数组初始化为0，表示点和点之间不通
        }
    }
    string s1;
    int t1,t2;
    Map mmap;
    while(cin>>s1)
    {
        if(s1=="O")             //如果输入的第一个字符是“O”,则更新flag数组，并更新图
        {
            cin>>t1;
            flag[t1-1]=1;
            for(int j=0;j<n;j++)
            {
                if(j!=t1-1 &&flag[j]==1 && distance(point[t1-1].x,point[t1-1].y,point[j].x,point[j].y)<=d*d)
                {
                    m[t1-1][j]=1;
                    m[j][t1-1]=1;
                }
            }
        }
        else
        {                           //如果输入的是S,则调用图的BFS输出判定是否可以找到点
            cin>>t1>>t2;
            mmap.SetMatrix(n,m);
            if(!flag[t1-1] || !flag[t2-1])
                cout<<"FAIL"<<endl;
            else if(mmap.BFSTraverse(t1-1,t2-1))
                    cout<<"SUCCESS"<<endl;
                else
                    cout<<"FAIL"<<endl;
        }
    }
}
int main()
{
    int t;
    cin>>t;
    test(t);
    return 0;
}