[对偶 KM算法 生成树 || 最大费用可行流 || 线性规划] BZOJ 1937 [Shoi2004]Mst 最小生成树

最新推荐文章于 2021-04-07 22:25:01 发布
最新推荐文章于 2021-04-07 22:25:01 发布
阅读量907 收藏
点赞数
分类专栏： 树 图论 二分图 网络流 线性规划&单纯形 生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014609452/article/details/51822904
版权
图论 同时被 3 个专栏收录
66 篇文章 0 订阅
订阅专栏
网络流
44 篇文章 0 订阅
订阅专栏
树
34 篇文章 0 订阅
订阅专栏

树边减，非树边加，wi表示i号边原来的边权，di表示i号边的改变量

对于一条非树边，覆盖所有树边，都要满足：wi−di≤wj+dj

得wi−wj≤di+dj

这样的话d就是KM算法里的顶标 对偶成最大权匹配

跑最大匹配即可


#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;

inline char nc()
{
    static char buf[100000],*p1=buf,*p2=buf;
    if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
    return *p1++;
}

inline void read(int &x)
{
    char c=nc(),b=1;
    for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
    for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

namespace KMA{
    const int N=805;
    int n,m,w[N][N];
    int mate[N],S[N],T[N],lx[N],ly[N],sla[N];
    bool match(int u)
    {
        S[u]=1;
        for (int v=1;v<=m;v++)
        {
            if (T[v]) continue;
            if (lx[u]+ly[v]==w[u][v])
            {
                T[v]=1;
                if (!mate[v] || match(mate[v]))
                    return mate[v]=u,1;
            }else
                sla[v]=min(sla[v],lx[u]+ly[v]-w[u][v]);
        }
        return 0;
    }
    int KM()
    {
        if (n>m)
        {
            for (int i=1;i<=n;i++)
                for (int j=1;j<=i && j<=m;j++)
                    swap(w[i][j],w[j][i]);
            swap(n,m);
        }
        cl(mate); cl(ly);
        for (int i=1;i<=n;i++)
        {
            lx[i]=-1<<30;
            for (int j=1;j<=m;j++) lx[i]=max(lx[i],w[i][j]);
        }
        for (int i=1;i<=n;i++)
        {
            for (int j=1;j<=m;j++) sla[j]=1<<30;
            for (;;)
            {
                cl(S); cl(T);
                if (match(i)) break;
                int a=1<<30;
                for (int j=1;j<=m;j++) if (!T[j]) a=min(a,sla[j]);
                for (int j=1;j<=n;j++) if (S[j]) lx[j]-=a;
                for (int j=1;j<=m;j++) if (T[j]) ly[j]+=a; else sla[j]-=a;
            }
        }
        int ret=0;
        for (int i=1;i<=m;i++)
            ret+=w[mate[i]][i];
        return ret;
    }
}

const int N=55,K=10,M=805;

struct edge{
    int u,v,w,next;
}G[N<<1];
int head[N],inum;
inline void add(int u,int v,int w,int p){
    G[p].u=u; G[p].v=v; G[p].w=w; G[p].next=head[u]; head[u]=p;
}

int n,m;
int ln,rn;
int fat[N][K],depth[N],idx[N],wgt[N];

#define V G[p].v
inline void dfs(int u,int fa)
{
    fat[u][0]=fa; depth[u]=depth[fa]+1;
    for (int k=1;k<K;k++) fat[u][k]=fat[fat[u][k-1]][k-1];
    for (int p=head[u];p;p=G[p].next)
        if (V!=fa)
            idx[V]=++rn,wgt[V]=G[p].w,dfs(V,u);
}

inline int LCA(int u,int v){
    if (depth[u]<depth[v]) swap(u,v);
    for (int k=K-1;~k;k--)
        if ((depth[u]-depth[v])&(1<<k))
            u=fat[u][k];
    if (u==v) return u;
    for (int k=K-1;~k;k--)
        if (fat[u][k]!=fat[v][k])
            u=fat[u][k],v=fat[v][k];
    return fat[v][0];
}

struct edges{
    int u,v,w,f;
}E[M];

inline void build(int u,int lca,int id,int w)
{
    if (u==lca) return;
    KMA::w[id][idx[u]]=max(0,wgt[u]-w);
    build(fat[u][0],lca,id,w);
}

int main()
{
    int iu,iv,iw,lca;
    freopen("t.in","r",stdin);
    freopen("t.out","w",stdout);
    read(n); read(m);
    for (int i=1;i<=m;i++)
        read(E[i].u),read(E[i].v),read(E[i].w);
    for (int i=1;i<n;i++)
    {
        read(iu); read(iv);
        for (int j=1;j<=m;j++)
            if ((E[j].u==iu && E[j].v==iv) || (E[j].u==iv && E[j].v==iu))
                E[j].f=1,iw=E[j].w;
        add(iu,iv,iw,++inum); add(iv,iu,iw,++inum);
    }
    dfs(1,0);
    for (int i=1;i<=m;i++)
        if (!E[i].f)
        {
            iu=E[i].u; iv=E[i].v;
            lca=LCA(iu,iv);
            build(iu,lca,++ln,E[i].w);
            build(iv,lca,ln,E[i].w);
        }
    KMA::n=ln; KMA::m=rn;
    printf("%d\n",KMA::KM());
    return 0;
}

费用流的做法：http://blog.csdn.net/u014609452/article/details/52598726


#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  if (p1==p2){ p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
  return *p1++;
}

inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const int N=1005;

struct edge{
  int u,v,next; int idx;
}G[N<<1];
int head[N],inum;

inline void add(int u,int v,int idx,int p){
  G[p].u=u; G[p].v=v; G[p].idx=idx; G[p].next=head[u]; head[u]=p;
}

int n,m;
const int K=21;

int fat[N][K],depth[N],fad[N];
#define V G[p].v
inline void dfs(int u,int fa){
  fat[u][0]=fa; depth[u]=depth[fa]+1;  
  for (int k=1;k<K;k++) fat[u][k]=fat[fat[u][k-1]][k-1];  
  for (int p=head[u];p;p=G[p].next)
    if (V!=fa)
      dfs(V,u),fad[V]=G[p].idx;
}

inline int LCA(int u,int v){  
  if (depth[u]<depth[v]) swap(u,v);  
  for (int k=K-1;~k;k--)  
    if ((depth[u]-depth[v])&(1<<k))  
      u=fat[u][k];  
  if (u==v) return u;  
  for (int k=K-1;~k;k--)  
    if (fat[u][k]!=fat[v][k])  
      u=fat[u][k],v=fat[v][k];  
  return fat[v][0];  
}  

namespace MCMF{
  const int N=1005;  
  struct edge{  
    int u,v,w,f,next;  
  }G[1000005];  
  int head[N],inum=1;  
  inline void add(int u,int v,int w,int f,int p){  
    G[p].u=u; G[p].v=v; G[p].w=w; G[p].f=f; G[p].next=head[u]; head[u]=p;  
  }  
  inline void link(int u,int v,int w,int f){  
    add(u,v,w,f,++inum); add(v,u,-w,0,++inum);  
  } 
  int S,T;  
  int dis[N],ins[N],pre[N];  
  const int NQ=1000005;
#define ad(x) ((x)+1==NQ?(x)=0:++(x)) 
  int Q[NQ],l,r;  
  int Maxcost;
  inline bool SPFA(){  
    for (int i=1;i<=T;i++) dis[i]=-1<<30,ins[i]=0,pre[i]=0;  
    l=-1,r=-1;  
    Q[ad(r)]=S; dis[S]=0; ins[S]=1;  
    while (l!=r){  
      int u=Q[ad(l)]; ins[u]=0;  
      for (int p=head[u];p;p=G[p].next)  
	if (G[p].f && dis[V]<dis[u]+G[p].w){  
	  dis[V]=dis[u]+G[p].w; pre[V]=p;  
	  if (!ins[V]) Q[ad(r)]=V,ins[V]=1;  
	}  
    }  
    if (dis[T]<=0) return false;  
    int minimum=1<<30;  
    for (int p=pre[T];p;p=pre[G[p].u])  
      minimum=min(minimum,G[p].f);  
    for (int p=pre[T];p;p=pre[G[p].u]){  
      G[p].f-=minimum; G[p^1].f+=minimum;  
      Maxcost+=minimum*G[p].w;  
    }  
    return true;  
  }
  inline void Solve(){
    while (SPFA());
  }
}

int cnt;
int sx[N],sy[N],sw[N],sg[N],val[N];

