Confidential----Ural_1416----次小生成树

题目地址：http://acm.timus.ru/problem.aspx?space=1&num=1416

题目的意思是：要你求最小生成树的值和出了这个除了这个以外的最小值，可能和它相同，可能比它大。如果第二个情况不存在的话就输出-1。

这个就涉及到怎样求除了最小生成树以外的第二小生成树，也就是我们所说的次小生成树的问题。在这里我写了一个比较丑陋的算法，不能和大牛的相比，但是是我想了一个下午的时光加上晚上的时光才弄出来的。我的想法十分的直接，那就是先求出最小生成树，并把已经加入到这个边的标记。然后在接下来的算法中一次枚举删除每条边。再在其它的里面求最小生成树。这样结果就出来了。有一个细节要注意的就是每次删除求了之后要还原。再就是特别是在求第二小生成树的时候要看能否求出，如果无法求出，则返回的应是-1。

下面贴出AC的代码：

#include<iostream>
#include<algorithm>
using namespace std;

#define MAXN 505
#define MAXM 300000
#define INF  99999999

struct edge
{
    int u,v,w;
    int used;
    int del;
}e[MAXM];

int father[MAXN];
int n,m;
bool flag_first;

int find(int x)
{
    int s;
    for(s=x;father[s]>=0;s=father[s]);
    while(s!=x)                     //这里用到的是所谓的路径压缩，方便后面的查找
    {
        int t = father[x];
        father[x] = s;
        x = t;
    }
    return s;
}

void Union(int x,int y)
{
    int x1 = find(x);
    int y1 = find(y);
    int tmp = father[x1]+father[y1]; //这里是两个集合的总个数（负数）

    if(father[x1] > father[y1])      //采用这样的合并判断，也是为了减少深度
    {
        father[x1] = y1;
        father[y1] = tmp;
    }
    else
    {
        father[y1] = x1;
        father[x1] = tmp;
    }
}

bool cmp(edge a,edge b)
{
    return a.w < b.w;
}


void initset()
{
    int i;
    for(i=0;i<=n;i++)
        father[i] = -1;
}

void init()
{
    int i,j;
    //scanf("%d%d",&n,&m);

    initset();

    for(i=1;i<=m;i++)
    {
        scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
        e[i].del = 0;
        e[i].used = 0;
    }

    //the next we sign the edges which have the same w
    sort(e+1,e+1+m,cmp);
}

int Kruskal()
{
    int sum = 0;
    int num = 0;
    int u,v;

    for(int i=1;i<=m;i++)
    {
        if(e[i].del == 1)//the edge has been out
            continue;
        u = e[i].u;
        v = e[i].v;
        if(find(u) != find(v))
        {
            num++;
            sum+=e[i].w;
            Union(u,v);
            if(flag_first) //看是不是第一次求最小生成树，用来标记是否是第一个里面的最小生成树的边
                e[i].used = 1;
        }
        if(num>=n-1)
            break;
    }

    //如果没有这么多的边，就说明不存在，则返回-1
    if(num < n-1)
        return -1;
    return sum;
}

int main()
{
    int t;
    while(cin>>n>>m)
    {
        init();
        flag_first = true;
        int w1 = Kruskal();
        initset();
        flag_first = false;
        int w2;

        int min = INF;

        //下面是枚举的算法。对每一个在第一最小生成树的边枚举，删除求第二小
        //然后保存里面最小的就是次小的
        //其实这个也可以用来判断最小生成树是否唯一的算法
        for(int i=1;i<=m;i++)
        {
            if(e[i].used == 1)
            {
                e[i].del = 1;
                initset();
                w2 = Kruskal();
                if(min > w2 && w2 != -1)
                {
                    min = w2;
                }
                e[i].del = 0;
            }
        }
        cout<<"Cost: "<<w1<<endl;
        if(min == INF) //如果次小的不存在的话那么就不会给min赋值
        {
            cout<<"Cost: "<<-1<<endl;
        }
        else
            cout<<"Cost: "<<min<<endl;
    }
    return 0;
}