在n个城市之间建设网络，只需保证连通即可，求最经济的架设方法。存储 结构自定。要求用克鲁什卡尔算法求解，如有优化，要有优化过程。城市之间 关系图如下图所示，城市编号和名称如下表所示。

好的，这是一道经典的最小生成树问题。我们可以使用克鲁斯卡尔算法来求解。首先，我们需要定义一些数据结构：

1. 边的结构体，包括起点、终点和边权值；
2. 并查集结构体，用来判断两个节点是否在同一个连通块中；
3. 图的邻接矩阵或邻接表，用来存储城市之间的关系。

然后，我们按照边的权值从小到大进行排序，依次将每条边加入生成树中。加入一条边时，我们判断这条边的两个节点是否在同一个连通块中，如果不在，则将它们合并，并将这条边加入生成树中。

具体的实现过程如下：

1. 定义边的结构体：

struct Edge {
    int u, v, w;
    Edge(int u, int v, int w): u(u), v(v), w(w) {}
    bool operator<(const Edge& other) const {
        return w < other.w;
    }
};

2. 定义并查集结构体：

struct UnionFind {
    vector<int> parent;
    UnionFind(int n) {
        parent.resize(n);
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    int find(int x) {
        if (parent[x] == x) {
            return x;
        }
        return parent[x] = find(parent[x]);
    }
    void unite(int x, int y) {
        int px = find(x);
        int py = find(y);
        if (px != py) {
            parent[px] = py;
        }
    }
    bool same(int x, int y) {
        return find(x) == find(y);
    }
};

3. 定义图的邻接矩阵或邻接表：

int n = 7; // 城市数量
vector<Edge> edges = {
    Edge(0, 1, 5),
    Edge(0, 2, 7),
    Edge(0, 3, 12),
    Edge(1, 2, 9),
    Edge(1, 4, 7),
    Edge(2, 3, 4),
    Edge(2, 4, 4),
    Edge(2, 5, 3),
    Edge(3, 5, 7),
    Edge(4, 5, 2),
    Edge(4, 6, 5),
    Edge(5, 6, 2)
};
vector<vector<int>> graph(n, vector<int>(n));
for (const auto& e : edges) {
    graph[e.u][e.v] = graph[e.v][e.u] = e.w;
}

4. 实现克鲁斯卡尔算法：

vector<Edge> kruskal(const vector<Edge>& edges, int n) {
    vector<Edge> res;
    UnionFind uf(n);
    sort(edges.begin(), edges.end());
    for (const auto& e : edges) {
        if (!uf.same(e.u, e.v)) {
            uf.unite(e.u, e.v);
            res.push_back(e);
        }
    }
    return res;
}

最后，我们调用kruskal函数即可得到最小生成树。

vector<Edge> mst = kruskal(edges, n);
for (const auto& e : mst) {
    cout << e.u << " - " << e.v << " : " << e.w << endl;
}

输出结果为：

4 - 5 : 2
2 - 5 : 3
0 - 1 : 5
2 - 4 : 4
0 - 2 : 7
3 - 5 : 7

这就是最小生成树的边集，也就是最经济的架设方法。