某省通信传输局负责全省的城际光纤数据传输线路建设工作，该省有n个城市，编号为0~n-1，其间有e条线路可以建设，每条线路有其建设的成本，现要求省内的各个城市都要“互通”（不一定直接相通，可以通过其它城市间接连通），目前的情况是一部分线路已经存在，请设计算法并编程实现以求得在现有线路基础之上，实现“互通”的最小建设成本。 具体测试数如下： 城市数量n=7（编号0~6），边的数量m=9，线路（起点、终点）、建设成本、是否已建设有以下四元组序列表示（0,1,6,0）、（0,5,1,0）、（1,2,4,0）、（1,6,3,1）、（2,3,2,0）、（3,4,6,1）、（3,6,5,0）、（4,5,8,0）、（4,6,7,0） 程序运行结果，请按算法过程输出选用的线路信息和最小总成本为13，用C++实现并分析算法时间复杂度

这是一个典型的最小生成树问题，可以使用Kruskal算法或Prim算法来解决。这里我们使用Kruskal算法来实现。

Kruskal算法的基本思想是从小到大选择边加入生成树中，直到所有点都在同一个连通块中为止。具体实现时，可以使用并查集来判断两个点是否在同一个连通块中，并使用优先队列（最小堆）来选择边。

以下是C++实现代码和时间复杂度分析：

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

using namespace std;

// 定义边的结构体
struct Edge {
    int from, to, cost;
};

// 定义并查集
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) {
        parent[find(x)] = find(y);
    }
};

// 定义优先队列的比较函数
struct cmp {
    bool operator()(const Edge& a, const Edge& b) {
        return a.cost > b.cost;
    }
};

int main() {
    int n = 7, m = 9;
    vector<Edge> edges = {{0, 1, 6}, {0, 5, 1}, {1, 2, 4}, {1, 6, 3}, {2, 3, 2}, {3, 4, 6}, {3, 6, 5}, {4, 5, 8}, {4, 6, 7}};
    int ans = 0; // 最小总成本
    int cnt = 0; // 已选边数
    UnionFind uf(n); // 初始化并查集
    priority_queue<Edge, vector<Edge>, cmp> pq; // 初始化优先队列
    for (auto edge : edges) {
        if (edge.cost == 0) { // 已建设的线路直接加入连通块
            uf.unite(edge.from, edge.to);
            cnt++;
        } else { // 未建设的线路加入优先队列
            pq.push(edge);
        }
    }
    while (!pq.empty() && cnt < n - 1) { // 选择边直到所有点在同一个连通块中
        Edge edge = pq.top();
        pq.pop();
        if (uf.find(edge.from) != uf.find(edge.to)) {
            uf.unite(edge.from, edge.to);
            ans += edge.cost;
            cnt++;
            cout << "选用线路：" << edge.from << "-" << edge.to << "，成本为：" << edge.cost << endl;
        }
    }
    cout << "最小总成本为：" << ans << endl;
    return 0;
}

时间复杂度分析：

初始化并查集的时间复杂度为O(n)，将已建设的线路加入连通块的时间复杂度为O(m)，初始化优先队列的时间复杂度为O(m log m)，选择边直到所有点在同一个连通块中的时间复杂度为O(m log n)，因此总的时间复杂度为O(m log m)。在本例中，m=9，因此时间复杂度为O(9 log 9)，即O(1)级别。