int main(){
  int ia,ib,iu,iv;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  MCMF::S=m+1; MCMF::T=m+2;
  for (int i=1;i<=m;i++){
    read(sx[i]); read(sy[i]); read(sw[i]);
    val[i]=1;
  }
  for (int i=1;i<n;i++){
    read(iu),read(iv);
    for (int j=1;j<=m;j++)
      if ((iu==sx[j]&&iv==sy[j]) || (iu==sy[j]&&iv==sx[j]))
	sg[j]=1;
  }
  for (int i=1;i<=m;i++){
    if (sg[i])
      MCMF::link(MCMF::S,i,0,val[i]);
    else
      MCMF::link(i,MCMF::T,0,val[i]);
    if (sg[i]){
      add(sx[i],sy[i],i,++inum);
      add(sy[i],sx[i],i,++inum);
    }
  }
  dfs(1,0);
  for (int i=1;i<=m;i++)
    if (!sg[i]){
      int u=sx[i],v=sy[i],lca=LCA(u,v);
      while (u!=lca){
	if (sw[fad[u]]>sw[i])
	  MCMF::link(fad[u],i,sw[fad[u]]-sw[i],1<<30);
	u=fat[u][0];
      }
      while (v!=lca){
	if (sw[fad[v]]>sw[i])
	  MCMF::link(fad[v],i,sw[fad[v]]-sw[i],1<<30);
	v=fat[v][0];
      }
    }
  MCMF::Solve();
  printf("%d\n",MCMF::Maxcost);
  return 0;
}



还有线性规划的做法


