【数据结构与算法实习】题目3 灯塔(LightHouse)

题目描述：
海上有许多灯塔，为过路船只照明。每个灯塔都配有一盏探照灯，照亮其东北、西南两个对顶的直角区域。探照灯的功率之大，足以覆盖任何距离。灯塔本身是如此之小，可以假定它们不会彼此遮挡。
若灯塔A、B均在对方的照亮范围内，则称它们能够照亮彼此。比如在图二的实例中，蓝、红灯塔可照亮彼此，蓝、绿灯塔则不是，红、绿灯塔也不是。
现在，对于任何一组给定的灯塔，请计算出其中有多少对灯塔能够照亮彼此。

输入格式:
共n+1行。
第1行为1个整数n，表示灯塔的总数。
第2到n+1行每行包含2个整数x, y，分别表示各灯塔的横、纵坐标。

要求：
1 ≤ n ≤ 4×10^6
灯塔的坐标x, y是整数，且不同灯塔的x, y坐标均互异
1 ≤ x, y ≤ 10^8

输出格式:
1个整数，表示可照亮彼此的灯塔对的数量。

输入样例:

3
2 2
4 3
5 1

输出样例:

1

题解：

//本题的逻辑结构：队列
//本题的存储结构：链式
//解题思路和算法：当其他点相对该点在一、四象限即x*y>0时即满足可照亮的条件
//               将数据依次入队1，每次入队都将队列内数据出队和该数据比较，判断是否可相互照亮，之后将队列数据和该数据一起入队
//               当新增一点时，只考虑该点对之前的所有点是否能够照亮，可以减少程序时间复杂度
//效率:时间复杂度O(n^2)、空间复杂度：O(n)
// 测试数据： （1）输入：3
//                 2 2
//                 4 3
//                 5 1
//                 输出：
//                 1
//            （2）输入：5
//                  1 3
//                  2 4
//                  5 6
//                  7 8
//                  9 10
//                  输出：
//                  10

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>

#define TRUE 1;
#define FALSE 0;
#define ERROR -1;
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))

typedef int bool;
typedef int ElementType;

typedef struct Node * PtrToNode;
struct Node
{
    /* data */
    ElementType Data;
    PtrToNode Next;
};
typedef PtrToNode Position;

typedef struct QNode * PtrToQNode;
struct QNode
{
    /* data */
    Position Front, Rear;
};
typedef PtrToQNode QueQue;

bool IsEmpty(QueQue Q){
    return (Q->Front == NULL);
}

ElementType DeleteQ(QueQue Q){
    Position FrontCell;
    ElementType FrontELem;

    if(IsEmpty(Q)){
        return ERROR;
    }
    else{
        FrontCell = Q->Front;
        if(Q->Front == Q->Rear){
            Q->Front = Q->Rear = NULL;
        }
        else{
            Q->Front = Q->Front->Next;
        }
        FrontELem = FrontCell->Data;

        return FrontELem;
    }
}

bool AddQ(QueQue Q, ElementType RearELem){
    Position RearCell;
    RearCell = (Position)malloc(sizeof(struct Node));
    if(IsEmpty(Q)){
        RearCell->Data = RearELem;
        Q->Front = RearCell;
        Q->Rear = RearCell;
        Q->Front->Next = NULL;
        Q->Rear->Next = NULL;
    }
    else{
        if(Q->Front == Q->Rear){
            RearCell->Data = RearELem;
            Q->Rear->Next = RearCell;
            Q->Rear = RearCell;
            Q->Front->Next = Q->Rear;
        }
        else{
            RearCell->Data = RearELem;
            Q->Rear->Next = RearCell;
            Q->Rear = RearCell;
            Q->Rear->Next = NULL;   
        }
    }
    return TRUE;
}

QueQue CreateQueQue(){
    QueQue Q;

    Q = malloc(sizeof(struct QNode));
    Q->Front = Q->Rear = NULL;
    return Q;
}

char * Que2Str(QueQue Q){
    char *returnStr;
    char str[10000];
    int lenth = strlen(str);
    for (int i = 0; i < lenth ; i++)
    {
        /* code */
        str[i]=0;
    }
    int counter = 0;
    Position ptr = Q->Front;
    if(IsEmpty(Q)){
        returnStr = str;
        return "-";
    }
    else{
        while(ptr!=Q->Rear->Next){
                str[counter]=ptr->Data;//注意不要str[counter]=(char)ptr->Data，存储的是int，只是输出时用%s/%c即可
                ptr = ptr->Next;
                counter++;
            }
        returnStr = str;
        return returnStr;
    }
}

int main(){
    QueQue qx = CreateQueQue();
    QueQue qy = CreateQueQue();
    QueQue q2x = CreateQueQue();
    QueQue q2y = CreateQueQue();
    int n;
    int sum = 0;
    scanf("%d",&n);
    for(int i = 0; i < n; i++){
        int xPos;
        int yPos;
        scanf("%d %d",&xPos,&yPos);
        if(IsEmpty(qx)){
            AddQ(qx, xPos);
            AddQ(qy, yPos);
        }
        else{
            for(int j = 0; j < i; j++){
                int xPosBefore = DeleteQ(qx);
                int yPosBefore = DeleteQ(qy);
                if((xPosBefore - xPos)*(yPosBefore - yPos)>=0){
                    sum++;
                }
                AddQ(q2x, xPosBefore);
                AddQ(q2y, yPosBefore);
            }
            AddQ(q2x, xPos);
            AddQ(q2y, yPos);
            while(!IsEmpty(q2x)){
                AddQ(qx, DeleteQ(q2x));
                AddQ(qy, DeleteQ(q2y));
            }
        }
    }
    printf("%d", sum);
    return 0;
}