c++编程1． 对一个实际交通问题抽象为一个连通网，用顶点代表地点，用边代表能直达（例如有高铁），边上的权值可以是里程数、票价或运行时间。 2． 该网用邻接表作为该网的存储结构，可实现：初始化图、提供顶点数量、提供每一条边的信息、插入边、删除边、查找边、深度优先遍历、宽度优先遍历、用普里姆算法求最小代价生成树（即智能交通中的最佳路径选择问题）。 3． 所有功能放在一个程序中实现。提供菜单，通过输入选项编号执行对应功能。 4． 该程序也可以用邻接矩阵作为存储结构实现。

好的，您的问题是如何实现一个交通连通网的存储和操作程序，使用邻接表作为存储结构，并提供各种基本操作功能，对吗？

那么，我可以给您提供一个大体的程序框架，您可以根据需要进行修改和完善。以下是程序的主要代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<vector>
#define MAXN 10005
using namespace std;

struct Edge {
    int to, dis;
    Edge(int to, int dis) : to(to), dis(dis) {}
};

vector<Edge> G[MAXN];   // 存储邻接表

void init() {
    for (int i = 0; i < MAXN; i++) G[i].clear();
}

void add_edge(int u, int v, int d) {
    G[u].push_back(Edge(v, d));
    G[v].push_back(Edge(u, d));
}

void del_edge(int u, int v) {
    for (int i = 0; i < G[u].size(); i++) {
        if (G[u][i].to == v) {
            G[u].erase(G[u].begin() + i);
            break;
        }
    }
    for (int i = 0; i < G[v].size(); i++) {
        if (G[v][i].to == u) {
            G[v].erase(G[v].begin() + i);
            break;
        }
    }
}

Edge find_edge(int u, int v) {
    for (int i = 0; i < G[u].size(); i++) {
        if (G[u][i].to == v) {
            return G[u][i];
        }
    }
    return Edge(-1, -1);
}

void dfs(int u, bool vis[]) {
    vis[u] = true;
    cout << u << " ";
    for (int i = 0; i < G[u].size(); i++) {
        int v = G[u][i].to;
        if (!vis[v]) dfs(v, vis);
    }
}

void bfs(int u, bool vis[]) {
    queue<int> q;
    q.push(u);
    vis[u] = true;
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        cout << x << " ";
        for (int i = 0; i < G[x].size(); i++) {
            int v = G[x][i].to;
            if (!vis[v]) {
                vis[v] = true;
                q.push(v);
            }
        }
    }
}

struct node {
    int v, dis;
    bool operator < (const node &a) const {
        return dis > a.dis;
    }
};

void prim(int n, int s, bool vis[]) {
    priority_queue<node> q;
    for (int i = 0; i < G[s].size(); i++) {
        int v = G[s][i].to, dis = G[s][i].dis;
        q.push((node){v, dis});
    }
    vis[s] = true;
    int cnt = 1;
    while (!q.empty() && cnt < n) {
        node x = q.top();
        q.pop();
        int v = x.v, dis = x.dis;
        if (vis[v]) continue;
        vis[v] = true;
        cnt++;
        cout << s << " " << v << " " << dis << endl;
        for (int i = 0; i < G[v].size(); i++) {
            int u = G[v][i].to, d = G[v][i].dis;
            q.push((node){u, d});
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        add_edge(u, v, w);
    }
    bool vis[MAXN];
    memset(vis, false, sizeof(vis));
    dfs(1, vis);
    cout << endl;
    memset(vis, false, sizeof(vis));
    bfs(1, vis);
    cout << endl;
    memset(vis, false, sizeof(vis));
    prim(n, 1, vis);
    return 0;
}

这个程序中，我们使用 vector 数组 `G` 存储邻接表，其中 `G[i]` 表示与顶点 `i` 相连的所有边。具体函数如下：

- `init()`：初始化邻接表。
- `add_edge(u, v, d)`：添加一条从顶点 `u` 到顶点 `v` 的权值为 `d` 的边，因为是无向图，所以还需要添加一条从顶点 `v` 到顶点 `u` 的边。
- `del_edge(u, v)`：删除从顶点 `u` 到顶点 `v` 的边，因为是无向图，所以还需要删除从顶点 `v` 到顶点 `u` 的边。
- `find_edge(u, v)`：查找顶点 `u` 到顶点 `v` 的边，并返回这条边的权值。
- `dfs(u, vis[])`：深度优先遍历以顶点 `u` 为起点的连通分量，vis 数组用于记录已经访问过的顶点。
- `bfs(u, vis[])`：广度优先遍历以顶点 `u` 为起点的连通分量，vis 数组用于记录已经访问过的顶点。
- `prim(n, s, vis[])`：用普里姆算法求出以顶点 `s` 为起点的最小生成树，vis 数组用于记录已经访问过的顶点。

以上是一个简单的实现，您可以根据需要添加更多的功能或优化代码。如果您需要使用邻接矩阵作为存储结构，可以将 `vector` 数组改为二维数组即可。