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

Prim+次小生成树。

次小生成树的两种算法：
算法1、step 1.  先用prim求出最小生成树T.
         在prim的同一时候。用一个矩阵max[u][v] 记录 在T中连结随意两点u,v的唯一的
         路中权值最大的那条边的权值. (注意这里).
         这是非常easy做到的。由于prim是每次增加一个结点s, 而设已经标号了的结点
         集合为W, 则W中全部的结点到s的路中的最大权值的边就是当前增加的这条边.
         step 1 用时 O(V^2).
     step 2.  枚举全部不在T中的边uv, 增加边uv则必定替换权为max[u][v]的边。

算法2、先用prim求出最小生成树T。
           枚举T中的每一条边，把它删除，求剩下的图的最小生成树。

选全部枚举得到的生成树中的最小的那一个。

AC码：

#include<stdio.h>
#include<string.h>
#define INF 99999999
int G[505][505],visit[505],lowcost[505];
int repair[505][505],pre[505],f[505][505];
int main()
{
	int T,v,e,a,b,cost,MinTree,ans,i,j,k,min;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&v,&e);
		//memset(G,INF,sizeof(G));   // 对矩阵G赋值，仅仅能赋为0或-1，假设赋为INF，提交不成功
		for(i=0;i<=v;i++)
		{
			for(j=0;j<=v;j++)
				G[i][j]=INF;
		}
		memset(repair,0,sizeof(repair));

		for(i=0;i<e;i++)
		{
			scanf("%d%d%d",&a,&b,&cost);
			G[a][b]=G[b][a]=cost;
			// 把该边初始为可修状态
			repair[a][b]=repair[b][a]=1;  // repair:修
		}

		// Prim算法生成最小树
		memset(visit,0,sizeof(visit));
		memset(f,0,sizeof(f));
		for(i=1;i<=v;i++)
		{
			lowcost[i]=G[1][i];      // 初始化lowcost的值
			pre[i]=1;                // 辅助数组
		}
		visit[1]=1;
		k=1;
		MinTree=0;
		for(i=1;i<=v;i++)
		{
			min=INF;
			for(j=1;j<=v;j++)
			{
				if(!visit[j]&&min>lowcost[j])
				{
					min=lowcost[j];
					k=j;
				}
			}
			if(min==INF)
				break;
			repair[pre[k]][k]=repair[k][pre[k]]=0;
			MinTree+=min;
			visit[k]=1;
			for(j=1;j<=v;j++)
			{
				if(visit[j])
					f[k][j]=f[j][k]=f[j][pre[k]]>G[pre[k]][k]?f[j][pre[k]]:G[pre[k]][k];
				if(!visit[j]&&G[k][j]<lowcost[j])
				{
					lowcost[j]=G[k][j];
					pre[j]=k;
				}
			}
		}

		// 再求次小生成树
		ans=INF;
		for(i=1;i<=v;i++)
		{
			for(j=1;j<=v;j++)
			{
				if(repair[i][j])
					ans=ans<(MinTree-f[i][j]+G[i][j])?ans:(MinTree-f[i][j]+G[i][j]);
			}
		}
		if(ans==MinTree)
			printf("Yes\n");
		else
			printf("No\n");
	}
	return 0;
}

版权声明：本文博主原创文章，博客，未经同意不得转载。