次小生成树HDU--4081

刚接触的次小生成树，就是最小生成树通过一次变换得到。

o（N^3）的做法：

　　求得最小生成树，标记其中的边，枚举删除每条边，再求最小生成树，并在这些权值中取得最小值，得到次小生成树。

o（N^2）的做法：

　　先求得最小生成树，并在此中标记每条边是否用过。

　　mmax[I][J]，数组来记录I到J最小生成树路径上权值的一条最大值。

　　接着枚举不在最小生成树的边(I,J);

　　SecMst=Mst-edge[I][J]+mmax[I][J],取最小值，为次小生成树的值

     Hdu 4081

　　

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0xfffffff
double edge[1001][1001];
double mmax[1001][1001];
double lowcost[1001];
int nearvex[1001];
int used[1001][1001];
bool vis[1001];
int t,n;
struct Node
{
    int u,v,w;
}fpoint[1001];

double cal(Node a,Node b)
{
    return sqrt(1.0*((a.u-b.u)*(a.u-b.u)+(a.v-b.v)*(a.v-b.v)));
}

double prim(int u0)
{
    memset(vis,0,sizeof(vis));
    memset(nearvex,0xff,sizeof(nearvex));
    int i,j;
    for(i=1;i<=n;i++)
    {
        lowcost[i]=INF;
    }
    lowcost[u0]=0;
    double sumweight=0;
    for(i=1;i<=n;i++)
    {
        int mmin=INF;
        int v=-1;
        for(j=1;j<=n;j++)
        {
            if(vis[j]!=1&&lowcost[j]<mmin)
            {
                v=j;
                mmin=lowcost[j];
            }
        }
        for(j=1;j<=n;j++)
        {
            if(vis[j]&&j!=v) 
            {
                mmax[j][v]=mmax[v][j]=(mmax[j][nearvex[v]]>edge[nearvex[v]][v]?mmax[j][nearvex[v]]:edge[nearvex[v]][v]);
            }
        }
        if(nearvex[v]!=-1)                                //表示该段已用
        {
            used[nearvex[v]][v]=used[v][nearvex[v]]=2;
        }
        vis[v]=1;                                         //表示该点已经记录
        sumweight+=lowcost[v];
        for(j=1;j<=n;j++)
        {
             if(edge[v][j]!=0&&!vis[j]&&edge[v][j]<lowcost[j])    //更新lowcost数组，找到下一条合适的边
            {
                nearvex[j]=v;
                lowcost[j]=edge[v][j];
            }
        }
    }
    return sumweight;
}

int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int i,j;
        for(i=1;i<=n;i++)
        {
            int x,y,w;
            scanf("%d%d%d",&x,&y,&w);
            fpoint[i].u=x,fpoint[i].v=y,fpoint[i].w=w;
        }
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                edge[i][j]=0;
            }
        }
        for(i=1;i<=n;i++)
        {
            for(j=i+1;j<=n;j++)
            {
                used[i][j]=used[j][i]=1;
                edge[i][j]=edge[j][i]=cal(fpoint[i],fpoint[j]);
            }
        }
        int u0=1;
        double ans=prim(u0);
        double r=-1;
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(used[i][j]==2)
                {
                    r=r>(fpoint[i].w+fpoint[j].w)/(ans-edge[i][j])?r:(fpoint[i].w+fpoint[j].w)/(ans-edge[i][j]);
                }
                else
                    if(used[i][j]==1)
                {
                    r=r>(fpoint[i].w+fpoint[j].w)/(ans-mmax[i][j])?r:(fpoint[i].w+fpoint[j].w)/(ans-mmax[i][j]);
                }
            }
        }
        printf("%0.2lf
",r);
    }
    return 0;
}