信息学奥赛一本通 1392：繁忙的都市(city) | 洛谷 P2330 [SCOI2005]繁忙的都市

【题目链接】

ybt 1392：繁忙的都市(city)
洛谷 P2330 [SCOI2005]繁忙的都市

【题目考点】

1. 图论 最小生成树

【解题思路】

将题目叙述转为图论概念，交叉路口为顶点，道路为边，道路是双向的，且所有交叉路口都直接或间接连接起来，说明这是无向连通图。每条道路的分值，就是边的权值。政府要改造一些道路，就是选一些边。
三个要求的概念分别为：

1. 选择的边构成的图应该是连通图，且应该包含原图所有顶点。
2. 选择的边尽可能少。
   边最少时，该图就成了无根树。边数为顶点数减1。
   综合以上两点，选择的边及顶点构成的图就是原图的生成树。
3. 生成树有多种方案，选择其中权值最大的边最小的那一种生成树方案，即瓶颈生成树。

树上最大边权值在图的所有生成树中最小的生成树，叫做瓶颈生成树。
最小生成树一定是瓶颈生成树，但瓶颈生成树未必是最小生成树。（其证明见百度百科）

题目要求的就是瓶颈生成树，我们可以直接求出最小生成树，它一定是瓶颈生成树。
该题顶点数<=300，边数<=100000，使用Prim，Prim堆优化，Kruskal都可以完成该题。

【题解代码】

解法1：朴素Prim算法

#include<bits/stdc++.h>
using namespace std;
#define N 305
struct Edge
{
    int v, w;
    Edge(){}
    Edge(int a, int b):v(a),w(b){};
};
vector<Edge> edge[N];
bool vis[N];
int n, m, mx, dis[N];
void prim()
{
    memset(dis, 0x3f, sizeof(dis));
    dis[1] = 0;
    for(int k = 1; k <= n; ++k)
    {
        int u = 0;
        for(int i = 1; i <= n; ++i)
            if(vis[i] == false && (u == 0 || dis[i] < dis[u]))
                u = i;
        vis[u] = true;
        mx = max(mx, dis[u]);
        for(Edge e : edge[u])
        {
            int v = e.v, w = e.w;
            if(vis[v] == false && dis[v] > w)
                dis[v] = w;
        }
    }
}
int main()
{
    int f, t, w;
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> w;
        edge[f].push_back(Edge(t, w));
        edge[t].push_back(Edge(f, w));
    }
	prim();
    cout << n-1 << ' ' << mx;
    return 0;
}

解法2：Prim算法堆优化

#include<bits/stdc++.h>
using namespace std;
#define N 305
struct Pair
{
    int v, d;
    Pair(){}
    Pair(int a, int b):v(a),d(b){}
    bool operator < (const Pair &b) const
    {
        return b.d < d;
    }
};
struct Edge
{
    int v, w;
    Edge(){}
    Edge(int a, int b):v(a),w(b){};
};
vector<Edge> edge[N];
bool vis[N];
int n, m, mx, dis[N];
void prim()
{
    memset(dis, 0x3f, sizeof(dis));
    priority_queue<Pair> pq;
    pq.push(Pair(1, 0));
    dis[1] = 0;
    int visNum = 0;
    while(pq.empty() == false)
    {
        int u = pq.top().v;
        pq.pop();
        if(vis[u])
            continue;
        vis[u] = true;
        mx = max(mx, dis[u]);
        if(++visNum == n)
        	break;
        for(Edge e : edge[u])
        {
            int v = e.v, w = e.w;
            if(vis[v] == false && dis[v] > w)
            {
                dis[v] = w;
                pq.push(Pair(v, dis[v]));
            }
        }
    }
}
int main()
{
	int f, t, w;
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> w;
        edge[f].push_back(Edge(t, w));
        edge[t].push_back(Edge(f, w));
    }
    prim();
    cout << n-1 << ' ' << mx;
    return 0;
}

解法2：Kruskal算法

#include<bits/stdc++.h>
using namespace std;
#define N 305
struct Edge
{
    int f, t, w;
    Edge(){}
    Edge(int a, int b, int c):f(a),t(b),w(c){};
    bool operator < (const Edge &b) const
    {
        return w < b.w;
    }
};
vector<Edge> edges;
bool vis[N];
int fa[N];
int n, m, mx, en;
void initFa()
{
    for(int i = 1; i <= n; ++i)
        fa[i] = i;
}
int find(int x)
{
    return x == fa[x] ? x : (fa[x] = find(fa[x]));
}
void merge(int x, int y)
{
    fa[find(x)] = find(y);
}
void init()
{
    int f, t, w;
    cin >> n >> m;
    for(int i = 1; i <= m; ++i)
    {
        cin >> f >> t >> w;
        edges.push_back(Edge(f, t, w));
    }
}
void kruskal()
{
    sort(edges.begin(), edges.end());
    for(int i = 0; i < edges.size(); ++i)
    {
        int f = edges[i].f, t = edges[i].t, w = edges[i].w;
        if(find(f) != find(t))
        {
            merge(f, t);
            mx = max(mx, w);
            if(++en == n - 1)
                break;
        }
    }
}
int main()
{
    init();
    initFa();
    kruskal();
    cout << n-1 << ' ' << mx;
    return 0;
}