用C++实现用邻接矩阵和邻接表存储图，并实现连通图、欧拉图、哈密顿图的判定。 请完成Project04.cpp中Graph类的成员函数，具体要求如下： Graph类： 用来表示一个无向图。 成员变量： m_AdjMat：邻接矩阵 m_AdjList：邻接表 成员函数： Graph()：默认构造函数，构造一个空图。注意应同时初始化邻接矩阵和邻接表 ~Graph()：析构函数 Graph(string filepath)：解析文件filepath，构造一个Graph对象。

以下是实现要求的代码：

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

class Graph {
private:
    int** m_AdjMat;  // 邻接矩阵
    vector<vector<int>> m_AdjList;  // 邻接表
    int m_NumVertex;  // 顶点数
    int m_NumEdge;  // 边数

public:
    Graph() {
        m_NumVertex = 0;
        m_NumEdge = 0;
        m_AdjMat = nullptr;
        m_AdjList.clear();
    }

    ~Graph() {
        if (m_AdjMat != nullptr) {
            for (int i = 0; i < m_NumVertex; i++) {
                delete [] m_AdjMat[i];
            }
            delete [] m_AdjMat;
        }
        m_AdjList.clear();
    }

    Graph(string filepath) {
        ifstream fin(filepath);
        if (!fin) {
            cout << "File not found." << endl;
            exit(1);
        }
        fin >> m_NumVertex >> m_NumEdge;  // 读入顶点数和边数
        m_AdjMat = new int*[m_NumVertex];
        for (int i = 0; i < m_NumVertex; i++) {
            m_AdjMat[i] = new int[m_NumVertex];
            for (int j = 0; j < m_NumVertex; j++) {
                m_AdjMat[i][j] = 0;  // 初始化邻接矩阵
            }
        }
        m_AdjList.resize(m_NumVertex);  // 初始化邻接表
        int u, v;
        for (int i = 0; i < m_NumEdge; i++) {  // 读入边
            fin >> u >> v;
            m_AdjMat[u][v] = m_AdjMat[v][u] = 1;  // 更新邻接矩阵
            m_AdjList[u].push_back(v);  // 更新邻接表
            m_AdjList[v].push_back(u);
        }
        fin.close();
    }

    bool isConnected() {  // 判断连通图
        vector<bool> visited(m_NumVertex, false);
        dfs(0, visited);
        for (bool v : visited) {
            if (!v) {
                return false;
            }
        }
        return true;
    }

    bool isEulerian() {  // 判断欧拉图
        if (!isConnected()) {
            return false;
        }
        for (int i = 0; i < m_NumVertex; i++) {
            if (m_AdjList[i].size() % 2 != 0) {
                return false;
            }
        }
        return true;
    }

    bool isHamiltonian() {  // 判断哈密顿图
        vector<int> path;
        vector<bool> visited(m_NumVertex, false);
        for (int i = 0; i < m_NumVertex; i++) {
            path.clear();
            visited.clear();
            visited.resize(m_NumVertex, false);
            if (dfs_path(i, i, visited, path)) {
                return true;
            }
        }
        return false;
    }

private:
    void dfs(int u, vector<bool>& visited) {  // 深度优先搜索
        visited[u] = true;
        for (int v = 0; v < m_NumVertex; v++) {
            if (m_AdjMat[u][v] && !visited[v]) {
                dfs(v, visited);
            }
        }
    }

    bool dfs_path(int u, int start, vector<bool>& visited, vector<int>& path) {  // 查找哈密顿路径
        visited[u] = true;
        path.push_back(u);
        if (path.size() == m_NumVertex) {
            if (m_AdjMat[u][start]) {
                return true;
            }
            path.pop_back();
            visited[u] = false;
            return false;
        }
        for (int v : m_AdjList[u]) {
            if (!visited[v]) {
                if (dfs_path(v, start, visited, path)) {
                    return true;
                }
            }
        }
        path.pop_back();
        visited[u] = false;
        return false;
    }
};

使用方法：

- 默认构造函数：`Graph g;`
- 从文件构造：`Graph g("filename.txt");`
- 判断连通图：`bool connected = g.isConnected();`
- 判断欧拉图：`bool eulerian = g.isEulerian();`
- 判断哈密顿图：`bool hamiltonian = g.isHamiltonian();`