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

好的，我来给你写一下。

首先，我们需要定义一个节点的结构体，包括节点的编号和节点的权值，如下所示：

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

接着，我们定义一个图的类，包括以下成员函数：

1. 构造函数：初始化图的大小和邻接矩阵。

2. 深度优先遍历函数：使用递归的方式进行深度优先遍历，并输出遍历序列。

3. 广度优先遍历函数：使用队列的方式进行广度优先遍历，并输出遍历序列。

4. 最短路径函数：使用Dijkstra算法求解源点到图中每个点的最短路径，并输出。

代码如下所示：

#include <iostream>
#include <queue>
#include <vector>
#include <climits>
using namespace std;

const int MAXN = 100;

class Graph {
public:
    Graph(int n, bool directed = false) {
        this->n = n;
        this->directed = directed;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrix[i][j] = INT_MAX;
            }
        }
    }

    void addEdge(int u, int v, int w) {
        matrix[u][v] = w;
        if (!directed) {
            matrix[v][u] = w;
        }
    }

    void dfs(int u, bool visited[]) {
        visited[u] = true;
        cout << u << " ";
        for (int v = 0; v < n; v++) {
            if (matrix[u][v] != INT_MAX && !visited[v]) {
                dfs(v, visited);
            }
        }
    }

    void dfsTraversal() {
        bool visited[MAXN] = { false };
        for (int u = 0; u < n; u++) {
            if (!visited[u]) {
                dfs(u, visited);
            }
        }
        cout << endl;
    }

    void bfsTraversal() {
        bool visited[MAXN] = { false };
        queue<int> q;
        for (int u = 0; u < n; u++) {
            if (!visited[u]) {
                q.push(u);
                visited[u] = true;
                while (!q.empty()) {
                    int v = q.front();
                    q.pop();
                    cout << v << " ";
                    for (int w = 0; w < n; w++) {
                        if (matrix[v][w] != INT_MAX && !visited[w]) {
                            q.push(w);
                            visited[w] = true;
                        }
                    }
                }
            }
        }
        cout << endl;
    }

    void shortestPath(int source) {
        vector<int> dist(n, INT_MAX);
        vector<bool> visited(n, false);
        dist[source] = 0;
        for (int i = 0; i < n; i++) {
            int u = -1;
            for (int j = 0; j < n; j++) {
                if (!visited[j] && (u == -1 || dist[j] < dist[u])) {
                    u = j;
                }
            }
            visited[u] = true;
            for (int v = 0; v < n; v++) {
                if (!visited[v] && matrix[u][v] != INT_MAX && dist[u] + matrix[u][v] < dist[v]) {
                    dist[v] = dist[u] + matrix[u][v];
                }
            }
        }
        cout << "Shortest path from source " << source << ":" << endl;
        for (int i = 0; i < n; i++) {
            cout << "To " << i << ": " << dist[i] << endl;
        }
    }

private:
    int n;
    bool directed;
    int matrix[MAXN][MAXN];
};

int main() {
    Graph g(6);
    g.addEdge(0, 1, 10);
    g.addEdge(0, 4, 5);
    g.addEdge(1, 2, 1);
    g.addEdge(1, 3, 2);
    g.addEdge(2, 3, 4);
    g.addEdge(3, 5, 7);
    g.addEdge(4, 3, 9);
    g.addEdge(4, 5, 3);

    cout << "DFS traversal: ";
    g.dfsTraversal();

    cout << "BFS traversal: ";
    g.bfsTraversal();

    g.shortestPath(0);

    return 0;
}

这段代码中，我们创建了一个含有6个节点的图，并添加了一些边。然后，我们依次调用了dfsTraversal、bfsTraversal和shortestPath函数，分别进行深度优先遍历、广度优先遍历和最短路径求解，并输出了相应的结果。