NYOJ 118 修路方案

最新推荐文章于 2022-07-27 10:38:05 发布

dlj1713779797

最新推荐文章于 2022-07-27 10:38:05 发布

阅读量547

点赞数

分类专栏：最小生成树文章标签： kruskal 次小生成树

本文链接：https://blog.csdn.net/dlj1713779797/article/details/51444549

版权

最小生成树专栏收录该内容

4 篇文章 0 订阅

订阅专栏

修路方案

时间限制： 3000 ms | 内存限制： 65535 KB

难度： 5

描述

南将军率领着许多部队，它们分别驻扎在N个不同的城市里，这些城市分别编号1~N，由于交通不太便利，南将军准备修路。

现在已经知道哪些城市之间可以修路，如果修路，花费是多少。

现在，军师小工已经找到了一种修路的方案，能够使各个城市都联通起来，而且花费最少。

但是，南将军说，这个修路方案所拼成的图案很不吉利，想让小工计算一下是否存在另外一种方案花费和刚才的方案一样，现在你来帮小工写一个程序算一下吧。

输入

第一行输入一个整数T(1<T<20)，表示测试数据的组数
每组测试数据的第一行是两个整数V,E，(3<V<500,10<E<200000)分别表示城市的个数和城市之间路的条数。数据保证所有的城市都有路相连。
随后的E行，每行有三个数字A B L，表示A号城市与B号城市之间修路花费为L。

输出

对于每组测试数据输出Yes或No（如果存在两种以上的最小花费方案则输出Yes,如果最小花费的方案只有一种，则输出No)

样例输入

样例输出

No
Yes

分析：用kruskal算法先求最小生成树，标记出构成最小生成树边，然后枚举这些边，每次删一条，然后求一次生成树，将其值保存起来。求完之后，把删除的边补回去。进行下一次删边，枚举过程中保存最小值，如果最小值跟原来的最小生成树的值相等的话，则说明，该最小生成不唯一，反之唯一。

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>

using namespace std;

struct edge
{
    int u,v,cost,flag;
    bool operator < (const edge &w)const //按费用由小到大排序
    {
        return cost < w.cost;
    }
}a[200010];
int n,m;
int p[510];

void init(int n)//并查集初始化
{
    for(int i = 0;i <= n;i++)
        p[i] = i;
}

int Find(int x) // 并查集查找
{
    while(x != p[x])
    {
        x = p[x];
    }
    return x;
}

int isok()//用并查集判断所有的点是否连通
{
    int w = Find(1);
    for(int i = 2;i <= n;i++)
    {
        if(Find(i) != w)
            return 0;
    }
    return 1;
}

int kruskal(int k)
{
    int sum = 0;
    init(n);//初始化
    for(int i = 0;i < m;i++)
    {
        if(i != k)//去掉k这条边
        {
            int x = Find(a[i].u);
            int y = Find(a[i].v);
            if(x != y)
            {
                sum += a[i].cost;
                p[x] = y;
            }
        }
    }
    if(isok())//如果是生成树，则返回其权值
        return sum;
    else
        return -1;
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        for(int i = 0;i < m;i++)
        {
            scanf("%d %d %d",&a[i].u,&a[i].v,&a[i].cost);
            a[i].flag = 0;
        }
        init(n);//初始化
        sort(a,a + m);
        int ans = 0;
        for(int i = 0;i < m;i++)
        {
            //用并查集判断u，v是否属于同一连通分量，即判断是否产生圈
            int x = Find(a[i].u);
            int y = Find(a[i].v);
            if(x != y)    //如果不在一个连通分量
            {
                ans += a[i].cost;//将权值加入结果中
                p[x] = y;//合并连通分量
                a[i].flag = 1;//将加入集合的边进行标记
            }
        }
        int flag = 0;
        for(int i = 0;i < m;i++)
        {
            if(a[i].flag == 1) //去掉求得的最小生成树中的一条边，重新求取最小生成树
            {
                if(kruskal(i) == ans)//如果求得的结果跟之前的相等
                {
                    flag = 1;//表示次小生成树存在
                    break;
                }
            }
        }
        if(flag)
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}