SGU 176 Flow construction(有上下限的最小流)

最新推荐文章于 2019-06-20 20:24:06 发布
最新推荐文章于 2019-06-20 20:24:06 发布
阅读量127 收藏
点赞数
文章标签： php

题目链接：http://acm.sgu.ru/problem.php?contest=0&problem=176

题意：给出一个有向图，边有边权。对于边有要求，要求有些边的流量恰好等于容量，其他边的流量要不大于其容量。在该要求下求最小流。1号点为源点，n号点为汇点。

思路：有上下限最小流。两种方法：

（1）构建的新图D和上面的D是一样的。也是先求S到T的最大流，此时记录<t,s>边的流量A，然后删掉边<t,s>，接着求t到s的最大流B，则答案为A-B。此时A-B有可能为0，原因是这个图本来最小流为0，由于有环的存在这个图可以自给自足，此时增加S到s的边<S,s,B-A>，再跑S到t(此时是原来图的汇点t)的最大流。这样，每条边的流量加上下限就是每条边的实际流量。

（2）二分t到s的上限。x=in[i]-out[i]，x>=0,连边<S,i,x>，sum+=x,否则<i,T,-x>。求S到T的最大流,大于等于sum则可行。

#include <iostream>
#include <string.h>
#include <stdio.h>
#define min(x,y) ((x)<(y)?(x):(y))
using namespace std;

struct node
{
	int x,y,b,c;
};

struct Node
{
	int v,cap,flow,next;

	Node(){}
	Node(int _v,int _cap,int _flow,int _next)
	{
		v=_v;
		cap=_cap;
		flow=_flow;
		next=_next;
	}
};


const int INF=1000000000;
Node edges[120005];
node info[10005];
int n,m,s,t,S,T,head[1005],e;
int num[1005],h[1005],curedge[1005],pre[1005];

void Add(int u,int v,int cap)
{
	edges[e]=Node(v,cap,0,head[u]);
	head[u]=e++;
	edges[e]=Node(u,0,0,head[v]);
	head[v]=e++;
}



int Maxflow(int s,int t,int n)
{
	int ans=0,i,k,x,d,u;

	memset(num,0,sizeof(num));
	memset(h,0,sizeof(h));
	for(i=0;i<=n;i++) curedge[i]=head[i];
	num[n]=n;u=s;
	while(h[u]<n)
	{
		if(u==t)
		{
			d=INF+1;
			for(i=s;i!=t;i=edges[curedge[i]].v) if(d>edges[curedge[i]].cap)
				k=i,d=edges[curedge[i]].cap;
			for(i=s;i!=t;i=edges[curedge[i]].v)
			{
				x=curedge[i];
				edges[x].cap-=d;
				edges[x].flow+=d;
				edges[x^1].cap+=d;
				edges[x^1].flow-=d;
			}
			ans+=d;u=k;
		}
		for(i=curedge[u];i!=-1;i=edges[i].next) if(edges[i].cap>0&&h[u]==h[edges[i].v]+1)
			break;
		if(i!=-1)
		{
			curedge[u]=i;
			pre[edges[i].v]=u;
			u=edges[i].v;
		}
		else
		{
			if(--num[h[u]]==0) break;
			curedge[u]=head[u];
			for(x=n,i=head[u];i!=-1;i=edges[i].next) if(edges[i].cap>0&&h[edges[i].v]<x)
				x=h[edges[i].v];
			h[u]=x+1;num[h[u]]++;
			if(u!=s) u=pre[u];
		}
	}
	return ans;
}

int in[105],out[105];

int main()
{
	memset(head,-1,sizeof(head));
	e=0;
    int ans1,ans2,ans,i,sum=0;
    scanf("%d%d",&n,&m);
    if(n==0)
	{
        puts("Impossible");
        return 0;
    }
    s=1;t=n;S=n+1;T=n+2;
    for(i=1;i<=m;i++)
	{
        scanf("%d%d%d%d",&info[i].x,&info[i].y,&info[i].b,&info[i].c);
        if(info[i].c)
		{
            sum+=info[i].b;
            in[info[i].y]+=info[i].b;
            out[info[i].x]+=info[i].b;
            Add(info[i].x,info[i].y,0);
        }
        else Add(info[i].x,info[i].y,info[i].b);
    }

    for(i=1;i<=n;i++)
	{
        Add(S,i,in[i]);
        Add(i,T,out[i]);
    }
    Add(t,s,INF);

    if(Maxflow(S,T,n+2)!=sum)
	{
        puts("Impossible");
        return 0;
    }
    ans1=edges[head[t]^1].cap;

    edges[head[t]].cap=0;
    edges[head[t]^1].cap=0;

    ans2=Maxflow(t,s,n+2);
    ans=ans1-ans2;
    if(ans<0)
	{
		edges[head[t]].cap=0;
        edges[head[t]^1].cap=0;
		edges[e]=Node(s,-ans,0,head[S]);
	    head[S]=e++;
        Maxflow(S,t,n+2);
        ans=0;
    }
    printf("%d\n",ans);
    for(i=1;i<=m;i++) printf(i==1?"%d":" %d",edges[i+i-1].cap+info[i].b*info[i].c);
    puts("");
    return 0;
}

　

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <map>


