用c++定义一有n个结点的的以邻接矩阵为存储方式的网（有向或无向均可），并对其进行如下操作：1.深度优先遍历，并输出遍历序列；2.广度优先遍历，并输出遍历序列；3.求源点到图中每个点的最短路径，并输出；

好的，我可以帮你回答这个问题。

对于这个问题，我们可以先定义一个结构体来表示图中的每一个节点：

struct Node {
    int val;  // 节点的值
    bool visited;  // 标记该节点是否已被访问过
};

接着，我们可以定义一个类 `Graph` 来表示整个图：

class Graph {
public:
    Graph(int n);  // 构造函数，n 表示节点的个数
    void addEdge(int from, int to, int weight);  // 添加一条边
    void DFS(int node);  // 深度优先遍历
    void BFS(int node);  // 广度优先遍历
    void shortestPath(int src);  // 求源点到图中每个点的最短路径

private:
    int n;  // 节点的个数
    int** adjMatrix;  // 邻接矩阵
    Node* nodes;  // 节点数组
};

在 `Graph` 类中，我们定义了三个公有函数：

- `addEdge`: 添加一条边
- `DFS`: 深度优先遍历
- `BFS`: 广度优先遍历
- `shortestPath`: 求源点到图中每个点的最短路径

接下来，我们来实现这些函数。

首先是构造函数，我们需要初始化邻接矩阵和节点数组：

Graph::Graph(int n) {
    this->n = n;
    adjMatrix = new int*[n];
    for (int i = 0; i < n; i++) {
        adjMatrix[i] = new int[n];
        for (int j = 0; j < n; j++) {
            adjMatrix[i][j] = 0;
        }
    }
    nodes = new Node[n];
    for (int i = 0; i < n; i++) {
        nodes[i].val = i;
        nodes[i].visited = false;
    }
}

接着是添加一条边的函数：

void Graph::addEdge(int from, int to, int weight) {
    adjMatrix[from][to] = weight;
}

接下来是深度优先遍历函数，我们可以使用递归的方式来实现：

void Graph::DFS(int node) {
    cout << node << " ";
    nodes[node].visited = true;
    for (int i = 0; i < n; i++) {
        if (adjMatrix[node][i] != 0 && !nodes[i].visited) {
            DFS(i);
        }
    }
}

广度优先遍历函数可以使用队列来实现：

void Graph::BFS(int node) {
    queue<int> q;
    q.push(node);
    nodes[node].visited = true;
    while (!q.empty()) {
        int curr = q.front();
        q.pop();
        cout << curr << " ";
        for (int i = 0; i < n; i++) {
            if (adjMatrix[curr][i] != 0 && !nodes[i].visited) {
                q.push(i);
                nodes[i].visited = true;
            }
        }
    }
}

最后是求源点到图中每个点的最短路径函数，我们可以使用 Dijkstra 算法来实现：

void Graph::shortestPath(int src) {
    int* dist = new int[n];
    bool* visited = new bool[n];
    for (int i = 0; i < n; i++) {
        dist[i] = INT_MAX;
        visited[i] = false;
    }
    dist[src] = 0;
    for (int i = 0; i < n - 1; i++) {
        int minDist = INT_MAX;
        int minNode = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < minDist) {
                minDist = dist[j];
                minNode = j;
            }
        }
        visited[minNode] = true;
        for (int j = 0; j < n; j++) {
            if (adjMatrix[minNode][j] != 0 && !visited[j]) {
                int newDist = dist[minNode] + adjMatrix[minNode][j];
                if (newDist < dist[j]) {
                    dist[j] = newDist;
                }
            }
        }
    }
    for (int i = 0; i < n; i++) {
        cout << "Shortest distance from " << src << " to " << i << " is: " << dist[i] << endl;
    }
}

这样，我们就完成了对于有n个结点的的以邻接矩阵为存储方式的网（有向或无向均可）的深度优先遍历、广度优先遍历和求源点到图中每个点的最短路径的操作。