著名的“汉密尔顿（Hamilton）回路问题”是要找一个能遍历图中所有顶点的简单回路（即每个顶点只访问 1 次）。本题就要求你判断任一给定的回路是否汉密尔顿回路。 输入格式： 首先第一行给出两个正整数：无向图中顶点数 N（2<N≤200）和边数 M。随后 M 行，每行给出一条边的两个端点，格式为“顶点1 顶点2”，其中顶点从 1 到N 编号。再下一行给出一个正整数 K，是待检验的回路的条数。随后 K 行，每行给出一条待检回路，格式为： n V 1 ​ V 2 ​ ⋯ V n ​ 其中 n 是回路中的顶点数，V i ​ 是路径上的顶点编号。 输出格式： 对每条待检回路，如果是汉密尔顿回路，就在一行中输出"YES"，否则输出"NO"。用c语言编写程序

以下是使用邻接表表示图的 C 语言代码实现：

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

#define MAXN 200

// 邻接表结构体定义
typedef struct Node *PtrToNode;
struct Node {
    int v;
    PtrToNode next;
};
typedef PtrToNode List[MAXN];

// 全局变量
List graph;
int visited[MAXN];  // 记录每个顶点是否被访问

// 深度优先搜索函数
int DFS(int v, int n, int path[]) {
    visited[v] = 1;
    path[n++] = v;
    if (n == MAXN) return 1;  // 如果已经经过了所有顶点，则找到了汉密尔顿回路
    PtrToNode p = graph[v].next;
    while (p) {
        int w = p->v;
        if (!visited[w]) {
            if (DFS(w, n, path)) return 1;  // 如果找到了汉密尔顿回路，则直接返回
        }
        p = p->next;
    }
    visited[v] = 0;  // 回溯
    return 0;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    // 初始化邻接表
    for (int i = 1; i <= n; i++) {
        graph[i].next = NULL;
    }
    // 读入边信息，建立邻接表
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        // 添加 u 到 v 的边
        PtrToNode p = (PtrToNode)malloc(sizeof(struct Node));
        p->v = v;
        p->next = graph[u].next;
        graph[u].next = p;
        // 添加 v 到 u 的边
        p = (PtrToNode)malloc(sizeof(struct Node));
        p->v = u;
        p->next = graph[v].next;
        graph[v].next = p;
    }
    // 处理每个待检测的回路
    int k;
    scanf("%d", &k);
    for (int i = 0; i < k; i++) {
        int n, path[MAXN];
        scanf("%d", &n);
        for (int j = 0; j < n; j++) {
            scanf("%d", &path[j]);
        }
        // 判断是否为汉密尔顿回路
        if (n == n && path[0] == path[n - 1]) {
            int flag = 1;
            for (int j = 0; j < n - 1; j++) {
                int u = path[j], v = path[j + 1];
                if (!graph[u].next || !graph[v].next) {
                    flag = 0;  // 如果该顶点没有与其他顶点相连，则不是汉密尔顿回路
                    break;
                }
                PtrToNode p = graph[u].next;
                while (p) {
                    if (p->v == v) break;  // 如果找到了对应的边，则继续下一步
                    p = p->next;
                }
                if (!p) {
                    flag = 0;  // 如果没有找到对应的边，则不是汉密尔顿回路
                    break;
                }
            }
            if (flag) {
                // 从起点开始进行深度优先搜索
                for (int j = 1; j <= n; j++) {
                    visited[j] = 0;
                }
                if (DFS(path[0], 0, path)) {
                    printf("YES\n");
                } else {
                    printf("NO\n");
                }
            } else {
                printf("NO\n");
            }
        } else {
            printf("NO\n");
        }
    }
    return 0;
}