无线网络 (Ver. I)

题解

1. 这里的输入为O和输入为S的次数都是由输入控制的，一般这种情况都是cin>>ch作为控制表达式，输入eof结束输入。如果这里给输入为O和输入为S都弄一个这样的循环，则理论上需要输入两次EOF，而实际上输入EOF后会执行后续的程序，但是其中的cin不会执行。这里的解决办法是输入为O和输入为S共用一个while(cin>>ch)，先将输入为S时的各种值用队列存起来，之后再一个一个出队使用。

题目

问题 E: 无线网络 (Ver. I)

时间限制: 1 Sec  内存限制: 128 MB
提交: 832  解决: 251
[提交][状态][讨论版]
题目描述

在东南亚发生了地震。 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

代码块

#include <iostream>
#include <queue>
using namespace std;

class Edge//为队列Q设计的类
{
    int vex1;
    int vex2;
    friend class Graph;
};

class Position//电脑的坐标
{
    int x;
    int y;
    friend class Graph;
};

class Graph
{
private:
    int vexnum;
    int d;
    Position *T;//存各顶点坐标
    int **matrix;
    int *S;//数组S表示电脑是否被修复
    queue<Edge> Q;//先将输入为S时的顶点信息存起来，到后面矩阵初始化好了再出队判断顶点能否到达
public:
    Graph();
    ~Graph();
    void Test();
};

Graph::Graph()
{
    int i, j;
    cin>>vexnum>>d;
    T = new Position[vexnum];
    matrix = new int*[vexnum];
    S = new int[vexnum];
    for(i=0; i<vexnum; i++)
    {
        matrix[i] = new int[vexnum];
        cin>>T[i].x>>T[i].y;
        for(j=0; j<vexnum; j++)
            matrix[i][j] = 0;
        S[i] = 0;
    }
    getchar();
    char ch;
    while(cin>>ch)
    {
        if(ch=='O')
        {
            cin>>i;
            S[i-1] = 1;
        }
        else if(ch=='S')
        {
            Edge e;
            cin>>e.vex1>>e.vex2;
            Q.push(e);
        }
    }
    for(i=0; i<vexnum; i++)//根据电脑是否被修复和电脑间的距离判断两电脑能否直达，并将矩阵相应值置1
    {
        for(j=0; j<vexnum; j++)
        {
            if(j!=i && S[i] && S[j] && ((T[i].x-T[j].x)*(T[i].x-T[j].x)+(T[i].y-T[j].y)*(T[i].y-T[j].y))<=(d*d))
                matrix[i][j] = 1;
        }
    }
    int k;//Floyd算法实现传递闭包
    for(k=0; k<vexnum; k++)
        for(i=0; i<vexnum; i++)
            for(j=0; j<vexnum; j++)
                if(matrix[i][k] && matrix[k][j])
                    matrix[i][j] = 1;
}

Graph::~Graph()
{
    for(int i=0; i<vexnum; i++)
        delete []matrix[i];
    delete []matrix;
    delete []T;
    delete []S;
}

void Graph::Test()
{
    Edge e;
    while(!Q.empty())
    {//此时矩阵已经根据输入为O的情况初始化好了，出队进行判断
        e = Q.front();
        Q.pop();
        if(matrix[e.vex1-1][e.vex2-1])
            cout<<"SUCCESS"<<endl;
        else
            cout<<"FAIL"<<endl;
    }
}

int main(void)
{
    Graph myGraph;
    myGraph.Test();
    return 0;
}