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

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

首先，邻接矩阵是一种常用的图的存储方式，对于有$n$个结点的无向图，其邻接矩阵$G$是一个$n \times n$的矩阵，其中$G_{i,j}$表示结点$i$和结点$j$之间是否有边，有边则为1，否则为0。对于有向图，邻接矩阵的定义相应地变为$G_{i,j}$表示从结点$i$到结点$j$是否有一条有向边。

接下来，我们来讲解三个操作：

1.深度优先遍历，并输出遍历序列

深度优先遍历是图的一种遍历方式，其基本思想是从某个结点开始，沿着一条未访问过的边走到尽头，如果没有未访问过的边，则回溯到上一个结点，继续走另外一条未访问过的边，直到所有结点都被访问过为止。

深度优先遍历可以借助栈来实现，具体实现步骤如下：

- 将起始结点入栈；
- 取出栈顶结点，如果该结点未被访问，则输出该结点，并将其标记为已访问；
- 遍历该结点的所有邻接结点，将未被访问过的邻接结点入栈；
- 重复步骤2和步骤3，直到栈为空。

下面是深度优先遍历的示例代码：

void dfs(int u, bool visited[], int n, int** G, vector<int>& result) {
    visited[u] = true;
    result.push_back(u);
    for (int v = 0; v < n; v++) {
        if (G[u][v] && !visited[v]) {
            dfs(v, visited, n, G, result);
        }
    }
}

vector<int> depthFirstSearch(int n, int** G) {
    bool visited[n];
    memset(visited, false, sizeof(visited));
    vector<int> result;
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            dfs(i, visited, n, G, result);
        }
    }
    return result;
}

其中，$visited$数组用于标记结点是否被访问过，$result$数组用于存储遍历序列。

2.广度优先遍历，并输出遍历序列

广度优先遍历是图的另一种遍历方式，其基本思想是从某个结点开始，先访问其所有邻接结点，然后依次访问其邻接结点的邻接结点，直到所有结点都被访问过为止。

广度优先遍历可以借助队列来实现，具体实现步骤如下：

- 将起始结点入队；
- 取出队首结点，如果该结点未被访问，则输出该结点，并将其标记为已访问；
- 遍历该结点的所有邻接结点，将未被访问过的邻接结点入队；
- 重复步骤2和步骤3，直到队列为空。

下面是广度优先遍历的示例代码：

vector<int> breadthFirstSearch(int n, int** G) {
    bool visited[n];
    memset(visited, false, sizeof(visited));
    vector<int> result;
    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();
                result.push_back(u);
                for (int v = 0; v < n; v++) {
                    if (G[u][v] && !visited[v]) {
                        q.push(v);
                        visited[v] = true;
                    }
                }
            }
        }
    }
    return result;
}

其中，$visited$数组和$result$数组的含义与深度优先遍历中相同，$q$队列用于存储待访问的结点。

3.求源点到图中每个点的最短路径，并输出

最短路径算法是图论中一类重要的问题，常用的算法有Dijkstra算法和Bellman-Ford算法。

Dijkstra算法适用于有向无环图和非负边权的情况，其基本思想是从源点开始，每次选择一个距离源点最近的未确定最短路径的结点，然后通过该结点更新所有与它相邻的结点的最短路径。具体实现步骤如下：

- 初始化源点到自身的距离为0，源点到其他结点的距离为无穷大；
- 选择源点为当前未确定最短路径的结点；
- 以该结点为中介点，更新与它相邻的结点的最短路径；
- 重复步骤2和步骤3，直到所有结点的最短路径均已确定。

下面是Dijkstra算法的示例代码：

vector<int> dijkstra(int n, int** G, int s) {
    bool visited[n];
    memset(visited, false, sizeof(visited));
    int dist[n];
    for (int i = 0; i < n; i++) {
        dist[i] = G[s][i];
    }
    visited[s] = true;
    for (int i = 1; i < n; i++) {
        int minDist = INT_MAX;
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < minDist) {
                minDist = dist[j];
                u = j;
            }
        }
        if (u == -1) {
            break;
        }
        visited[u] = true;
        for (int v = 0; v < n; v++) {
            if (!visited[v] && G[u][v] != INT_MAX && dist[u] + G[u][v] < dist[v]) {
                dist[v] = dist[u] + G[u][v];
            }
        }
    }
    vector<int> result;
    for (int i = 0; i < n; i++) {
        result.push_back(dist[i]);
    }
    return result;
}

其中，$dist$数组用于存储源点到各个结点的最短距离，$visited$数组用于标记结点是否已经确定最短路径。

Bellman-Ford算法适用于有向图和负边权的情况，其基本思想是利用松弛操作来逐步缩小源点到各个结点的最短路径估计值，直到估计值收敛为止。具体实现步骤如下：

- 初始化源点到自身的距离为0，源点到其他结点的距离为无穷大；
- 对所有边进行$|V|-1$次松弛操作，其中$|V|$是图中结点的个数；
- 检查是否存在从源点可达的负权回路，如果存在，则算法失败，否则最短路径估计值即为最短路径。

下面是Bellman-Ford算法的示例代码：

vector<int> bellmanFord(int n, int** G, int s) {
    int dist[n];
    for (int i = 0; i < n; i++) {
        dist[i] = INT_MAX;
    }
    dist[s] = 0;
    for (int i = 1; i < n; i++) {
        for (int u = 0; u < n; u++) {
            for (int v = 0; v < n; v++) {
                if (G[u][v] != INT_MAX && dist[u] != INT_MAX && dist[u] + G[u][v] < dist[v]) {
                    dist[v] = dist[u] + G[u][v];
                }
            }
        }
    }
    bool hasNegativeCycle = false;
    for (int u = 0; u < n; u++) {
        for (int v = 0; v < n; v++) {
            if (G[u][v] != INT_MAX && dist[u] != INT_MAX && dist[u] + G[u][v] < dist[v]) {
                hasNegativeCycle = true;
                break;
            }
        }
        if (hasNegativeCycle) {
            break;
        }
    }
    vector<int> result;
    if (hasNegativeCycle) {
        result.push_back(INT_MAX);
    } else {
        for (int i = 0; i < n; i++) {
            result.push_back(dist[i]);
        }
    }
    return result;
}

其中，$dist$数组的含义与Dijkstra算法中相同，$hasNegativeCycle$变量用于标记是否存在从源点可达的负权回路。