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

好的，我来回答你的问题。

首先，我们需要定义一个结构体来表示图的每个节点，包含节点编号和节点值两个属性：

struct Node {
    int id; // 节点编号
    int value; // 节点值
};

然后，我们可以定义一个类来表示以邻接矩阵为存储方式的网，包含节点数量、邻接矩阵和节点列表等属性：

class Graph {
public:
    Graph(int n); // 构造函数，n为节点数量
    void addEdge(int u, int v, int w); // 添加一条从节点u到节点v的边，权重为w
    void dfs(); // 深度优先遍历
    void bfs(); // 广度优先遍历
    void shortestPath(int s); // 求源点s到图中每个点的最短路径
private:
    int n; // 节点数量
    vector<Node> nodes; // 节点列表
    vector<vector<int>> adjMatrix; // 邻接矩阵
    void dfsHelper(int u, vector<bool>& visited); // 深度优先遍历的辅助函数
};

在构造函数中，我们需要初始化节点列表和邻接矩阵：

Graph::Graph(int n) {
    this->n = n;
    // 初始化节点列表
    for (int i = 0; i < n; i++) {
        nodes.push_back({i, 0});
    }
    // 初始化邻接矩阵
    adjMatrix.resize(n, vector<int>(n, 0));
}

添加边的函数也很简单，我们只需要在邻接矩阵中标记两个节点之间的连通关系即可：

void Graph::addEdge(int u, int v, int w) {
    adjMatrix[u][v] = w;
}

接下来是深度优先遍历和广度优先遍历。深度优先遍历可以使用递归实现，我们从某个起点开始遍历，对于每个未被访问过的邻居节点，递归地进行深度优先遍历。遍历过程中需要记录已经访问过的节点：

void Graph::dfs() {
    vector<bool> visited(n, false);
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfsHelper(i, visited);
        }
    }
}

void Graph::dfsHelper(int u, vector<bool>& visited) {
    visited[u] = true;
    cout << nodes[u].id << " ";
    for (int v = 0; v < n; v++) {
        if (adjMatrix[u][v] != 0 && !visited[v]) {
            dfsHelper(v, visited);
        }
    }
}

广度优先遍历需要使用队列来实现，我们从某个起点开始遍历，将其加入到队列中，然后依次取出队列中的节点，并将其所有未被访问过的邻居节点加入到队列中。遍历过程中需要记录已经访问过的节点：

void Graph::bfs() {
    vector<bool> visited(n, false);
    queue<int> q;
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            q.push(i);
            visited[i] = true;
            while (!q.empty()) {
                int u = q.front();
                q.pop();
                cout << nodes[u].id << " ";
                for (int v = 0; v < n; v++) {
                    if (adjMatrix[u][v] != 0 && !visited[v]) {
                        q.push(v);
                        visited[v] = true;
                    }
                }
            }
        }
    }
}

最后是求源点到图中每个点的最短路径。我们可以使用Dijkstra算法或者Bellman-Ford算法来解决，这里我选择使用Dijkstra算法，时间复杂度为O(n^2)。

Dijkstra算法的基本思想是贪心，每次选择当前距离源点最近的节点，并更新其邻居节点的距离。具体实现可以使用优先队列来加速查找最近的节点：

void Graph::shortestPath(int s) {
    vector<int> dist(n, INT_MAX);
    dist[s] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({0, s});
    while (!pq.empty()) {
        int u = pq.top().second;
        pq.pop();
        for (int v = 0; v < n; v++) {
            if (adjMatrix[u][v] != 0) {
                int newDist = dist[u] + adjMatrix[u][v];
                if (newDist < dist[v]) {
                    dist[v] = newDist;
                    pq.push({newDist, v});
                }
            }
        }
    }
    for (int i = 0; i < n; i++) {
        cout << "Shortest distance from " << s << " to " << nodes[i].id << " is " << dist[i] << endl;
    }
}

至此，我们已经完成了三个操作。完整代码如下：