在n个城市之间建设网络，只需保证连通即可，求最经济的架设方法。存储结构自定。要求用克鲁什卡尔算法求解

为了求解这个问题，我们可以先将每个城市视为图中的一个节点，并将城市之间的距离作为节点之间的边权值。然后，我们可以使用克鲁斯卡尔算法来解决这个问题。

克鲁斯卡尔算法的思路是先将所有边按照边权值进行排序，然后从小到大依次加入边，直到所有的节点都被连接为止。在加入边的过程中，需要注意不能形成环，如果形成环，则该边不能加入，直到找到一条不会形成环的边为止。

具体实现可以使用并查集来判断是否形成环，并使用最小堆来进行边的排序。算法的时间复杂度为O(E log E)。

以下是使用C++实现的示例代码：

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

using namespace std;

const int INF = 0x3f3f3f3f;

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;
    }
};

int find(int x, vector<int>& parent) {
    if (x != parent[x]) {
        parent[x] = find(parent[x], parent);
    }
    return parent[x];
}

void merge(int x, int y, vector<int>& parent) {
    int px = find(x, parent);
    int py = find(y, parent);
    parent[px] = py;
}

int kruskal(int n, vector<Edge>& edges) {
    vector<int> parent(n);
    for (int i = 0; i < n; i++) {
        parent[i] = i;
    }

    priority_queue<Edge> pq;
    for (int i = 0; i < edges.size(); i++) {
        pq.push(edges[i]);
    }

    int cnt = 0, ans = 0;
    while (!pq.empty() && cnt < n - 1) {
        Edge e = pq.top();
        pq.pop();
        if (find(e.u, parent) == find(e.v, parent)) {
            continue;
        }
        merge(e.u, e.v, parent);
        ans += e.w;
        cnt++;
    }

    if (cnt < n - 1) {
        return INF;
    } else {
        return ans;
    }
}

int main() {
    int n, m;
    cin >> n >> m;

    vector<Edge> edges;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        edges.push_back(Edge(u - 1, v - 1, w));
    }

    int ans = kruskal(n, edges);
    cout << ans << endl;

    return 0;
}

其中，n表示城市的个数，m表示城市之间的道路数量，edges表示所有的道路信息。最后输出的ans即为最经济的架设方法。