PTA L2-010 排座位（25分）C(gcc)实现

题目要求

布置宴席最微妙的事情，就是给前来参宴的各位宾客安排座位。无论如何，总不能把两个死对头排到同一张宴会桌旁！这个艰巨任务现在就交给你，对任何一对客人，请编写程序告诉主人他们是否能被安排同席。

输入格式：

输入第一行给出3个正整数：N（≤100），即前来参宴的宾客总人数，则这些人从1到N编号；M为已知两两宾客之间的关系数；K为查询的条数。随后M行，每行给出一对宾客之间的关系，格式为：宾客1 宾客2 关系，其中关系为1表示是朋友，-1表示是死对头。注意两个人不可能既是朋友又是敌人。最后K行，每行给出一对需要查询的宾客编号。

这里假设朋友的朋友也是朋友。但敌人的敌人并不一定就是朋友，朋友的敌人也不一定是敌人。只有单纯直接的敌对关系才是绝对不能同席的。

输出格式：

对每个查询输出一行结果：如果两位宾客之间是朋友，且没有敌对关系，则输出No problem；如果他们之间并不是朋友，但也不敌对，则输出OK；如果他们之间有敌对，然而也有共同的朋友，则输出OK but…；如果他们之间只有敌对关系，则输出No way。

输入样例：

7 8 4
5 6 1
2 7 -1
1 3 1
3 4 1
6 7 -1
1 2 1
1 4 1
2 3 -1
3 4
5 7
2 3
7 2

输出样例：

No problem
OK
OK but...
No way

代码长度限制 16 KB

时间限制 150 ms

内存限制 64 MB

分析

敌人之间很好判断，只需要一次查询Guest1与Guest2的关系是否为敌人，而朋友的关系可以用树状查询，即递归出所有朋友的朋友。

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

//定义结构体

struct Guest
{
    int *relationshipPtr;
};

//动态创建数组以及初始化

bool *CreateBoolArray(int num)
{
    return (bool *)malloc(sizeof(bool) * num);
}

void MemsetBoolArray(bool *array, int num)
{
    for (int i = 0; i < num; i++)
    {
        array[i] = false;
    }
}

int *CreateIntArray(int num)
{
    return (int *)malloc(sizeof(int) * num);
}

void MemsetIntArray(int *array, int num)
{
    for (int i = 0; i < num; i++)
    {
        array[i] = 0;
    }
}

struct Guest *CreateGuestArray(int num)
{
    return (struct Guest *)malloc(sizeof(struct Guest) * num);
}

void MemsetGuestArray(struct Guest *guest, int num)
{
    for (int i = 0; i < num; i++)
    {
        guest[i].relationshipPtr = CreateIntArray(num);
        MemsetIntArray(guest[i].relationshipPtr, num);
    }
}

//树状查询朋友关系

void SearchRelatedFriend(struct Guest *guest, int guestCount, int g, bool *gRelatedFriends)
{
    for (int i = 0; i < guestCount; i++)
    {
        if (guest[g].relationshipPtr[i] == 1 && gRelatedFriends[i] == false)
        {
            gRelatedFriends[i] = true;
            SearchRelatedFriend(guest, guestCount, i, gRelatedFriends);
        }
    }
}

//是否为朋友

bool IsFriend(struct Guest *guest, int guestCount, int g1, int g2)
{
    bool *g1RelatedFriends = CreateBoolArray(guestCount);
    MemsetBoolArray(g1RelatedFriends, guestCount);
    bool *g2RelatedFriends = CreateBoolArray(guestCount);
    MemsetBoolArray(g2RelatedFriends, guestCount);
    SearchRelatedFriend(guest, guestCount, g1 - 1, g1RelatedFriends);
    SearchRelatedFriend(guest, guestCount, g2 - 1, g2RelatedFriends);
    for (int i = 0; i < guestCount; i++)
    {
        if (g1RelatedFriends[i] == g2RelatedFriends[i] && g1RelatedFriends[i] == true)
        {
            return true;
        }
    }
    return false;
}

//是否为敌人

bool IsEnemy(struct Guest *guest, int g1, int g2)
{
    return guest[g1 - 1].relationshipPtr[g2 - 1] == -1 ? true : false;
}

//输入以及输出

void ReadInput(struct Guest *guest, int guestCount, int relationshipCount, int queryCount)
{
    for (int i = 0; i < relationshipCount; i++)
    {
        int g1, g2, relation;
        scanf("%d %d %d", &g1, &g2, &relation);
        guest[g1 - 1].relationshipPtr[g2 - 1] = relation;
        guest[g2 - 1].relationshipPtr[g1 - 1] = relation;
    }
    for (int i = 0; i < queryCount; i++)
    {
        int g1, g2;
        scanf("%d %d", &g1, &g2);
        bool friend, enemy;
        friend = IsFriend(guest, guestCount, g1, g2);
        enemy = IsEnemy(guest, g1, g2);
        if (friend && !enemy)
        {
            printf("No problem\n");
        }
        else if (friend && enemy)
        {
            printf("OK but...\n");
        }
        else if (!friend && !enemy)
        {
            printf("OK\n");
        }
        else
        {
            printf("No way\n");
        }
    }
}

//主函数

int main()
{
    int guestCount, relationshipCount, queryCount;
    scanf("%d %d %d", &guestCount, &relationshipCount, &queryCount);
    struct Guest *guestPtr = CreateGuestArray(guestCount);
    MemsetGuestArray(guestPtr, guestCount);
    ReadInput(guestPtr, guestCount, relationshipCount, queryCount);
}