BZOJ1834: [ZJOI2010]network 网络扩容

最新推荐文章于 2019-05-28 13:52:00 发布
最新推荐文章于 2019-05-28 13:52:00 发布
阅读量354 收藏
点赞数
分类专栏： 网络流 费用流 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ep1C_HeReT1c/article/details/53788816
版权
网络流 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
网络流
37 篇文章 0 订阅
订阅专栏
费用流
18 篇文章 0 订阅
订阅专栏

题目链接

【分析】

刚看到这道题。想了想。哇，我好像会做~
第一问直接最大流。第二问，在残量网络中重新建图：
对于剩余流量不足K的边（x,y），建新边，流量为K-W[i]，费用为C[i]。对于剩余流量不为0的边，建新边，流量为W[i]，费用为0。
然后费用流就可以了。

为什么这样建呢？
自己YY的是：每条边再流过的流量最多为K，则对于每条边，可流的流量不需要费用，不足的流量就补齐，有费用。
然而理想很美好，现实很骨感。开开心心的交了，WA！！？？
很不服气。。找数据测，90！！？第一组就错了。

然后看看dalao们的题解，又想了半天，才知道自己错在哪里。

正确的做法是：

从第一问的残留网络上继续建图，对残留网络上的每一条边建一条容量是∞费用是w的边（反向弧容量为0，费用为-w），然后建一个超级源点，从超级源向1建一条容量为k，费用为0的边，对这个图进行最小费用最大流算法。

那么之前的做法错在哪里呢？
因为最大流的流法可以有多种方案，而计算的时候，只算了总流量，但只是一种方案。而原先的做法是默认了第二问中仍用第一问中求出来的方案来完成，显然错误。（吐槽：数据是真的水。。）

【代码】

  1. 第一种思路的代码（90）
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#define N 1005
#define M 20005
#define INF 1000000000
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pa;

int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int n,m,K,cnt=1,S,T,ans,Cnt=1;
int b[M],p[N],nextedge[M],w[M],c[M];
int B[10005],P[N],Next[10005],W[10005],C[5010],cur[N];
int Dis[N],Pre[N],Level[N];
bool Flag[N];

void Add(int x,int y,int z,int cost)
{
    cnt++;
    b[cnt]=y;
    nextedge[cnt]=p[x];
    p[x]=cnt;
    w[cnt]=z;
    c[cnt]=cost;
}

void Anode(int x,int y,int z,int cost){
    Add(x,y,z,cost);Add(y,x,0,-cost);
} 

void Ins(int x,int y,int z)
{
    Cnt++;
    B[Cnt]=y;
    Next[Cnt]=P[x];
    P[x]=Cnt;
    W[Cnt]=z;
}

void Insert(int x,int y,int z){
    Ins(x,y,z);Ins(y,x,0);
}

bool Bfs()
{
    queue<int>q;
    for(int i=1;i<=n;i++) Level[i]=0;
    Level[1]=1;
    q.push(1);
    while(!q.empty())
    {
        int k=q.front();q.pop();
        for(int i=P[k];i;i=Next[i])
        {
            int v=B[i];
            if(!Level[v]&&W[i])
            {
                Level[v]=Level[k]+1;
                q.push(v);
            }
        }
    }
    return Level[n];
}

int Dfs(int x,int maxf)
{
    if(x==n||!maxf) return maxf;
    int rtn=0;
    for(int i=cur[x];i&&maxf>rtn;i=Next[i])
    {
        int v=B[i],f=W[i];
        if(Level[v]==Level[x]+1&&f)
        {
            f=Dfs(v,min(maxf-rtn,f));
            W[i]-=f;W[i^1]+=f;
            if(W[i]>0) cur[x]=i;
            rtn+=f;
        }
    }
    return rtn;
}

void Dinic()
{
    int rtn=0;
    while(Bfs())
    {
        for(int i=1;i<=n;i++) cur[i]=P[i];
        rtn+=Dfs(1,INF);
    }
    printf("%d ",rtn);
}

void Input_Init()
{
    n=read(),m=read(),K=read();
    for(int i=1;i<=m;i++)
    {
        static int x,y,z;
        x=read(),y=read(),z=read(),C[i]=read();
        Insert(x,y,z);
    }
}

