次小生成树

最新推荐文章于 2022-02-19 22:33:39 发布
最新推荐文章于 2022-02-19 22:33:39 发布
阅读量116 收藏
点赞数
文章标签： php
原文链接：http://www.cnblogs.com/Dxy0310/p/9769757.html
版权

次小生成树的定义：

　   次小生成树根据名字就知道是比最小生成树的权值和还要大的生成树，而且是大于最小生成树的权值和的权值最小的那个生成树。

 

次小生成树的求法：

　1.暴力拆边法

　　由最小生成树可得最小生成树中的边的权值和最小，那么我们可以每次考虑枚举删除其中的边，并用其他的权值尽量小的非树边顶上，对新的生成树的权值和取个min就行了，时间复杂度：O(nmlogm)。

　　#10068. 「一本通 3.1 练习 3」秘密的牛奶运输：https://loj.ac/problem/10068

 

#include<bits/stdc++.h>
using namespace std;
#define re register int
#define ll long long
#define INF 0x3f3f3f3f
#define maxn  509    
#define maxm 10009
inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ll)(ch-'0');ch=getchar();}
    return x*f;
}
struct edge
{
    int x,y;
    ll val;
}p[maxm]; 
int n,m,k,tot,cnt;
int fa[maxn],vis[maxn];
ll ans,mx,sum;
bool comp(edge a,edge b)
{
    return a.val<b.val;
}

int find(int x)
{
    return fa[x]==x?fa[x]:fa[x]=find(fa[x]);
}
int main()
{
//    freopen(".in","r",stdin);
//    freopen(".out","w",stdout);
    n=read(),m=read();
    for(int i=1;i<=n;i++)
        fa[i]=i;
    for(int i=1;i<=m;i++)
        p[i].x=read(),p[i].y=read(),p[i].val=read();
    sort(p+1,p+1+m,comp);
    for(int i=1;i<=m;i++)
    {
        int a=find(p[i].x),b=find(p[i].y);
        if(a!=b)
        {
            fa[b]=a;
            ans+=p[i].val;
            vis[++cnt]=i;
            if(cnt==n-1)
                break;
        }
    }
    mx=1e18;
    for(int i=1;i<=cnt;i++)
    {    
        sum=0,tot=0;
        for(int j=1;j<=n;j++)
            fa[j]=j;
        for(int j=1;j<=m;j++)
        {
            if(vis[i]==j)
                continue;
            int a=find(p[j].x),b=find(p[j].y);
            if(a!=b)
            {
                sum+=p[j].val;
                fa[b]=a;
                tot++;
                if(tot==n-1)
                    break;
            }
        }
        if(sum>ans)
        mx=min(mx,sum);
    }
    if(mx==1e18)
        mx=10;
    printf("%lld\n",mx);
    fclose(stdin);
    fclose(stdout);
    return 0;
}

 

 　　2.倍增

　　考虑在最小生成树中加一条非树边(u,v)，那么整棵树将会形成一个环，去掉环上的任意一条边后仍然为一颗生成树，因为我们所需要求的是次小生成树，所以可以贪心地将环上树边中权值最大的边删除并加上边(u,v)。

　　实现：①先用Kruskal求出最小生成树并标记树边和最小生成树的权值和。

　　　　　②用dfs求出f数组和每个节点的深度。

　　　　　③用倍增的方法求出最小生成树中任意两点间路径的最大和次大值。

　　　　  ④枚举每一条非树边(u,v)，利用LCA求出环上的树边的最大值，将其权值减去并加上树边(u,v)的权值，更新答案。

　　求次大值是因为所求为严格的次小生成树，其权值和要大于最小生成树的权值和，当所枚举的非树边的边权和环上树边的最大值相同时便取次大值。

　　因为取最大值后所形成的心得生成树的权值和与原来的最小生成树的权值和必然相等，并不满足题目要求。

 　　BZOJ 1977 次小生成树 Tree：https://www.lydsy.com/JudgeOnline/problem.php?id=1977

　　