#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)<(y)?(x):(y))
#define abs(x) ((x)>=0?(x):-(x))
#define i64 long long
#define u32 unsigned int
#define u64 unsigned long long
#define clr(x,y) memset(x,y,sizeof(x))
#define CLR(x) x.clear()
#define ph(x) push(x)
#define pb(x) push_back(x)
#define Len(x) x.length()
#define SZ(x) x.size()
#define PI acos(-1.0)
#define sqr(x) ((x)*(x))
#define MP(x,y) make_pair(x,y)
#define EPS 1e-9

#define FOR0(i,x) for(i=0;i<x;i++)
#define FOR1(i,x) for(i=1;i<=x;i++)
#define FOR(i,a,b) for(i=a;i<=b;i++)
#define FORL0(i,a) for(i=a;i>=0;i--)
#define FORL1(i,a) for(i=a;i>=1;i--)
#define FORL(i,a,b)for(i=a;i>=b;i--)
using namespace std;


void RD(int &x){scanf("%d",&x);}
void RD(u32 &x){scanf("%u",&x);}
void RD(double &x){scanf("%lf",&x);}
void RD(int &x,int &y){scanf("%d%d",&x,&y);}
void RD(u32 &x,u32 &y){scanf("%u%u",&x,&y);}
void RD(double &x,double &y){scanf("%lf%lf",&x,&y);}
void RD(int &x,int &y,int &z){scanf("%d%d%d",&x,&y,&z);}
void RD(int &x,int &y,int &z,int &t){scanf("%d%d%d%d",&x,&y,&z,&t);}
void RD(u32 &x,u32 &y,u32 &z){scanf("%u%u%u",&x,&y,&z);}
void RD(double &x,double &y,double &z){scanf("%lf%lf%lf",&x,&y,&z);}
void RD(char &x){x=getchar();}
void RD(char *s){scanf("%s",s);}
void RD(string &s){cin>>s;}


void PR(int x) {printf("%d\n",x);}
void PR(int x,int y) {printf("%d %d\n",x,y);}
void PR(i64 x) {printf("%lld\n",x);}
void PR(u32 x) {printf("%u\n",x);}
void PR(double x) {printf("%.5lf\n",x);}
void PR(char x) {printf("%c\n",x);}
void PR(char *x) {printf("%s\n",x);}
void PR(string x) {cout<<x<<endl;}


struct Node
{
	int u,v,cap,flow,next;
};


const int INF=1000000000;
Node edges[120005];
int n,m,s,t,head[1005],e;
int num[1005],h[1005],curedge[1005],pre[1005];

void add(int u,int v,double cap)
{
	edges[e].u=u;
	edges[e].v=v;
	edges[e].cap=cap;
	edges[e].flow=0.0;
	edges[e].next=head[u];
	head[u]=e++;
}

void Add(int u,int v,double cap)
{
	add(u,v,cap);
	add(v,u,0.0);
}



int Maxflow(int s,int t,int n)
{
	int ans=0,i,k,x,d,u;

	memset(num,0,sizeof(num));
	memset(h,0,sizeof(h));
	for(i=0;i<=n;i++) curedge[i]=head[i];
	num[n]=n;u=s;
	while(h[u]<n)
	{
		if(u==t)
		{
			d=INF+1;
			for(i=s;i!=t;i=edges[curedge[i]].v) if(d>edges[curedge[i]].cap)
				k=i,d=edges[curedge[i]].cap;
			for(i=s;i!=t;i=edges[curedge[i]].v)
			{
				x=curedge[i];
				edges[x].cap-=d;
				edges[x].flow+=d;
				edges[x^1].cap+=d;
				edges[x^1].flow-=d;
			}
			ans+=d;u=k;
		}
		for(i=curedge[u];i!=-1;i=edges[i].next) if(edges[i].cap>0&&h[u]==h[edges[i].v]+1)
			break;
		if(i!=-1)
		{
			curedge[u]=i;
			pre[edges[i].v]=u;
			u=edges[i].v;
		}
		else
		{
			if(--num[h[u]]==0) break;
			curedge[u]=head[u];
			for(x=n,i=head[u];i!=-1;i=edges[i].next) if(edges[i].cap>0&&h[edges[i].v]<x)
				x=h[edges[i].v];
			h[u]=x+1;num[h[u]]++;
			if(u!=s) u=pre[u];
		}
	}
	return ans;
}

