PAT 甲级 1142 Maximal Clique (25 分)

A clique is a subset of vertices of an undirected graph such that every two distinct vertices in the clique are adjacent. A maximal clique is a clique that cannot be extended by including one more adjacent vertex. (Quoted from https://en.wikipedia.org/wiki/Clique_(graph_theory))

Now it is your job to judge if a given subset of vertices can form a maximal clique.

Input Specification:
Each input file contains one test case. For each case, the first line gives two positive integers Nv (≤ 200), the number of vertices in the graph, and Ne, the number of undirected edges. Then Ne lines follow, each gives a pair of vertices of an edge. The vertices are numbered from 1 to Nv.

After the graph, there is another positive integer M (≤ 100). Then M lines of query follow, each first gives a positive number K (≤ Nv), then followed by a sequence of K distinct vertices. All the numbers in a line are separated by a space.

Output Specification:
For each of the M queries, print in a line Yes if the given subset of vertices can form a maximal clique; or if it is a clique but not a maximal clique, print Not Maximal; or if it is not a clique at all, print Not a Clique.

Sample Input:

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

Sample Output:

Yes
Yes
Yes
Yes
Not Maximal
Not a Clique

题目大意：
clique是一个点集，任意两点都是相连的。
maximal clique是最大的clique，标志是不能再加入任何一个点构成一个clique

给定一个Nv个顶点，Ne条边的无向图
M次询问
每次询问给定K个点，这K个点是否是maximal clique；是否是一个clique；

分析：

1. 判断是否是clique，即判断是否任意两边都相连；
2. 判断是否是maximal，即遍历剩余点，看是否存在一个点和集合中所有的结点相连

#include <iostream>
#include <cstdio>
#include <vector>
#include <unordered_map>
using namespace std;
const int maxn = 210;

int E[maxn][maxn];
int n, m;  // n个点，m条边

// 是否全部相连
bool isClique(vector<int> v)
{
    int num = v.size();
    for (int i = 0; i < num; i ++)
    {
        for (int j = 0; j < num; j ++)
        {
            if (i==j) continue;
            if (!E[v[i]][v[j]]) return false;
        }
    }
    return true;
}

bool isMaximal(vector<int>v, unordered_map<int, bool> hash)
{
    int num = v.size();
    for (int i = 1; i <= n; i ++)
    {
        if (!hash[i])
        {
            int j = 0;
            for (; j < num; j ++)
                if (!E[i][v[j]]) 
                    break;
            if (j == num) 
                return false;
        }
    }
    return true;
}

int main()
{
    // freopen("/Users/zhbink/Documents/C++/C++/in.txt","r",stdin);
    cin >> n >> m;
    for (int i = 0; i < m; i ++)
    {
        int a, b;
        cin >> a >> b;
        E[a][b] = 1;
        E[b][a] = 1;
    }

    int q;
    cin >> q;
    while (q --)
    {
        int k;
        cin >> k;
        vector<int> v(k);
        unordered_map<int, bool> hash;
        for (int i = 0; i < k; i ++)
        {
            cin >> v[i];
            hash[v[i]] = 1;
        }
        if (!isClique(v))
            puts("Not a Clique");
        else
        {
            if (isMaximal(v, hash)) puts("Yes");
            else puts("Not Maximal");
        }   
    }
    return 0;
}