修路方案

修路方案

时间限制： 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找最小生成树， 并在最小生成树的同时维护一个maxch[i][j]数组（边ij的可替换边中最长边）， 并替换其中可替换的最长边找到次小生成树。

//次小生成树
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NUM 501
#define INF 0xfffffff
int n, m, side[MAX_NUM][MAX_NUM], mark[MAX_NUM], pre[MAX_NUM], maxch[MAX_NUM][MAX_NUM], dis[MAX_NUM];

int mymax(int a, int b)
{
	return a > b ? a : b;
}

int prim()
{
	int i, j, tmin, var, first, second;
	memset(dis, 127, sizeof(dis));
	memset(pre, 0, sizeof(pre));
	memset(mark, 0, sizeof(mark));
	memset(maxch, 0, sizeof(maxch));
	dis[1] = 0;
	first = 0;
	for(i = 1; i <= n; i++)
	{
		tmin = INF;                         
		for(j = 1; j <= n; j++)
		{
			if(dis[j] < tmin && !mark[j])           //找一个权值最小的点作为起点
			{
				tmin = dis[j];
				var = j;
			}
		}
		first += tmin;                              //找完一个点就加上，不用最后加了
		mark[var] = 1;
		maxch[var][pre[var]] = side[var][pre[var]];   //初始化maxch， maxch[i][j]：在已搜过的点找可替换的最大的边
		maxch[pre[var]][var] = maxch[var][pre[var]];
		side[var][pre[var]] = 0;                      //搜过的边权清零，避免与后面判断次小生成树冲突
		side[pre[var]][var] = 0;
		for(j = 1; j <= n; j++)                       //遍历所有以搜过的点在设置maxch, 注意到上一个点的maxch不变，有动归的意思
		{
			if(mark[j] && j != var)
			{
				maxch[var][j] = mymax(maxch[var][pre[var]], maxch[pre[var]][j]);
				maxch[j][var] = maxch[var][j];
			}
		}
		for(j = 1; j <= n; j++)
		{
			if(side[var][j] && !mark[j])              //更新到附近的dis
			{
				if(side[var][j] < dis[j])
				{
					dis[j] = side[var][j];
					pre[j] = var;                      //设置上个节点pre[]
				}
			}
		}
	}
	second = INF;
	for(i = 1; i <= n; i++)
	{
		for(j = 1; j <= n; j++)
		{
			if(i != j && side[i][j] && first - maxch[i][j] + side[i][j] < second) //遍历未加入最小生成树的边， 找到可替换的最小边
			{
				second = first - maxch[i][j] + side[i][j];
			}
		}
	}
	if(first == second)               //判断最小生成树和次小生成树的值是否相同
	{
		return 1;
	}
	return 0;
}

int main()
{
	int t, i, sp, ep, val;
	scanf("%d", &t);
	while(t--)
	{
		scanf("%d%d", &n, &m);
		memset(side, 0, sizeof(side));
		for(i = 0; i < m; i++)
		{
			scanf("%d%d%d", &sp, &ep, &val);
			side[sp][ep] = side[ep][sp] = val;
		}
		if(prim())
		{
			printf("Yes\n");
		}
		else
		{
			printf("No\n");
		}
	}
	return 0;
}