#include<bits/stdc++.h>
using namespace std;
#define re register int
#define ll long long
#define INF 0x3f3f3f3f 
#define maxn 100009
#define maxm 300009
inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ll)(ch-'0');ch=getchar();}
    return x*f;
}
struct EDGE
{
    int x,y;
    ll val;
}pp[maxm];
struct edge
{
    int to,nxt;
    ll val;
}p[maxn<<1];
bool used[maxm];
int head[maxn],depth[maxn],f[maxn][29],fa[maxn];
ll mx[maxn][29],cmx[maxn][29];
int n,m,k,tot,cnt;
ll ans,sum;
//f[i][j]表示节点i往父节点方向走2^j步后的节点编号 
//mx[i][j]      ...                  间的路径上边的最大值 
//cmx[i][j]     ...                                次大值     
void add(int x,int y,ll z)
{
    ++cnt,p[cnt].to=y,p[cnt].nxt=head[x],head[x]=cnt,p[cnt].val=z;
}

bool comp(EDGE a,EDGE b)
{
    return a.val<b.val;
}

int find(int x)
{
    return fa[x]==x?fa[x]:fa[x]=find(fa[x]);
}

void Kruskal()//求最小生成树 
{
    sort(pp+1,pp+1+m,comp);
    for(int i=1;i<=m;i++)
    {
        int a=find(pp[i].x),b=find(pp[i].y);
        if(b!=a)
        {
            fa[b]=a;
            used[i]=1;//used[i]=1表示编号为i的这条边是树边 
            ans+=pp[i].val;
            tot++;    
            add(pp[i].x,pp[i].y,pp[i].val);//建最小生成树 
            add(pp[i].y,pp[i].x,pp[i].val);
            if(tot==n-1)
                break;
        }
    }
}

void dfs(int u,int father)//求f数组和depth数组 每个点的深度 
{
    depth[u]=depth[father]+1;
    f[u][0]=father;
    for(int i=1;(1<<i)<=depth[u];i++)
        f[u][i]=f[f[u][i-1]][i-1];
    for(int i=head[u];i;i=p[i].nxt)
    {
        int v=p[i].to;
        if(v==father)
            continue;
        mx[v][0]=p[i].val;
        dfs(v,u);
    }
}

void Cal()//倍增求出mx[]和cmx[] 
{
    for(int j=1;j<=20;j++)
        for(int i=1;i<=n;i++)
        {
            mx[i][j]=max(mx[i][j-1],mx[f[i][j-1]][j-1]);//i往上跳2^j步路径上的最大值为 i往上跳2^(j-1)路径上的最大值 
            //和以i往上跳2^(j-1)步所到达的节点为起点跳2^(j-1)步路径上的最大值 
            cmx[i][j]=max(cmx[i][j-1],cmx[f[i][j-1]][j-1]);//次大值同最大值 
            if(cmx[i][j]<mx[i][j-1]&&mx[i][j-1]<mx[f[i][j-1]][j-1])//将最大值中较小的值和次大值进行比较更新 
                cmx[i][j]=mx[i][j-1];
            else if(cmx[i][j]<mx[f[i][j-1]][j-1]&&mx[f[i][j-1]][j-1]<mx[i][j-1])
                cmx[i][j]=mx[f[i][j-1]][j-1];
        }
}

int Lca(int x,int y)
{
    if(depth[x]>depth[y])
        swap(x,y);
    for(int i=20;i>=0;i--)
        if(depth[x]<=depth[y]-(1<<i))
            y=f[y][i];
    if(x==y)
        return x;
    for(int i=20;i>=0;i--)
        if(f[x][i]!=f[y][i])
            x=f[x][i],y=f[y][i];
    return f[x][0];
}