struct Info
{
    int u,v,b,c;

    void read()
    {
        RD(u,v,b,c);
        if(c==0) c=b,b=0;
        else c=b;
    }
};

Info a[10005];
int in[105],out[105];


int OK(int mid)
{
    clr(head,-1); e=0;
    clr(in,0),clr(out,0);
    int i,sum=0,x;
    a[m+1].u=n; a[m+1].v=1;
    a[m+1].b=0; a[m+1].c=mid;
    FOR1(i,m+1)
    {
        in[a[i].v]+=a[i].b;
        out[a[i].u]+=a[i].b;
        Add(a[i].u,a[i].v,a[i].c-a[i].b);
    }
    int S=0,T=n+1;
    FOR1(i,n)
    {
        x=in[i]-out[i];
        if(x>=0) Add(S,i,x),sum+=x;
        else Add(i,T,-x);
    }
    return Maxflow(S,T,T+1)>=sum;
}

int main()
{
    RD(n,m);
    int i;
    FOR1(i,m) a[i].read();
    int low=0,high=INF,mid;
    while(low<=high)
    {
        mid=(low+high)>>1;
        if(OK(mid)) high=mid-1;
        else low=mid+1;
    }
    int ans;
    if(high>=0&&OK(high)) ans=high;
    else if(OK(low)) ans=low;
    else ans=-1;
    if(ans==-1)
    {
        puts("Impossible");
        return 0;
    }
    PR(ans);
    FOR1(i,m)
    {
        if(i!=1) putchar(' ');
        printf("%d",edges[i+i-1].cap+a[i].b);
    }
    puts("");
    return 0;
}

 

　　

 

