NYOJ 118-修路方案

修路方案

时间限制： 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)

样例输入

2
3 3
1 2 1
2 3 2
3 1 3
4 4
1 2 2
2 3 2
3 4 2
4 1 2

样例输出

No
Yes

分析：

就是让求次小生成树的，代码中有详细的注释，此处不多做分析了。

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;

#define INF 0x3f3f3f3f
int v,e;
int s[1005][1005],use1[1005][1005],maxn[1005][1005];
int sum=0;

int prim()///求最小生成树的过程
{
    int vis[1005],low[1005],pre[1005];
    int bj,min1;
    memset(vis,0,sizeof(vis));///将该初始化的数组初始化
    memset(use1,0,sizeof(use1));
    memset(maxn,0,sizeof(maxn));
    vis[1]=1;/**次数组是标记数组，因为城市的编号是从1到n的，所以我门任意从一个点开始遍历，
    一般方便，我门都会选择最小的编号，即为1的城市编号，该数组将用过得点都标记起来**/
    bj=1;///这个变量是用来记录与当前节点距离最近的下一个城市得出编号
    for(int i=2;i<=v;i++)///我门选择从1开始，于是将将剩下的编号与1的距离都存在low数组里
    {
        low[i]=s[bj][i];
        pre[i]=1;///该数组是那个点到i点的，说白了与i相连的上一个节点
    }
    pre[1]=0;///将1的前驱节点设为0，因为他没有前驱节点
    for(int i=1;i<v;i++)///找剩下的v-1个点，也可以说找v-1条边
    {
        min1=INF;///这里别忘了，每一轮都要刷
        for(int j=1;j<=v;j++)///遍历v个点
        {
            if(!vis[j]&&min1>low[j])///如果该点没有被使用过并且路径能被更新
            {
                bj=j;///记录编号
                min1=low[j];///更新值
            }
        }
        sum+=min1;///将找到的最小生成树的边加到最小生成树的总值里
        vis[bj]=1;///将找到的点标记
        use1[bj][pre[bj]]=use1[pre[bj]][bj]=1;/**将构成最小生成树的边都标记一下，
    待次小生成树找边的时候就不能找这些被标记的边**/
        for(int j=1;j<=v;j++)///更新
        {
            if(vis[j])/**如果该点被标记过，也就是走过了，我们就要更新点bj与点j的maxn数组值，
                这里肯定会有宝宝们疑问为什么只更新走过的点呢，其实很简单，对于没有走过的点，
                就最小生成树中来说，你给他添加一条边，它也构不成回路，所以不用着急更新，这个数组
                的作用就是在找次小生成书的时候要减去环中的最大边用的**/
                maxn[j][bj]=maxn[bj][j]=max(maxn[j][pre[bj]],low[bj]);
            if(!vis[j]&&low[j]>s[bj][j])/**这是用来更新low数组的，因为没有走过的点和走过的点任意一点相连
            就可以实现连通，当然我们会找最小的距离喽，但是更新的时候别忘了，将前驱节点也要一并更新了**/
            {
                low[j]=s[bj][j];
                pre[j]=bj;
            }
        }
    }
    return sum;
}

int sprim()///求次小生成树
{
    int ans=INF;///记录次小生成树的总值
    for(int i=1;i<=v;i++)///遍历所有的边
    {
        for(int j=i+1;j<=v;j++)
        {
            if(!use1[i][j]&&s[i][j]!=INF)///如果该边不是构成最小生成树的边而且可以走的通
            {
                ans=min(sum+s[i][j]-maxn[i][j],ans);///更新次小生成树，加上该边减去环中最大的边
            }
        }
    }
    return ans;
}

int main()
{
    int t,a,b,c;
    scanf("%d",&t);
    while(t--)
    {
        memset(s,INF,sizeof(s));///别忘记将该数组先刷大
        scanf("%d %d",&v,&e);
        for(int i=1;i<=e;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            s[a][b]=s[b][a]=min(s[a][b],c);///双向连接，防止有重复输入路径的情况
        }
        if(prim()==sprim())///判断次小生成树和最小生成树的结果是否一样
            printf("Yes\n");
        else
            printf("No\n");
    }
    return 0;
}