ll Query_mx(int x,int y,int lca,ll val)//倍增找(u,v)路径上的最大值，分为u->lca 和 v->lca  
{
    ll lmx=0,rmx=0;
    for(int i=20;i>=0;i--)
        if(depth[lca]<=depth[x]-(1<<i))
        {
            if(mx[x][i]!=val)
                lmx=max(lmx,mx[x][i]);
            else
                lmx=max(lmx,cmx[x][i]);
            x=f[x][i];
        }
    for(int i=20;i>=0;i--)
        if(depth[lca]<=depth[y]-(1<<i))
        {
            if(mx[y][i]!=val)
                rmx=max(rmx,mx[y][i]);
            else
                rmx=max(rmx,cmx[y][i]);
            y=f[y][i];
        }
    return max(lmx,rmx);
}

void Get_ans()//枚举非树边 
{
    sum=2e18;
    for(int i=1;i<=m;i++)
        if(!used[i])
        {
            int x=pp[i].x,y=pp[i].y;
            ll z=pp[i].val;
            int father=Lca(x,y);
            ll temp=Query_mx(x,y,father,z);
            if(temp!=z&&ans-temp+z<sum)
                sum=ans-temp+z; 
        }
    printf("%lld\n",sum);
}

int main()
{
//    freopen(".in","r",stdin);
//    freopen(".out","w",stdout);
    n=read(),m=read();
    for(int i=1;i<=n;i++)
        fa[i]=i;
    for(int i=1;i<=m;i++)
        pp[i].x=read(),pp[i].y=read(),pp[i].val=read();
    Kruskal();
    dfs(1,0);
    Cal();
    Get_ans();
    fclose(stdin);
    fclose(stdout);
    return 0;
}

 

转载于:https://www.cnblogs.com/Dxy0310/p/9769757.html

