nyoj_118:修路方案（次小生成树）

题目链接

题意，判断次小生成树与最小生成树的权值和是否相等。

豆丁文档—— A-star和第k短路和次小生成树和Yen和MPS寻路算法

法一：

先求一次最小生成树，将这棵树上的边加入一个向量中，再判断去掉前面所求的最小生成树的某条边能否再求得一棵等权值的最小生成树

复杂度O(NElogE)

//稠密图不可用

#include<bits/stdc++.h>
using namespace std; 

 + ;
 + ;
int fa[maxn];
int n, m;
vector<int> TreeEdge;

struct Road            //保存每条路的信息
{
    int u,v,w;
    bool operator<(const Road& t) const      //按长度由小到大排序
    {
        return w<t.w;
    }
} R[maxm];
//初始化并查集
void Init()
{
    ; i <= n; i++)
        fa[i]=i; //每个点自成一个连通分量
}
//找x的祖先
int Find(int x)
{
    return x == fa[x]? x:fa[x]=Find(fa[x]);
}
//判断图的连通性
bool isAccess()
{
    );
    ; i <= n; i++)
        if(f!=Find(i)) return false;
    return true;
}
//kruskal求不要k这条边的最小生成树
int kruskal(int k)
{
    ;
    Init();
    ; i<m; i++)
    {
        if(i!=k)
        {
            int tx=Find(R[i].u);
            int ty=Find(R[i].v);
            if(tx!=ty)
            {
                ans+=R[i].w;
                fa[tx]=ty;
            }
        }
    }
    if(isAccess()) return ans;    //如果是生成树，返回权值
    ;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        TreeEdge.clear();
        scanf("%d%d",&n,&m);
        ; i<m; i++)
            scanf("%d%d%d",&R[i].u,&R[i].v,&R[i].w);
        sort(R, R+m);                //将所有边排序
        Init();
        //===begin===MST
        ;                //求最小生成树
        ; i<m; i++)
        {
            int tx=Find(R[i].u), ty=Find(R[i].v);
            if(tx!=ty)
            {
                ans+=R[i].w;
                fa[tx]=ty;
                TreeEdge.push_back(i);//将这条边加入生成树中
            }
        }
        //===end===MST
        ;
        ;i<TreeEdge.size();i++)
            if(kruskal(TreeEdge[i])==ans)    //看看不用这条边能否再次生成一棵最小生成树
            {
                ok=;
                break;
            }
        if(ok) printf("Yes\n");
        else printf("No\n");
    }
}

法二：

首先求出原图的最小生成树，记录权值之和为Minst.枚举添加每条不在最小生成树上的边<u,v>，加上以后一定会形成一个环，找到环上权值第二大的边（即除<u,v>外最大的边）把它删除掉，计算当前生成树的权值之和。取所有枚举修改的生成树权值之和的最小值，就是次小生成树。具体实现时，更简单的方法是从每个节点i遍历整个最小生成树，定义F[i,j]为从i到j的路径上最大边的权值。遍历图求出F[i,j]的值，然后对于添加每条不在最小生成树中的边<i,j>，新的生成树权值之和就是Minst+w<i,j>-F[j],记录其最小值，则为次小生成树。该算法的时间复杂度为O(n^2+m)。由于只用求一次最小生成树，可以用最简单的Prim算法，时间复杂度为O(n^2)。算法的瓶颈不在于最小生成树，而在于O(n^2+m)的枚举加边修改，所以用更好的最小生成树算法是没有必要的。（详见豆丁文档）

复杂度O(n^2)

标程如下：

#include<bits/stdc++.h>
using namespace std;
#define maxN 510
#define MAX 0x0fffffff
#define MIN -0x0fffffff

int N,M,map[maxN][maxN],dis[maxN],maxlen[maxN][maxN],pre[maxN];
bool vis[maxN];

int prim()
{
    int i,j,k,minn,pr;
    memset(vis,false,sizeof(vis));
    ; i<=N; i++)
        dis[i]=map[][i],pre[i]=;
    vis[]=true;
    ; j<N; j++)
    {
        minn=MAX;
        ; i<=N; i++)
            if(!vis[i]&&dis[i]<minn)
                k=i,minn=dis[i];
        pr=pre[k];
        maxlen[k][pr]=maxlen[pr][k]=map[k][pr];
        ; i<=N; i++)
            if(vis[i])
                maxlen[i][k]=maxlen[k][i]=max(maxlen[i][pr],maxlen[k][pr]);
        vis[k]=true;
        ; i<=N; i++)
            if(!vis[i]&&dis[i]>map[i][k])
            {
                dis[i]=map[i][k];
                pre[i]=k;
            }
    }
    ; i<N; i++)
        ; j<=N; j++)
            if(pre[i]==j||pre[j]==i)continue;
            ;
    ;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        int u,v,w;
        scanf("%d%d",&N,&M);
        ; i<=N; i++)
            ; j<=N; j++)
            {
                map[i][j]=MAX;
                maxlen[i][j]=MIN;
            }
        ; i<M; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            map[u][v]=map[v][u]=w;
        }
        if(prim())printf("Yes\n");
        else printf("No\n");
    }
}