Is There A Second Way Left? UVA

　　Nasa, being the most talented programmer of his time, can’t think things to be so simple. Recently all his neighbors have decided to connect themselves over a network (actually all of them want to share a broadband internet connection :-)). But he wants to minimize the total cost of cable required as he is a bit fastidious about the expenditure of the project. For some unknown reasons, he also wants a second way left. I mean, he wants to know the second best cost (if there is any which may be same as the best cost) for the project. I am sure, he is capable of solving the problem. But he is very busy with his private affairs(?) and he will remain so. So, it is your turn to prove yourself a good programmer. Take the challenge (if you are brave enough)...

Input

　　Input starts with an integer t ≤ 1000 which denotes the number of test cases to handle. Then follows t datasets where every dataset starts with a pair of integers v (1 ≤ v ≤ 100) and e (0 ≤ e ≤ 200). v denotes the number of neighbors and e denotes the number of allowed direct connections among them. The following e lines contain the description of the allowed direct connections where each line is of the form ‘start end cost’, where start and end are the two ends of the connection and cost is the cost for the connection. All connections are bi-directional and there may be multiple connections between two ends.

Output

　　There may be three cases in the output

　　　　1. No way to complete the task,

　　　　2. There is only one way to complete the task,

　　　　3. There are more than one way.

　　Output ‘No way’ for the first case, ‘No second way’ for the second case and an integer c for the third case where c is the second best cost. Output for a case should start in a new line.

Sample Input

4

5 4

1 2 5

3 2 5

4 2 5

5 4 5

5 3

1 2 5

3 2 5

5 4 5

5 5

1 2 5

3 2 5

4 2 5

5 4 5

4 5 6

1 0

Sample Output

Case #1 : No second way

Case#2 : No way

Case #3 : 21

Case #4 : No second way

题意：有一些点和一些边，问花费最小的值能否这些边能否将这些点连在一起，有没有第二种连接方案，注意这些边有一些边是重边。对于输出，如果不能连在一起则输出"No way",如果没有第二种让他们连在一起的方案则输出"No second way",如果有第二种方案则输出第二种方案的值。

思路：最小生成树和次小生成树的存在和求值问题，比较简单，由于有重边的情况因此不适合用prim算法，适合用Kruskal算法。具体思路见代码

代码：

#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <iostream>
#define mod 998244353
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

struct node
{
    //x,y表示边的左右端点，value表示边的值
    int x,y,value;
    //flag标记边是否在树上
    bool flag;
}no[205];
//n表示点数,m表示边数
int n,m;
//fa表示树上的顶点
int fa[105];
//ve用于与第i个点有连接的点
vector<int> ve[105];
//maxn存放两点之间的最大值
int maxn[105][105];
//初始化
void init()
{
    //开始时与自己相连的只有自己，同时顶点也是自己
    for(int i=0;i<=n;i++)
    {
        ve[i].clear();
        ve[i].push_back(i);
        fa[i]=i;
    }
}
//查找顶点
int find(int x)
{
    //如果找到顶点，则返回
    if(fa[x]==x)
    {
        return x;
    }
    //递归查找x的上一个点的上一个点，同时压缩路径
    return fa[x]=find(fa[x]);
}
//排序,按边的值从小到大
bool cmp(node a,node b)
{
    return a.value<b.value;
}
//最小生成树Kruskal算法
int kruskal()
{
    //对边进行排序
    sort(no+1,no+m+1,cmp);
    //初始化数据
    init();
    //ans表示最小生成树的权值和,cnt表示已经连接的边数
    int ans=0,cnt=0;
    //遍历所有边
    for(int i=1;i<=m;i++)
    {
        //如果连接了n-1个边，则表示已经连接所有的点了
        if(cnt==n-1)
        {
            break;
        }
        //记录当前边的两边端点的顶点
        int fx=find(no[i].x),fy=find(no[i].y);
        //如果他们不相等则进行操作
        if(fx!=fy)
        {
            //将fx的顶点变成fy，相当于把fx这个树的顶点挂在fy这个树顶的下面
            fa[fx]=fy;
            //生成树的边数加1
            cnt++;
            //加上这个边的权值
            ans+=no[i].value;
            //标记这个边
            no[i].flag=true;
            //对fx，fy则两颗树的所有点遍历
            for(int j=0;j<ve[fx].size();j++)
            {
                for(int k=0;k<ve[fy].size();k++)
                {
                    //将这两可树的所有点之间的最大值都变成现在变的值
                    //由于对no进行过排序，因此此时no[i].value的值是这个树上的最大值
                    maxn[ve[fx][j]][ve[fy][k]]=maxn[ve[fy][k]][ve[fx][j]]=no[i].value;
                }
            }
            //对fx的树遍历，将fx树上的点都连在fy树上
            for(int j=0;j<ve[fx].size();j++)
            {
                ve[fy].push_back(ve[fx][j]);
            }
        }
    }
    //如果连了n-1条边则表示有最小生成树
    if(cnt==n-1)
    {
        return ans;
    }
    else
    {
        return -1;
    }
}
//次小生成树，mst表示最小生成树的权值和
int second_kruskal(int mst)
{
    int ans=INF;
    //遍历所有边
    for(int i=1;i<=m;i++)
    {
        //如果这个边不在最小生成树上
        if(!no[i].flag)
        {
            //计算最小生成树加外边在减内边否的最小值
            ans=min(ans,mst+no[i].value-maxn[no[i].x][no[i].y]);
        }
    }
    return ans;
}

int main()
{
    int t,ans=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d %d %d",&no[i].x,&no[i].y,&no[i].value);
            no[i].flag=0;
        }
        printf("Case #%d : ",ans++);
        int s1=kruskal();
        if(s1==-1)
        {
            printf("No way
");
        }
        else if(m>n-1)
        {
            printf("%d
",second_kruskal(s1));
        }else 
        {
            printf("No second way
");
        }
    }
}