asd420406
关注
次小生成树 【总结】
世界很大
08-10 1366
MST - 最小生成树 引子：给你N个点以及M条边，问你MST是否唯一，若不唯一输出-1，否则输出MST的值。 通过 枚举 + 删边 + 再求MST 完全可以做到求解上述题目，但时间复杂度过高。这里介绍一种(N*2)的算法，是结合prime算法实现的。 算法核心思想：在prime求MST的过程中 用数组存储MST里面任意两点间的最大权值。最后枚举不在MST里面的边，判
C++ 图论之次最小生成树
最新发布
y6123236的专栏
11-29 1081
生成树指在无向图中找一棵包含图中的所有节点的树，此树是含有图中所有顶点的无环连通子图。对所有生成树边上的权重求和，权重和最小的树为最小生成树，次小的为次最小生成树。最小生成树和次最小生成树的应用领域都较广泛。也是图论中优为重要的研究对象，求解算法也是常规必须掌握的算法之一。最小生成树的算法主要是kruskal（克鲁斯卡尔）和Prim算法，求解次最小生成树时也是基于这两种算法，在此之上略做些变化。
求次小生成树
diaomeijiao3430的博客
11-10 139
题目链接：https://cn.vjudge.net/contest/67265#problem/C 具体思路：和判断最小生成树是否唯一的思路差不多，首先跑一遍最小生成树，在求最小生成树的过程中记录任意两个点之间的最大权值，然后试着暴力，如果有一条边没有在最小生成树上，那么就先加上这条边的权值，再去减去两个端点之间的最大权值，求一个最小值，这就是次小生...
次小生成树模板
aiweiluan5095的博客
09-18 140
次小生成树模板 【例题】 传送门 【做法】 先用最小生成树做出这棵树，然后DFS建树，插入一条非树边，肯定在树上形成了环，所以在环上找一个最大的删去，加入这条边。最后从所有情中选一个最小的就是答案。(首先得知道这个次小指的是什么次小，是值次小还是值从小到大排序后排名第二的，也就是涉及到次小是否能等于最小的问题) 贴上代码(Kruskal) ...
详解次小生成树以及相关的C++求解方法
09-03
次小生成树是图论中的一个重要概念，它在图G中是指权值次于最小生成树的另一种生成树。在给定的连通无向图G=(V,E,w)中，最小生成树T是一个权值之和最小的树，而次小生成树T1则是权值之和仅次于最小生成树的树，且...
求次小生成树（用prim）
weixin_42165786的博客
06-02 280
#include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;algorithm&gt; using namespace std; const int maxn = 111; const int inf = 0x3f3f3f3f; int Map[maxn][maxn];//邻接矩阵存图 int Max[maxn][maxn];//表...
次小生成树问题——秘密的牛奶运输
AKAPinkman的博客
02-19 638
题目描述 算法 本题是一个裸的严格次小生成树问题。所谓严格就是该次小生成树的总边权严格大于最小生成树（以下用MGT称呼）。非严格的就是边权和MGT相同 算法1： 自然的想先求MGT，再每次删去MGT中的一条边，在该图上做MGT求解（新图的MGT就是原图的次小生成树）。做一遍kruskal后面就不用再排序了，删边次数n - 1，每次求MGT是m，故 O(mlogm+nm)O(mlogm + nm)O(mlogm+nm)。 这种方法求不出 严格次小生成树，因为如果有非严格次小生成树，删边之后再找肯定会找到非
次小生成树算法
码农的一亩三分地
07-28 5358
定义: 　　设G = (V, E)是连通的无向图,T是图G的一个最小生成树.如果有另外一棵树T1,T1 ≠ T,满足不存在树T',T' ≠ T,w(T') &lt; w(T1),则称T1是图G的次小生成树. 算法: 1:基本算法 　　最简单也最容易想到的是,设T是G的最小生成树,依次枚举T的边并去掉,再求最小生成树,所得到的这些值的最小值就是次小生成树,由于最小生成树有N-1条边,这种方法...
vijos1070_关于次小生成树的求法
sluqy671的专栏
12-04 2939
（某日， xzz出现了卖萌的一幕） jzz:   DG， 你会求最小生成树吗？ DG：   会呀！ jzz:   那次小生成树呢？ DG:    这个嘛...... -_-||不会————枚举然后暴力吗？ jzz:   戚， O(nmlogm) 早炸飞了。 DG:    到底怎么做嘛？ jzz:   问问DL， 说不定他心情好会告诉你的。 DL：   那么问题来了， 如何用O(n²
1148 秘密的牛奶运输（次小生成树、dfs维护树中两个节点的最大距离）
二哈
11-03 259
1. 问题描述： 农夫约翰要把他的牛奶运输到各个销售点。运输过程中，可以先把牛奶运输到一些销售点，再由这些销售点分别运输到其他销售点。运输的总距离越小，运输的成本也就越低。低成本的运输是农夫约翰所希望的。不过，他并不想让他的竞争对手知道他具体的运输方案，所以他希望采用费用第二小的运输方案而不是最小的。现在请你帮忙找到该运输方案。注意：： 如果两个方案至少有一条边不同，则我们认为是不同方案； 费用第二小的方案在数值上一定要严格大于费用最小的方案； 答案保证一定有解； 输入格式 第一行是两个整数 N,
扩展Tarjan求解树上两点路径上的最长边（高效求解次小生成树）
新博客地址:sensirly.github.io
08-03 2191
SPOJ 3978 Distance Query 题意：给出一棵有边权的树（100000个点），有100000次讯问两点间路径上的最长边和最短边。 扩展Tarjan算法可以离线解决LCA问题（http://blog.csdn.net/kksleric/article/details/7442258）因此也可用于维护两点间路径上的性质。 设mx[i]为i点到当前集合根节点（tarjan过程中并
最小生成树与次小生成树：算法解析与实例
如果这个理论中的生成树T1不是次小生成树，那么存在另一棵树T'，其权重小于T1但不小于最小生成树T的权重，这与定义矛盾，因此T1是次小生成树。 在实际应用中，理解并掌握最小生成树的概念和算法是非常重要的，它们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值