里阿奴摩西
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wangjunrui666#bzoj-problem##4882. [Lydsy1705月赛]卡常生成树1
07-25
为了避免输入数据过于庞大，数据进行了压缩，解压方式可用下面这段代码解释：//在点i与点j之间添加一条边权为w的边第一行包含一个正整数T(1)，表示
【SHOI2004】最小生成树（线性规划）（KM求最小顶标和）
zxyoi_dreamer的博客（不定期诈尸）
09-16 1253
传送门 题解： 首先由贪心策略，我们知道对于一条树边，我们不可能加它的权值，对于一条非树边，我们不可能减少它的权值。 而一条非树边对应树上一条路径，显然如果我们要求这棵树是某一棵最小生成树，则修改后这条非树边的权值必须大于等于这条路径上任何一条边的权值。 设TTT表示树边集合，EEE表示非树边集合，∀e∈E\forall e\in E∀e∈E，PeP_ePe​表示eee的两个端点的树上路径的边的...
最小生成树 Kruskal
WWIandMC的博客
09-01 349
Kruskal算法比起Prim算法还要更贪心一些 Prim算法以某个顶点为起点，在这个顶点附近找权重最小的边；而Kruskal算法只要当前图中权重最小的边 Kruskal算法 Kruskal算法的思路是：把森林合并成树 最开始时，我们把所有的顶点看做是一棵树的根节点，总共有n棵树 edge begin end weight 0 0 1 10 1 0 5 11 2 1 2 18 3 1 6 16 4 1 8 12 5 2 3 22 6 2 8 8 7
证明k-生成树问题是NP完全问题
Alliyou的博客
11-28 1834
k-生成树是指给定一个无向图，找到一个生成树，其中每个节点的度数不超过k。 首先要验证所找的生成树是否符合要求，只需要遍历每个点，检查其度数即可，时间复杂度为V+E，为多项式时间复杂度，因此k-生成树问题为NP问题。 这个问题可以由Rudrata环路问题归约。当k=2时，所要寻找的生成树其实就是一条经过所有顶点的路径，只不过相比Rudrata路径而言，这个生成树是没有回路的。那么Rudrata
[SHOI2004]最小生成树，洛谷P4412，线性规划
Deep_Kevin的娱乐空间
12-04 641
正题       题目链接       首先，我们需要构造一种贪心的思路：       1.我们不可能给一条生成树边增加一个数。这样只会使的生成树的权值变大，而且对于不选树边的生成树，相对来说变得可能更小。      2.我们也不可能给一条非生成树边减去一个数，因为这样会使得不选树边的生成树权值变小，从而变得没有那么优秀。      那么很好理解上面的两条贪心“法则”之后，我们要构造几组...
线性规划 KM算法
RA100FDM的博客
04-07 282
有这样一个线性规划问题，求答案以及方案 Minimize Satisfy{∑u∈Lyu+∑v∈Ryvyu+yv≥wu,v((u,v)∈E)yu≥0yv≥0 Minimize\ Satisfy\\ \begin{cases} \sum_{u\in L}y_u+\sum_{v\in R}y_v \\ y_u+y_v\ge w_{u,v}((u,v)\in E)\\ y_u\ge 0 \\ y_v\ge 0 \end{cases} Minimize Satisfy⎩⎪⎪⎪⎨⎪⎪⎪⎧​∑u∈L​
wangjunrui666#bzoj-problem##5165. 树上倍增1
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
周东《浅析最大最小定理在信息学竞赛中的应用》
05-30
周东大神关于s-t平面图与对偶图的转化PPT 可以快速求解s-t平面图中的最大流问题 解释很详细，很有帮助
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
考虑点分树的做法，在点分树上每个点以距离为下标建一棵线段树，每次询问查询子树的贡献，再暴力向上跳合并父节点来自其它节点的贡献。 因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的...
Link-Cut-Tree 动态树经典讲稿附例题
10-11
适用ACM和OI等算法选手，Link-Cut-Tree 动态树经典讲稿，附BZOJ多道优秀练习题，原作者吉大附中实验学校 PoPoQQQ
最小生成树kruskal算法，最短路dijkstra算法 ，动态规划
04-17
% 离散优化 % *enum - 枚举法 % *monte - 蒙特卡洛法 % *lpint (BranchBound)- 线性整数规划 % *L01p_e - 0-1整数规划枚举法 % *L01p_ie - 0-1整数规划隐枚举法 % *bnb18 - 非线性整数规划(在MATLAB5.3使用) % *bnbgui - 非线性整数规划图形工具(在MATLAB5.3使用) % *mintreek - 最小生成树kruskal算法 % *minroute - 最短路dijkstra算法 % *krusk - 最小生成树kruskal算法mex程序 % *dijkstra - 最短路dijkstra算法mex程序 % *dynprog - 动态规划
bzoj 1937: [Shoi2004]Mst 最小生成树 费用流
lych的博客
04-12 991
首先可以对于一条非树边(x,y,len1)，对应的树上x~y的链中的某一条边(u,v,len2)，如果有len1=len2-len1。        显然一条非树边对应一个a，一条树边对应一个b，然后a+b>=len2-len1相当于最大权匹配中的顶标号。那么建一个二分图跑最大匹配即最大费用流（不需要满流）。 AC代码如下： #include #include #include #defin
Bzoj1937:[Shoi2004]Mst 最小生成树:KM算法
蜜の夜明け
03-25 983
题目链接:1937:[Shoi2004]Mst 最小生成树 首先由贪心思想可知，对于一条T上的边，我们要么不动，要么减少他的权值；对于一条不在T上的边，我们要么不动，要么增加他的权值 设di表示权值的改变量，对于一条T边i和一条非T边j，必须满足wi-di 式子移一下项，发现wi-wj #include #include #include #include #include using n
[BZOJ 1937][Shoi2004]Mst 最小生成树
_Horizon
02-17 970
KM，最小生成树
bzoj 2539: [Ctsc2000]丘比特的烦恼 （KM算法）
clover_hxy的博客
04-22 753
题目描述传送门题解KM的裸题吧，就是细节比较恶心。。。。代码#include<iostream> #include<algorithm> #include<cstring> #include<cstdio> #include<cmath> #include<map> #define N 103 #define inf 1000000000 using namespace std; double di
【KM算法】【最大乘积生成树】[HNOI2014] bzoj3571 画框
每天心塞一点点
03-12 1924
这道题考试的时候我直接写了个KM拿30分就滚去写下一题了orz。。 看了题解感觉想出来的人脑洞真的…………比较大……………… 把每一种匹配 (sigma(A), sigma(B))看做平面上的一个点 因为要求乘积最小 可以证明这个点肯定在下凸壳上 于是把下凸壳上的每个点逐一验证就可以了 构造下凸壳用的分治_(:з)∠)_  首先纵坐标最大的和横坐标最小的肯定在下凸壳上 然后找到
bzoj 1937: [Shoi2004]Mst 最小生成树
limboman的博客
06-21 611
将原问题对偶成为费用流模型； 写的原始对偶的费用流，然后发现每次增广容量最多为1…mdzz#include<bits/stdc++.h> #define rep(i,k,n) for(int i=k;i<=(n);i++) #define rep2(i,k,n) for(int i=k;i>=(n);i--) #define mp make_pair using namespace std; c
bzoj1937[Shoi2004]Mst 最小生成树
03-06 109
题目链接：bzoj1937 题目大意： 题解： KM/费用流 看不懂题解的我%了发男神 首先显然的，对于T上的边只进行减小操作，非T上的边只进行增加操作。（当然也可以不改变） 因为已经要求了一棵最小生成树T，即让非T上的边都不选。那么它不选的理由是什么呢？ 假设这条非T的边编号为j，连接x->y，如果它不选的话，那么它的边权w[j]一定大于所以...
||a-b||1是什么距离
最新发布
08-22
引用中给出了求两个点坐标之差的绝对值的最大值的公式，可以用于计算两个向量的曼哈顿距离。其中，||a-b||1表示向量a和向量b的曼哈顿距离，也称为L1距离。曼哈顿距离是指两点之间在一个规定的网格上的距离，计算方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值