#1142. Maximal Clique【图论 + 模拟】

原题链接

Problem Description：

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 $N_v$ ($\le 200$), the number of vertices in the graph, and $N_e$, the number of undirected edges. Then $N_e$ lines follow, each gives a pair of vertices of an edge. The vertices are numbered from 1 to $N_v$.

After the graph, there is another positive integer $M$ ($\le 100$). Then $M$ lines of query follow, each first gives a positive number $K$ ($\le N_v$), 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

Problem Analysis:

题目中每组询问给定一个顶点集合，需要我们判断该集合中的点和边是否成团，如果成团，是否是最大团。

对于给定的一个顶点集合，我们可以判断任何两个点之间是否存在边，如果是，则是一个团。

bool check_clique(int cnt)
{
    for (int i = 1; i <= cnt; i ++ )
        for (int j = i + 1; j <= cnt; j ++ ) 
            if (!g[vers[i]][vers[j]])
                return false;
    return true;
}

对于判断是否是最大团，在已经确认是团的基础上，我们可以遍历所有不在这个团的所有点，一旦存在这样一个点，这个点与团内所有点之间都存在边，那么就说明这个点可以加入这个团，那么就证明这个团不是一个最大团：

bool check_maximal(int cnt)
{
    memset(st, 0, sizeof st);
    for (int i = 1; i <= cnt; i ++ )
        st[vers[i]] = true;
    
    bool success = false;
    for (int i = 1; i <= n; i ++ )
        if (!st[i]) // 判断不在原集合的所有点        
        {
            // 我们来判断除了给定集合，还有没有其他的点能够参与进团
            int e = 0;
            for (int j = 1; j <= cnt; j ++ )
                if (g[i][vers[j]]) ++ e;
            if (e == cnt) return false;
        }
    return true;
}

Code

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 210;

int n, m;
bool g[N][N];
int vers[N];
bool st[N];

bool check_clique(int cnt)
{
    for (int i = 1; i <= cnt; i ++ )
        for (int j = i + 1; j <= cnt; j ++ ) 
            if (!g[vers[i]][vers[j]])
                return false;
    return true;
}

bool check_maximal(int cnt)
{
    memset(st, 0, sizeof st);
    for (int i = 1; i <= cnt; i ++ )
        st[vers[i]] = true;
    
    bool success = false;
    for (int i = 1; i <= n; i ++ )
        if (!st[i]) // 判断不在原集合的所有点        
        {
            // 我们来判断除了给定集合，还有没有其他的点能够参与进团
            int e = 0;
            for (int j = 1; j <= cnt; j ++ )
                if (g[i][vers[j]]) ++ e;
            if (e == cnt) return false;
        }
    return true;
}

int main()
{
    cin >> n >> m;
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        g[a][b] = g[b][a] = true;
    }
    
    int k;
    cin >> k;
    while (k -- )
    {
        int cnt;
        cin >> cnt;
        for (int i = 1; i <= cnt; i ++ ) scanf("%d", &vers[i]);
        if (check_clique(cnt))
        {
            if (check_maximal(cnt)) puts("Yes");
            else puts("Not Maximal");
        }
        else puts("Not a Clique");
    }
    return 0;
}