Graph类： 用来表示一个无向图。 成员变量： m_AdjMat：邻接矩阵 m_AdjList：邻接表

回答：

Graph类是一个用来表示无向图的类。它包含两个成员变量：m_AdjMat和m_AdjList。m_AdjMat是一个邻接矩阵，用来表示图中每个节点之间的关系；m_AdjList是一个邻接表，用来存储每个节点的邻居节点列表。在Graph类中，可以使用这些成员变量来实现图的遍历、查找和修改等操作。

相关问题

写一个Graph类： 用来表示一个无向图。 成员变量： m_AdjMat：邻接矩阵 m_AdjList：邻接表

好的，我理解了您的要求。以下是一个简单的Graph类的实现：

class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.m_AdjMat = [[0] * vertices for i in range(vertices)]
        self.m_AdjList = [[] for i in range(vertices)]
        
    def add_edge(self, u, v, weight=1):
        self.m_AdjMat[u][v] = weight
        self.m_AdjMat[v][u] = weight
        self.m_AdjList[u].append((v, weight))
        self.m_AdjList[v].append((u, weight))
        
    def remove_edge(self, u, v):
        self.m_AdjMat[u][v] = 0
        self.m_AdjMat[v][u] = 0
        self.m_AdjList[u] = [(x,y) for x,y in self.m_AdjList[u] if x!=v]
        self.m_AdjList[v] = [(x,y) for x,y in self.m_AdjList[v] if x!=u]
        
    def get_adjacency_matrix(self):
        return self.m_AdjMat
    
    def get_adjacency_list(self):
        return self.m_AdjList

在这个实现中，Graph类接收一个整数参数，表示无向图中的顶点数量。然后它定义了两个成员变量：邻接矩阵(m_AdjMat)和邻接表(m_AdjList)，它们都被初始化为具有vertices行和vertices列或vertices个空列表的零矩阵或零列表.

Graph类有两个方法：add_edge和remove_edge，用于添加或删除无向图的边。这些方法将更新邻接矩阵和邻接表。

最后，Graph类还有两个辅助方法：get_adjacency_matrix和get_adjacency_list，用于获取邻接矩阵和邻接表。

希望这个类满足您的需求。

用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();`