bool bfs()
{
    queue<int>q;
    q.push(S);
    for(int i=0;i<=T;i++) Dis[i]=INF;
    Dis[0]=0;
    while(!q.empty())
    {
        int k=q.front();q.pop();
        Flag[k]=0;
        for(int i=p[k];i;i=nextedge[i])
        {
            int v=b[i],f=w[i];
            if(Dis[v]>Dis[k]+c[i]&&f)
            {
                Dis[v]=Dis[k]+c[i];
                Pre[v]=i;
                if(!Flag[v])
                {
                    Flag[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return Dis[T]!=INF;
}

void Mcf()
{
    int maxf=INF;
    for(int i=Pre[T];i;i=Pre[b[i^1]])
        maxf=min(maxf,w[i]);
    for(int i=Pre[T];i;i=Pre[b[i^1]])
    {
        w[i]-=maxf;
        w[i^1]+=maxf;
        ans+=maxf*c[i];
    }
}

void MCF()
{
    while(bfs())
        Mcf();
    printf("%d\n",ans);
}

void Build_Graph()
{
    Anode(0,1,K,0);T=n;
    for(int i=2;i<=Cnt;i+=2)
    {
        static int x,y;
        x=B[i^1],y=B[i];
        if(W[i]<K) Anode(x,y,K-W[i],C[i>>1]);
        if(W[i]) Anode(x,y,W[i],0);
    }
}

int main()
{
    Input_Init();
    Dinic();
    Build_Graph();
    MCF();
    return 0;
}
  1. 正解（100）
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#define N 1005
#define M 20005
#define INF 1000000000
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pa;

int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int n,m,K,cnt=1,S,T,ans,Cnt=1;
int b[M],p[N],nextedge[M],w[M],c[M],cur[N];
int Dis[N],Pre[N],Level[N];
bool Flag[N];

void Add(int x,int y,int z,int cost)
{
    cnt++;
    b[cnt]=y;
    nextedge[cnt]=p[x];
    p[x]=cnt;
    w[cnt]=z;
    c[cnt]=cost;
}

void Anode(int x,int y,int z,int cost){
    Add(x,y,z,cost);Add(y,x,0,-cost);
} 

bool Bfs()
{
    queue<int>q;
    for(int i=1;i<=n;i++) Level[i]=0;
    Level[1]=1;
    q.push(1);
    while(!q.empty())
    {
        int k=q.front();q.pop();
        for(int i=p[k];i;i=nextedge[i])
        {
            int v=b[i];
            if(!Level[v]&&w[i])
            {
                Level[v]=Level[k]+1;
                q.push(v);
            }
        }
    }
    return Level[n];
}

int Dfs(int x,int maxf)
{
    if(x==n||!maxf) return maxf;
    int rtn=0;
    for(int i=cur[x];i&&maxf>rtn;i=nextedge[i])
    {
        int v=b[i],f=w[i];
        if(Level[v]==Level[x]+1&&f)
        {
            f=Dfs(v,min(maxf-rtn,f));
            w[i]-=f;w[i^1]+=f;
            if(w[i]>0) cur[x]=i;
            rtn+=f;
        }
    }
    return rtn;
}

void Dinic()
{
    int rtn=0;
    while(Bfs())
    {
        for(int i=1;i<=n;i++) cur[i]=p[i];
        rtn+=Dfs(1,INF);
    }
    printf("%d ",rtn);
}

void Input_Init()
{
    n=read(),m=read(),K=read();
    for(int i=1;i<=m;i++)
    {
        static int x,y,z,cost;
        x=read(),y=read(),z=read(),cost=read();
        Anode(x,y,z,cost);
    }
}

bool bfs()
{
    queue<int>q;
    q.push(S);
    for(int i=0;i<=T;i++) Dis[i]=INF;
    Dis[0]=0;
    while(!q.empty())
    {
        int k=q.front();q.pop();
        Flag[k]=0;
        for(int i=p[k];i;i=nextedge[i])
        {
            int v=b[i],f=w[i];
            if(Dis[v]>Dis[k]+c[i]&&f)
            {
                Dis[v]=Dis[k]+c[i];
                Pre[v]=i;
                if(!Flag[v])
                {
                    Flag[v]=1;
                    q.push(v);
                }
            }
        }
    }
    return Dis[T]!=INF;
}

void Mcf()
{
    int maxf=INF;
    for(int i=Pre[T];i;i=Pre[b[i^1]])
        maxf=min(maxf,w[i]);
    for(int i=Pre[T];i;i=Pre[b[i^1]])
    {
        w[i]-=maxf;
        w[i^1]+=maxf;
        ans+=maxf*c[i];
    }
}

void MCF()
{
    while(bfs())
        Mcf();
    printf("%d\n",ans);
}

void Build_Graph()
{
    T=n;
    Cnt=cnt;
    for(int i=2;i<=Cnt;i+=2)
    {
        static int x,y;
        x=b[i^1],y=b[i];
        Anode(x,y,INF,c[i]);
        c[i]=c[i+1]=0;
    }
    Anode(0,1,K,0);
}

int main()
{
    Input_Init();
    Dinic();
    Build_Graph();
    MCF();
    return 0;
}
CR1SceNT
关注
专栏目录
bzoj5515: [Zjoi2019]线段树（线段树）
苟为蒟蒻又何妨
06-27 214
传送门 每次等价于一部分操作一部分不操作。 显然一个点被标记只可能是被直接标记或者祖先被标记，于是我们对于每一个节点 维护它被标记的概率与祖先被标记的概率。 把每个区间分类讨论更新即可。 有如下几种情况： 1.覆盖祖先但未覆盖自己 2. 直接覆盖当前点 3. 经过当前点继续在子树中修改 4. 修改到父亲处向兄弟子树走 5. 修改到非父亲祖先向兄弟子树走 然后用线段树维护即可。 详见代码 代码： #...
bzoj4876: [Zjoi2017]线段树（树上差分）
苟为蒟蒻又何妨
06-27 183
传送门 对于这种广义线段树的题，想要定位区间[l,r][l,r][l,r]可以转化成定位节点[l−1,l−1],[r+1,r+1][l-1,l-1],[r+1,r+1][l−1,l−1],[r+1,r+1]路径上的一些儿子节点。 设lca=tlca=tlca=t 那么路径[l−1,l−1]→t[l-1,l-1]\rightarrow t[l−1,l−1]→t的右儿子和路径[r+1,r+1]→t[r...
BZOJ 1834: [ZJOI2010]network 网络扩容
weixin_33712881的博客
05-28 95
传送门 Description 给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。 求： 1、在不扩容的情况下，1到N的最大流； 2、将1到N的最大流增加K所需的最小扩容费用。 Input 第一行包含三个整数N,M,K，表示有向图的点数、边数以及所需要增加的流量。 接下来的M行每行包含四个整数u,v,C,W，表示一...
1834: [ZJOI2010]network 网络扩容
CRZbulabula的博客
02-12 522
1834: [ZJOI2010]network 网络扩容 Time Limit: 3 Sec  Memory Limit: 64 MB Submit: 2309  Solved: 1157 [Submit][Status][Discuss] Description 给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况
bzoj1834 [ZJOI2010]network 网络扩容
Elijahqi
01-20 201
(http://www.elijahqi.win/2017/12/13/bzoj1834-zjoi2010network-%E7%BD%91%E7%BB%9C%E6%89%A9%E5%AE%B9/%20%E2%80%8E) Description 给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况下，1到N的最大流； 2、
bzoj 1834 [ZJOI2010] network 网络扩容 题解
阿蒋的专栏
04-03 1948
【原题】 1834: [ZJOI2010]network 网络扩容 Time Limit: 3 Sec  Memory Limit: 64 MB Submit: 1453  Solved: 721 [Submit][Status] Description 给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况
[bzoj1834][ZJOI2010]network 网络扩容
Edt!
06-23 507
1834: [ZJOI2010]network 网络扩容 Time Limit: 3 Sec  Memory Limit: 64 MB Submit: 3194  Solved: 1654 [Submit][Status][Discuss] Description 给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况
BZOJ4784: [Zjoi2017]仙人掌（DP）
DZYO的博客
05-06 221
传送门 题解： 好题。 先把仙人掌的环去掉变为若干树的问题。 对于一种方案，我们把没有被覆盖的边看做重边，那么每种方案对应着一种把边覆盖完的方案。 我们发现任意一种合法的方案，从每个子树都有向父节点连的一条边，一共有degidegideg_i条边（加上当前点向上到父节点的边）。 我们要把这些边组合起来或者直接连到当前点，并连一条边出去。 这个方案数很简单：gi=gi−1+(i−1)∗gi...
BZOJ3527: [Zjoi2014]力（洛谷P3338）
forezxl的博客
07-09 199
FFT BZOJ题目传送门 洛谷题目传送门 推式子： Ei=∑j=1i−1qj(i−j)2−∑j=i+1nqj(i−j)2=∑j=1i−1f1(j)f2(i−j)−∑j=i+1nf1(j)f2(i−j)(5)(6)(5)Ei=∑j=1i−1qj(i−j)2−∑j=i+1nqj(i−j)2(6)=∑j=1i−1f1(j)f2(i−j)−∑j=i+1nf1(j)f2(i−j) \begin{a...
BZOJ1833 [ZJOI2010]count 数字计数
neither_nor
05-18 904
数位DP模板题 然而我并不会-_-orz了一发hzwer学长的代码，终于学会了数位DP 设f[i][j]表示i位，开头为j的方案数（算前导零） 先预处理f数组 求a以内的答案时，先加上所有位数不足a的位数的，然后从高位到低位枚举当前位是几，计入答案，然后定下这一位，枚举下一位 基本把黄学长的代码抄了一遍-_- 复杂度O(位数*10*更新复杂度) #include #include #
最小割基本模型及解决方案
Heret1c
12-19 1913
最小割概念 割：如果从图G中删除一个弧的集合c{f}，让S流不到T，那么这个集合成为图G的一个割。记做C（S,T），S,T为点集。 正向割边：对于集合c中的一条弧f{u,v}（u指向v）如果u∈S，v∈T则成为正向割边。 逆向割边：对于集合c中的一条弧f{u,v}（u指向v）如果u∈T，v∈S则成为逆向割边。 割的容量：割C{S,T}中所有正向割边的容量和称为割的容量。 最小割：容量最小的割Ci{S
BZOJ3158: 千钧一发
Heret1c
12-20 1299
题目链接【分析】某两样物品之间若满足某些条件则无法同时获取，显然最小割。 这个题其实和BZOJ3275几乎相同。。。【建图】 我刚开始蠢蠢的做法，还是拆点，对于点x，S向x’连边，流量b[i]，x”向T连边，流量为b[i]，对于每一对不能同时取得点i,j，连边i’–>j”，j’–>i”，流量均为INF。答案=(∑b[i]*2-最小割)/2。 看完大神的做法，简直觉得自己low爆了。 可以证明，
BZOJ2521: [Shoi2010]最小生成树
Heret1c
05-29 864
BZOJ2521QAQ一开始看到这个题就想到了BZOJ2561 然而瞬间否定，这两个题应该不太一样。神flag！flag！ 先说说一开始错的想法错在哪吧。。 可以直接passpass： （一开始想的是类似次小生成树的做法，先做最小生成树，排序时若有多个边长与z[lab]相同的边，把lab放到最后，然后MST，如果边lab没出现，直接返回。然而发现这样还是有可能有其他解使得不考虑边lab，MS
BZOJ4873: [Shoi2017]寿司餐厅
Heret1c
06-08 815
BZOJ4873。。感觉网络流题目做的也不少了。。可是拿到了还是不会QAQQAQ 一开始把mx2+cxmx^2+cx的xx看成了取的该种寿司的个数。。。 所求答案是获得的美味度之和减去花费。可以联想到最大权闭合子图。 然后考虑一下依赖关系。 首先可以想到源向每个区间连边，边权为Di,jD_{i,j}，这是收益。 在考虑花费，每一种寿司向汇连边，花费应该是mx2+cxmx^2+cx，可是这个
BZOJ4514: [Sdoi2016]数字配对
Heret1c
06-10 814
BZOJ4514看到题目很容易发现是最大费用最大流。 关键点就是如何分成二分图。 （QAQQAQ涨姿势了） 把每个aa分解质因数： a=∏pixia=\prod {p_i}^{x_i} 记Numi=∑xNum_i=\sum x那么可以发现可以根据NumiNum_i的奇偶性构造二分图。 然后正常建图。若NumiNum_i为奇数，连边(S,i,bi,0)(S,i,b_i,0),否则连边(i,
BZOJ1221: [HNOI2001] 软件开发
Heret1c
12-22 684
题目链接【分析】和餐巾计划基本相同。【建模】拆点，每个点x拆为x’和x”。 S向每个点x’建边，容量为n[i]，费用为0。表示当天用了n[i]。 每个x”向T建边，容量为n[i]，费用为0。表示当天需要n[i]。 S向每个点x’’建边，容量为INF，费用为f。表示当天通过购买来获得毛巾。 每个点x’向(x+1)’建边，容量为INF，费用为0。表示当天用完的毛巾留到下一天处理。 若x+a+1<=n，建
BZOJ4177: Mike的农场
Heret1c
06-16 669
BZOJ4177MDMD考的时候还想半天，这TMTM不就是文理分科吗。真的sbsb了。赶紧退役算了。。 SS向nn个点连边（S,i,ai）（S,i,a_i） nn个点向TT连边（i,T,bi）（i,T,b_i） 对于mm每条规则(i,j,k)(i,j,k)，连边(i,j,k)(i,j,k)和(j,i,k)(j,i,k) kk个额外收益，如果是都取aa获得收益，就建新点，SS连向新点，然后该点
BZOJ2839:集合计数(容斥,组合数学)
最新发布
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值