哈密顿回路问题的c语言实现

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

// 图中顶点的最大数量，可根据实际需求调整
#define MAX_VERTICES 100
// 假设的最大已探索状态数量（可根据实际调整，实际中可能需要更好的动态管理机制）
#define MAX_STATES 10000 

// 图的邻接矩阵
int graph[MAX_VERTICES][MAX_VERTICES];
// 标记顶点是否已访问
bool visited[MAX_VERTICES];
// 存储哈密顿回路路径
int path[MAX_VERTICES];
// 图的顶点数量
int numVertices;

// 定义一个结构体来记录路径状态等信息用于剪枝（简单示意）
typedef struct PathState {
    int path[MAX_VERTICES];
    bool visited[MAX_VERTICES];
    int pos;
} PathState;

// 可以用一个合适的数据结构（比如哈希表等）来存储探索过的路径状态
// 假设用一个简单数组模拟哈希表（实际应用需更完善的哈希表实现）
PathState exploredStates[MAX_STATES]; 
int stateCount = 0;

// 改进后的检查顶点 v 在位置 pos 加入路径是否可行，增加剪枝逻辑
bool isSafeWithPruning(int v, int pos) {
    // 先按原有逻辑检查边和访问情况
    if (graph[path[pos - 1]][v] == 0) {
        return false;
    }
    if (visited[v]) {
        return false;
    }

    // 构建当前路径状态结构体
    PathState currentState;
    memcpy(currentState.path, path, sizeof(path));
    memcpy(currentState.visited, visited, sizeof(visited));
    currentState.pos = pos;
    currentState.path[pos] = v;
    currentState.visited[v] = true;

    int i;
    // 检查当前状态是否已经探索过，如果是则直接返回不可行避免重复探索
    for (i = 0; i < stateCount; i++) {
        if (memcmp(&exploredStates[i], &currentState, sizeof(PathState)) == 0) {
            return false;
        }
    }

    // 将当前新状态加入已探索状态记录中
    exploredStates[stateCount++] = currentState;

    return true;
}

// 深度优先搜索寻找哈密顿回路的递归函数，使用改进后的剪枝逻辑
// pos 表示当前正在构建路径中的顶点位置
bool findHamiltonianCycleUtilWithPruning(int pos) {
    // 若已成功构建包含所有顶点的路径
    if (pos == numVertices) {
        // 检查最后顶点与起始顶点是否有边相连，有则找到回路
        if (graph[path[pos - 1]][path[0]] == 1) {
            return true;
        }
        return false;
    }

    int v;
    // 遍历所有顶点，尝试添加到路径中
    for (v = 1; v < numVertices; v++) {
        if (isSafeWithPruning(v, pos)) {
            // 将顶点 v 加入当前路径
            path[pos] = v;
            // 标记顶点 v 已访问
            visited[v] = true;

            // 递归继续构建后续路径
            if (findHamiltonianCycleUtilWithPruning(pos + 1)) {
                return true;
            }

            // 若递归构建失败，回溯，移除顶点 v 并标记为未访问
            visited[v] = false;
        }
    }

    // 所有顶点尝试完毕，未找到回路
    return false;
}

// 寻找哈密顿回路的对外接口函数，尝试从每个顶点开始寻找并应用改进逻辑
bool findHamiltonianCycle() {
    int start;
    // 尝试从每个顶点开始寻找回路
    for (start = 0; start < numVertices; start++) {
        // 初始化路径和访问标记
        int i;
        for (i = 0; i < numVertices; i++) {
            visited[i] = false;
            path[i] = -1;
        }

        // 从当前起始顶点 start 开始构建路径并标记为已访问
        path[0] = start;
        visited[start] = true;

        // 调用递归函数开始寻找回路
        if (findHamiltonianCycleUtilWithPruning(1)) {
            return true;
        }
    }
    return false;
}

int main() {
    // 获取图的顶点数量并进行合法性检查
    printf("请输入图的顶点数量: ");
    int numVertices;
    if (scanf("%d", &numVertices)!= 1 || numVertices <= 0 || numVertices > MAX_VERTICES) {
        printf("输入的顶点数量不合法，请重新运行程序并输入合理数值\n");
        return 1;
    }

    // 获取图的邻接矩阵信息并进行合法性检查
    printf("请输入图的邻接矩阵（0表示无边，1表示有边）:\n");
    int i;
    for (i = 0; i < numVertices; i++) {
        int j;
        for (j = 0; j < numVertices; j++) {
            int temp;
            if (scanf("%d", &temp)!= 1 || (temp!= 0 && temp!= 1)) {
                printf("邻接矩阵元素输入不合法，请重新运行程序并正确输入\n");
                return 1;
            }
            graph[i][j] = temp;
        }
    }

    // 寻找哈密顿回路并输出结果
    if (findHamiltonianCycle()) {
        printf("存在哈密顿回路，路径如下:\n");
        int i;
        for (i = 0; i < numVertices; i++) {
            printf("%d ", path[i]);
        }
        printf("%d\n", path[0]);
    } else {
        printf("不存在哈密顿回路\n");
    }

    return 0;
}