Roads and Libraries（最小生成树）

最新推荐文章于 2024-07-12 17:33:58 发布

原创最新推荐文章于 2024-07-12 17:33:58 发布 · 549 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#最小生成树 #并查集 #数据结构

图论专栏收录该内容

15 篇文章

订阅专栏

针对一个遭受龙卷风破坏的国家，本篇介绍了一种算法来确定修复道路和重建图书馆的最低成本，确保所有市民都能访问到图书馆。

The Ruler of HackerLand believes that every citizen of the country should have access to a library. Unfortunately, HackerLand was hit by a tornado that destroyed all of its libraries and obstructed its roads! As you are the greatest programmer of HackerLand, the ruler wants your help to repair the roads and build some new libraries efficiently.

HackerLand has cities numbered from to . The cities are connected by bidirectional roads. A citizen has access to a library if:

Their city contains a library.
They can travel by road from their city to a city containing a library.

The following figure is a sample map of HackerLand where the dotted lines denote obstructed roads:

The cost of repairing any road is dollars, and the cost to build a library in any city is dollars.

You are given queries, where each query consists of a map of HackerLand and value of and .

For each query, find the minimum cost of making libraries accessible to all the citizens and print it on a new line.

Input Format

The first line contains a single integer, , denoting the number of queries. The subsequent lines describe each query in the following format:

The first line contains four space-separated integers describing the respective values of (the number of cities), (the number of roads), (the cost to build a library), and (the cost to repair a road).
Each line of the subsequent lines contains two space-separated integers, and , describing a bidirectional road connecting cities and .

Constraints

Each road connects two distinct cities.

Output Format

For each query, print an integer denoting the minimum cost of making libraries accessible to all the citizens on a new line.

Sample Input

Sample Output

4
12

Explanation

We perform the following queries:

HackerLand contains cities connected by bidirectional roads. The price of building a library is and the price for repairing a road is .

The cheapest way to make libraries accessible to all is to:
- Build a library in city at a cost of .
- Repair the road between cities and at a cost of .
- Repair the road between cities and at a cost of .
This gives us a total cost of . Note that we don't need to repair the road between cities and because we repaired the roads connecting them to city !
In this scenario it's optimal to build a library in each city because the cost of building a library () is less than the cost of repairing a road ().

There are cities, so the total cost is .

题目大意：一个国家的路和图书馆都被损坏了，脑残国王想让每个城市都能有或者通过游历别的国家到达图书馆，给你几个点和几条被损坏的路和修一个图书馆和修一条路的花费，让你判断最小花费。
这道题卡了我至少一个点！我的大体思路就是一次类似最小生成树操作，得出最小生成树的边数（包括各个连通分量的）和联通分量数，然后就有两种方案：要么全建图书馆，要么在一个连通分量里建一个图书馆并把其余路给修通。一直感觉思路没问题！赛后试了各种数据，终于发现了个BUG！ Vector数组没清零！多么痛的领悟！另外这个还有个坑点就是最后结果得用longlong，不然会爆。并查集貌似也能作。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstring>
#include <queue>
#define N 0x3f3f3f3f
#define M 100100
using namespace std;
long long int n;
int cr, cl;
int m;
vector <int> Map[M];
int vis[M];//标记i是否访问
int prim(int s);//prim算法找最小生成树
int judge(int s);//判断是否还有未访问的点， 否则返回未访问点
void judge2(int u, int v);//主要是判断Map里有没有重边
int main()
{
    int q;
    scanf("%d", &q);
    while(q--)
    {
        memset(vis, 0, sizeof(vis));
        scanf("%lld%d%d%d", &n, &m, &cl, &cr);
        int u, v;
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d", &u, &v);
            judge2(u, v);
            judge2(v, u);
        }
        long long int e_cnt = prim(1);//敲黑板！ 要用长整型存最小生成树边数， 不然最后一步计算会爆！
        long long int v_cnt = 1;//同上， 存连通分量数
        int x = 1;//记录遍历点
        while(x)
        {
            x = judge(x);//从x点开始判断是否还有未访问的点， 有的话就连通分量数加一，e_cnt加上从这点开是最小生成树边数
            if(!x)
            {
                break;
            }
            else
            {
                e_cnt += prim(x);
                v_cnt ++;
            }
        }
        long long int cost1 = e_cnt * cr + v_cnt * cl;//会爆int的一步。。。。
        long long int cost2 = n * cl;//同上
        printf("%lld\n", min(cost1, cost2));
        for(int i = 0; i <= n; i++)
        {
            Map[i].clear();//vector 清零！多么痛的领悟！
        }
    }
    return 0;
}
int prim(int s)//算是prim算法一个小小的变化吧
{
    queue <int> q;
    int cnt = 0;
    q.push(s);
    vis[s] = 1;
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        int S = Map[t].size();
        for(int i = 0; i < S; i++)
        {
            int tt = Map[t][i];
            if(!vis[tt])
            {
                vis[tt] = 1;
                q.push(tt);
                cnt ++;
            }
        }
    }
    return cnt;

}
int judge(int s)
{
    for(int i = s; i <= n; i++)
    {
        if(!vis[i])
            return i;
    }
    return 0;
}
void judge2(int u, int v)
{
    int S = Map[u].size();
    for(int i = 0; i < S; i++)
    {
        if(Map[u][i] == v)
            return;
    }
    Map[u].push_back(v);
}