weixin_34349320
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
上下界网络流
04-16
"上下界网络流" 上下界网络流是一种特殊的网络流，边的流量有限制，必须在[down, up]的范围内。...5. 当且仅当附加弧都满流时是有可行流，最后的最小流是 flow[sd->st]^1], st 到 sd 的最大流就是 sd 到 st 的最小流。
SGU推荐题目分类
05-06
176 Flow construction 上下界网络流：Flow construction 是 SGU 中的一道上下界网络流题目，要求使用上下界网络流来解决。 177 Sqare 倒序染色：Sqare 是 SGU 中的一道倒序染色题目，要求使用倒序染色来解决。 ...
hdu 3157(有上下界的最小流)
志当存高远
09-13 1407
Crazy Circuits Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 154    Accepted Su
[上下界最小流] SGU 176. Flow construction
穹妹的家
09-02 466
176. Flow construction题意：从1到n的一个网络，每个边有上下界，求最小流。思路：属于有源汇上下界的最小流问题，总结下。 原网络每条边的容量为CMax−CMinC_{Max}-C_{Min}，同时记录每个点的下界流量，流入为正，流出为负，记为flow[i]flow[i]。 建立每个点和ssss及tttt之间的边，若flow[i]>0flow[i]>0，连接ssss和ii,容量为f
SGU 176 有源汇有上下界最小流(模板)
ZQDNR
04-23 400
176. Flow constructiontime limit per test: 0.5 sec. memory limit per test: 4096 KB input: standard output: standardYou have given the net consisting of nodes and pipes; pipes connect the nodes. Some
sgu 176. Flow construction
Wings_of_Liberty的专栏
09-13 983
题目链接：http://acm.sgu.ru/problem.php?contest=0&problem=176 题目大意：网中有些边必须满流，求最小可行流 题目思路：有上下界最小流，见周源《一种简易的方法求解流量有上下界的网络中网络流问题》，还有一种非二分的方法，但没有严格证明，所以我还是用的二分。 #include #include #include #include #include
SGU - 176 Flow construction(上下界有源有汇最小流)
静静地码
09-07 975
题目大意：给出N个点，M条有向边 如果有向边的标号是1的话，就表示该边的上界下界都为容量 如果有向边的标号为0的哈，表示该边的下界为0，上界为容量 现在问，从1到N的最小流是多少，并输出每条边的流量解题思路：上下界有源有汇最小流，基本模版#include <cstdio> #include <cstring> #include <algorithm> #include <vector> #in
sgu101-121.rar_sgu_sgu101 pascal
09-22
【标题】"sgu101-121.rar_sgu_sgu101 pascal" 指的是一个包含SGU在线评测系统上题目编号从101到121的Pascal语言解题代码的压缩包。SGU（Stepik Graph Problems）是一个专门针对图论和算法问题的在线评测系统，它提供...
SPOJ.zip_SPOJ_sgu_them
09-24
"SPOJ.zip_SPOJ_sgu_them"这个压缩包文件就包含了针对SPOJ上的一些问题的解决方案，特别的是，所有这些解决方案都采用了动态规划（Dynamic Programming, 简称DP）这一强大的算法思想。下面我们将深入探讨动态规划...
sgu:acm.sgu.ru
07-02
【标题】"sgu:acm.sgu.ru" 指的是一个与 ACM（国际计算机科学联盟）相关的项目，特别是与 acm.sgu.ru 这个在线编程竞赛平台相关。这个平台是为程序员提供练习和参与算法竞赛的地方，通常会发布一系列的编程问题，...
sgu 176 Flow construction--有源汇 有上下界 最小流
08-01 1946
/* SGU 176 Flow construction 题意：有些节点(编号1~n，1为源，n为汇)和管道，用来运输某种物质(substance) 某些管道必须满流，有些不必，找到一个最小流，满足要求 输入： 结束数目 管道数目 管道{ 管道前节点，后节点，最大流量，是否需要满流(1需要0不需要) } 就是求一个最小流 http://blog.csdn.net/qq172108805/art
SGU 176 Flow construction 有源汇 有上下界的最小流
水
10-31 1663
题意就是给出一个图。有源汇 然后每条边都有容量的上下界限制。 问的是是否有一个最小流，使得每条边得流量都满足流量限制，并且流量守恒 我使用的是二分的方法。 每次二分都要重新构图，然后计算。 #include #include #include #include #include #include #include #include #include #include
【上下界网络流】sgu194 zoj3229 sgu176 zoj1994 zoj3496
01-07 415
终于意识到了一个好的网络流模板是有多么重要。%>_<% 而且上下界的代码细节特别多，再加上蒟蒻木有写一段就检查的好习惯，直接导致调了很久……sgu194 这是一道无源点汇点的求上下界网络流的可行流。 首先把它转化为一个有源点汇点的网络流。令du[u]du[u]表示出边的下界之和减去入边的下界之和。把所有边的流量改为up−downup-down（上界-下界）。 建立一个超级源点ss和超级汇点t
SGU 176 有源汇上下界最小流
I will Do iT @ hlyblog.net
08-14 1649
题目意思就是 1 是源点、 n 是汇点。
★ SGU 176 有源汇上下界最小流
【洛风城】
08-04 848
有源汇上下界最小流建图： 1.构造附加网络(不添加[t,s]边)  2.对ss、tt求最大流  3.添加[t,s]边  4.对ss、tt求最大流  5.若ss、tt满流，则[t,s]的流量就是最小流
SGU 176 有源汇上下界的最小流
常胜将军的博客
06-20 245
题意：给出N个点，M条有向边，如果有向边的标号是1的话，就表示该边的上界下界都为容量，如果有向边的标号为0的哈，表示该边的下界为0，上界为容量，现在问，从1到N的最小流是多少，并输出每条边的流量。 思路：首先，还是处理出所有的结点的入流-出流，然后连向超级源点S，超级汇点T，和无源无汇的那种情况相同，把源汇当成普通结点，先跑出最大流了，再添加边，再跑一次最大流，接着得到的(t1->s1)流...
SGU 176 Flow construction 网络流 有上下界限制最小流
Rocking_Bee's Blog
12-03 497
1.构建附加网络 2.求ss 到 tt 的最大流 3.加入 t 到 s 容量为 INF 的边 4.再对 ss 到 tt 求一次最大流 5.若 ss 和 tt 满流，则 t 到 s 的流量即位最小流 6.若 5 不满足，则无可行流 #include #include #include #include #include #include using namespace std; cons
【有源汇点上下界最小流】[SGU176]Flow construction
weixin_30354675的博客
01-20 68
题目大意 给出N个点，M条有向边 如果有向边的标号是1的话，就表示该边的上界下界都为容量 如果有向边的标号为0的哈，表示该边的下界为0，上界为容量 现在问，从1到N的最小流是多少，并输出每条边的流量 分析 像无源汇点上下界可行流那样建图，然后从SS->ST跑一次，然后t->s连一条容量为+∞的边，跑一次，t->s这条边的流量即为最小流。 代...
sgu tgu 点云
最新发布
09-18
SGU和TGU是常用于点云处理的两种算法。点云是由大量点的集合形成的三维空间数据模型，常用于地图制作、建筑设计、虚拟现实等领域。 SGU（Surface Generation Unit）是一种基于网格化的点云处理算法。它通过将点云...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值