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

好的，以下是使用C++实现题目要求的代码：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f; // 表示正无穷

// 定义邻接矩阵存储方式的网
class Graph {
private:
    int n; // 结点数量
    vector<vector<int>> adj_matrix; // 邻接矩阵

public:
    // 构造函数，初始化邻接矩阵
    Graph(int n) {
        this->n = n;
        adj_matrix.resize(n, vector<int>(n, 0)); // 初始化为0
    }

    // 添加边
    void addEdge(int u, int v, int w) {
        adj_matrix[u][v] = w;
        // 如果是无向图，还要添加一条反向边
        // adj_matrix[v][u] = w;
    }

    // 深度优先遍历
    void DFS(int start_node, vector<bool>& visited, vector<int>& result) {
        visited[start_node] = true;
        result.push_back(start_node);

        for (int i = 0; i < n; i++) {
            if (adj_matrix[start_node][i] != 0 && !visited[i]) {
                DFS(i, visited, result);
            }
        }
    }

    // 广度优先遍历
    void BFS(int start_node, vector<int>& result) {
        vector<bool> visited(n, false);
        queue<int> q;

        visited[start_node] = true;
        q.push(start_node);

        while (!q.empty()) {
            int node = q.front();
            q.pop();
            result.push_back(node);

            for (int i = 0; i < n; i++) {
                if (adj_matrix[node][i] != 0 && !visited[i]) {
                    visited[i] = true;
                    q.push(i);
                }
            }
        }
    }

    // Dijkstra算法求最短路径
    void Dijkstra(int start_node, vector<int>& dist) {
        vector<bool> visited(n, false);

        // 初始化距离数组
        for (int i = 0; i < n; i++) {
            dist[i] = adj_matrix[start_node][i];
        }
        visited[start_node] = true;

        for (int i = 1; i < n; i++) {
            int min_dist = INF;
            int min_node = -1;

            // 找到距离最小的结点
            for (int j = 0; j < n; j++) {
                if (!visited[j] && dist[j] < min_dist) {
                    min_dist = dist[j];
                    min_node = j;
                }
            }

            // 更新距离数组
            if (min_node != -1) {
                visited[min_node] = true;
                for (int j = 0; j < n; j++) {
                    if (!visited[j] && adj_matrix[min_node][j] != 0) {
                        dist[j] = min(dist[j], dist[min_node] + adj_matrix[min_node][j]);
                    }
                }
            }
        }
    }
};

int main() {
    int n = 5; // 结点数量
    Graph g(n);

    // 添加边
    g.addEdge(0, 1, 2);
    g.addEdge(0, 4, 10);
    g.addEdge(1, 2, 3);
    g.addEdge(1, 3, 8);
    g.addEdge(2, 3, 1);
    g.addEdge(3, 0, 4);
    g.addEdge(3, 4, 5);

    // 深度优先遍历
    vector<bool> visited(n, false);
    vector<int> result;
    g.DFS(0, visited, result);
    cout << "DFS: ";
    for (int node : result) {
        cout << node << " ";
    }
    cout << endl;

    // 广度优先遍历
    result.clear();
    g.BFS(0, result);
    cout << "BFS: ";
    for (int node : result) {
        cout << node << " ";
    }
    cout << endl;

    // Dijkstra算法求最短路径
    vector<int> dist(n, INF);
    g.Dijkstra(0, dist);
    cout << "Dijkstra: ";
    for (int d : dist) {
        cout << d << " ";
    }
    cout << endl;

    return 0;
}

以上就是使用C++实现题目要求的代码，希望能够帮助到你。