网络流基础题

最新推荐文章于 2021-08-12 00:00:41 发布
最新推荐文章于 2021-08-12 00:00:41 发布
阅读量171 收藏 1
点赞数 2
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51791233/article/details/119494015
版权

网络流基础题

数字梯形问题

题目链接
这道题的三个操作，感觉比较全面的包括了建图的想法，也算比较基础的网络流入门题。对理解网络流应该比较有帮助吧
题目描述
给定一个由 n n n 行数字组成的数字梯形如下图所示。
在这里插入图片描述
梯形的第一行有 m m m 个数字。从梯形的顶部的 m m m 个数字开始，在每个数字处可以沿左下或右下方向移动，形成一条从梯形的顶至底的路径。

分别遵守以下规则：

1.从梯形的顶至底的 m m m 条路径互不相交；
2.从梯形的顶至底的 m m m 条路径仅在数字结点处相交；
3.从梯形的顶至底的 m m m 条路径允许在数字结点相交或边相交。

输入格式
第 1 1 1 行中有 1 1 1 个正整数 m m m 和 n n n，分别表示数字梯形的第一行有 m m m 个数字，共有 n n n 行。接下来的 n n n 行是数字梯形中各行的数字。

第 1 1 1 行有 m m m 个数字，第 2 2 2 行有 m + 1 m+1 m+1 个数字，以此类推。

输出格式
将按照规则 1 1 1，规则 2 2 2，和规则 3 3 3 计算出的最大数字总和并输出，每行一个最大总和。

输入输出样例

输入 #1
2 5
2 3
3 4 5
9 10 9 1
1 1 10 1 1
1 1 10 12 1 1
输出 #1
66
75
77

分析
操作1： m条路径互不相交，其实就是每个点只能走一次。(拆点)
操作2： 在操作1的基础上，取消了只能走一次的限制，那就不需要拆点正常连流量为1（边不可以相交）的边即可。但是要注意最后一排的点流向超级汇点（路径到达最后一排可以重复）。
操作3： 就是完全没有限制，点边都可以重复，把互相的流量改成INF即可。

关于拆点的问题:我们把一个顶点分成A,B两个点，并且将A点和B点之间连上一条流量为1的边，把A作为流入点，B作为流出点，那么如果有多条路径流向点A的话，最终也只有一条会流出点B，通过拆点就可以限制每个点只会被一条路径流过。
在这里插入图片描述如上图所示，如果点1和点2同时流向点3，那么因为拆点限流的关系，最后结果只会计算一条路径。

然后就是具体的建图方法：
很简单 看代码就懂了

1.建立一个超级原点 s s s，连向每个第一排的点（流量为1，费用为0）
2.然后每一层都向下一层能到的地方连边（流量看操作，费用为点权）
3.操作一额外多了一个拆点，所以记录了一个 o o o表示所有点数，到时候拆点就加个 o o o就行
4.所有最后一层的点连向超级汇点 t t t（流量为INF，费用为点权）

三个操作分开写，每次要记得初始化。

AC代码
不会有人只看这个吧

#include<bits/stdc++.h>
#define pll pair<int,int>
#define pb push_back
#define FAST std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define INF 1e18
#define inf 0x3f3f3f3f
#define pi acos(-1)
//#define ls now<<1
//#define rs now<<1|1
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e7 + 10;
const int N = 5e3 + 10;
int a[44][44],b[44][44];
int n,m,s,t;//从这里开始都是模板
struct node{
	int t,nex;
	ll w,c;
}e[MAXN];
ll ans,cost;
int head[N],cnt=1;
void add(int a,int b,ll c,ll d)
{
	e[++cnt].t=b;e[cnt].nex=head[a];e[cnt].w=c;	e[cnt].c=d;head[a]=cnt;
	e[++cnt].t=a;e[cnt].nex=head[b];e[cnt].w=0;e[cnt].c=-d;head[b]=cnt;
}
ll st[N];
int pre[N];
bool vs[N];
bool spfa() 
{
	queue<int>q;
	for(int i=0;i<=t;i++)
	{
		vs[i]=0;st[i]=-INF;pre[i]=-1;
	}
	q.push(s);st[s]=0;vs[s]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop();vs[u]=0;
		for(int i=head[u];i!=-1;i=e[i].nex)
		{
			int v=e[i].t;
			if(st[v]<st[u]+e[i].c&&e[i].w)
			{
				st[v]=st[u]+e[i].c;pre[v]=i;
				if(!vs[v]){vs[v]=1;q.push(v);}
			}
		}
	}
	if(st[t]==-INF)return false;
	ll d=INF;
	for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        d=min(d,e[i].w);
    }
    for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        e[i].w-=d;
        e[i^1].w+=d;
        cost+=e[i].c*d;
    }
    ans+=d;
    return true;
}//到这里开始建图
int o;
void op1()
{
	memset(head,-1,sizeof(head));cnt=1;
	s=0;t=o*2+1;
	for(int i=1;i<=n;i++)add(s,b[1][i],1,0);
	for(int i=1;i<=n+m-1;i++)add(b[m][i]+o,t,1,0);
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n+i-1;j++)
		{
			add(b[i][j],b[i][j]+o,1,a[i][j]);
		}
	}
	for(int i=1;i<m;i++)
	{
		for(int j=1;j<=n+i-1;j++)
		{
			add(b[i][j]+o,b[i+1][j],1,0);add(b[i][j]+o,b[i+1][j+1],1,0);
		}
	}
	cost=0;ans=0;
	while(spfa());
	cout<<cost<<endl;
}
void op2()
{
	memset(head,-1,sizeof(head));cnt=1;
	s=0;t=o+1;
	for(int i=1;i<=n;i++)add(s,b[1][i],1,0);
	for(int i=1;i<=n+m-1;i++)add(b[m][i],t,INF,a[m][i]);//注意这里是INF
	for(int i=1;i<m;i++)
	{
		for(int j=1;j<=n+i-1;j++)
		{
			add(b[i][j],b[i+1][j],1,a[i][j]);
			add(b[i][j],b[i+1][j+1],1,a[i][j]);
		}
	}
	cost=0;ans=0;
	while(spfa());
	cout<<cost<<endl;
}
void op3()
{
	memset(head,-1,sizeof(head));cnt=1;
	s=0;t=o+1;
	for(int i=1;i<=n;i++)add(s,b[1][i],1,0);
	for(int i=1;i<=n+m-1;i++)add(b[m][i],t,INF,a[m][i]);
	for(int i=1;i<m;i++)
	{
		for(int j=1;j<=n+i-1;j++)
		{
			add(b[i][j],b[i+1][j],INF,a[i][j]);
			add(b[i][j],b[i+1][j+1],INF,a[i][j]);
		}
	}
	cost=0;ans=0;
	while(spfa());
	cout<<cost<<endl;
}
void work() 
{
	cin>>n>>m;
	o=(n*2+m-1)*m/2;//计算总点数
	int cntn=0;
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=n+i-1;j++)
		{
			cin>>a[i][j];
			b[i][j]=++cntn;//给每个点加编号
		}
	}
	op1();op2();op3();
}
int main() {//个人习惯分开写
	FAST;
	int t = 1;
	//cin >> t;
	while (t--)work();
	return 0;
}

[CTSC1999]家园 / 星际转移问题

题目链接
题目描述
由于人类对自然资源的消耗，人们意识到大约在 2300 年之后，地球就不能再居住了。于是在月球上建立了新的绿地，以便在需要时移民。令人意想不到的是，2177 年冬由于未知的原因，地球环境发生了连锁崩溃，人类必须在最短的时间内迁往月球。

现有 n n n 个太空站位于地球与月球之间，且有 m m m 艘公共交通太空船在其间来回穿梭。每个太空站可容纳无限多的人，而太空船的容量是有限的，第 i i i 艘太空船只可容纳 h i h_i hi​ 个人。每艘太空船将周期性地停靠一系列的太空站，例如 ( 1 , 3 , 4 ) (1,3,4) (1,3,4)表示该太空船将周期性地停靠太空站 134134134 … 134134134… 134134134…。每一艘太空船从一个太空站驶往任一太空站耗时均为 1 1 1。人们只能在太空船停靠太空站(或月球、地球)时上、下船。

初始时所有人全在地球上，太空船全在初始站。试设计一个算法，找出让所有人尽快地全部转移到月球上的运输方案。

输入格式
输入的第一行是三个用空格隔开的整数，分别代表太空站个数 n n n，太空船个数 m m m 和地球上的人数 k k k。

第 2 2 2 到第 ( m + 1 ) (m+1) (m+1) 行，每行给出一艘太空船的信息，第 ( i + 1 ) (i+1) (i+1) 行的第一个整数 h i h_i hi​ 代表第 i i i 艘太空船可容纳的人数。随后有一个整数 rir_iri​，代表第 iii 艘太空船停靠的站点数。之后有 r i r_i ri​ 个整数，依次代表该太空船停靠站点的编号 S i , j S_{i, j} Si,j​，其中太空站自 1 1 1 至 n n n 编号，地球编号为 0 0 0，月球编号为 − 1 -1 −1。

输出格式
输出一行一个整数，代表将所有人转移到月球上的最短用时。若无解则输出 0 0 0。
输入输出样例

输入 #1
2 2 1
1 3 0 1 2
1 3 1 2 -1
输出 #1
5
数据范围
1 ≤ n ≤ 13 1 \leq n \leq13 1≤n≤13
1 ≤ m ≤ 20 1 \leq m \leq 20 1≤m≤20
1 ≤ k ≤ 50 1 \leq k \leq 50 1≤k≤50
1 ≤ r i ≤ n + 2 1 \leq r_i \leq n + 2 1≤ri​≤n+2
− 1 ≤ S i , j ≤ n -1 \leq S_{i, j}\leq n −1≤Si,j​≤n

分析
这道题数据范围很小，我们还是结合上面拆点的思想，将每个点编号，再按时间来拆点，造成一张分层图。

我们写一个结构体来存飞船信息(代码17到24行)
记录飞船容量以及流程，vector存每天所在位置，getd找两天的位置

我们考虑天数每增加一天该做的操作：

1.首先上一天肯定要和今天对应的点连边，表示可以停留。(第一个循环)
2.然后飞船会运人，那么就找到飞船上一天的位置和今天所在的位置连边，表示运输（第二个循环）

灵魂画师 呜呜 将就看吧
这里由于输入的时候地球为 0 0 0，月球为 − 1 -1 −1，所以我整体加了 2 2 2，保证正整数，所以每一层的节点数就是 n + 2 n+2 n+2
在这里插入图片描述

1.S原点连向day0的地球，边权为K
2.所有天数的月球向T连边，边权为INF，因为到了月球就可以了
3.每新建一天就让上一天连向这一天，边权为INF，表示可以停留（船上不了了）
4.找到每个飞船这一天和上一天的位置，连边，边权为 h i h_i hi​（一次只有那么多容量）

那么这题就做完了（doge）
好像还要判无解？？
无解其实很简单，每个飞船能到的点用并查集维护，最后看看地球（2）和月球（1）是否在一个集合即可

AC代码

#include<bits/stdc++.h>
#define pll pair<int,int>
#define mp make_pair
#define pb push_back
#define FAST std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define INF 1e18
#define inf 0x3f3f3f3f
#define pi acos(-1)
//#define ls now<<1
//#define rs now<<1|1
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e6 + 10;
const int N = 2e4 + 10;
int n,m,s,t,k;
struct ship{
	int res,day;
	vector<int>v;
	pll getd(int res)
	{
		return mp(v[(res-1)%day],v[res%day]);
	}
}sh[25];
struct node{
	int t,nex;
	ll w,c;
}e[MAXN];
ll ans,cost;
int head[N],cnt=1;
void add(int a,int b,ll c,ll d)
{
	e[++cnt].t=b;e[cnt].nex=head[a];e[cnt].w=c;	e[cnt].c=d;head[a]=cnt;
	e[++cnt].t=a;e[cnt].nex=head[b];e[cnt].w=0;e[cnt].c=-d;head[b]=cnt; 
}
ll st[N];
int pre[N];
bool vs[N];
bool spfa() 
{
	queue<int>q;
	for(int i=0;i<=t;i++)
	{
		vs[i]=0;st[i]=INF;pre[i]=-1;
	}
	q.push(s);st[s]=0;vs[s]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop();vs[u]=0;
		for(int i=head[u];i!=-1;i=e[i].nex)
		{
			int v=e[i].t;
			if(st[v]>st[u]+e[i].c&&e[i].w)
			{
				st[v]=st[u]+e[i].c;pre[v]=i;
				if(!vs[v]){vs[v]=1;q.push(v);}
			}
		}
	}
	if(st[t]==INF)return false;
	ll d=INF;
	for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        d=min(d,e[i].w);
    }
    for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        e[i].w-=d;
        e[i^1].w+=d;
        cost+=e[i].c*d;
    }
    ans+=d;
    return true;
}
int fa[20];
int find(int x)
{
	return fa[x]==x?x:fa[x]=find(fa[x]);
}
void work()
{
	memset(head,-1,sizeof(head));
    cin>>n>>m>>k;
    for(int i=1;i<=n+2;i++)fa[i]=i;
    for(int i=1;i<=m;i++)
    {
    	cin>>sh[i].res>>sh[i].day;
    	for(int j=1;j<=sh[i].day;j++)
    	{
    		int x;
			cin>>x;
    		x+=2;
    		sh[i].v.pb(x);
		}
		int a=find(sh[i].v[0]);
		for(int j=1;j<sh[i].v.size();j++)
		{
			int b=find(sh[i].v[j]);
			if(a!=b)fa[b]=a;
		}
	}
	if(find(1)!=find(2))
	{
		cout<<0<<endl;
		return;
	}
	s=0;t=10000;//t稍微赋大一些，不知道要几天才结束
	add(s,2,INF,0);add(1,t,INF,0);
	for(int day=1;;day++)
	{
		add(1+day*(n+2),t,INF,0);
		for(int i=1;i<=n+2;i++)
		{
			add((day-1)*(n+2)+i,day*(n+2)+i,INF,0);
			//cout<<(day-1)*(n+2)+i<<" "<<(day)*(n+2)+i<<endl;
		}
		for(int i=1;i<=m;i++)
		{
			pll a=sh[i].getd(day);
			add((day-1)*(n+2)+a.first,day*(n+2)+a.second,sh[i].res,0);
			//cout<<(day-1)*(n+2)+a.first<<" "<<day*(n+2)+a.second<<endl;
		}
		while(spfa())
		//cout<<ans<<" "<<day<<endl;
		if(ans>=k)
		{
			cout<<day<<endl;
			return;
		}
	}
}
int main() {
    FAST;
    int t = 1;
    //cin >> t;
    while (t--)work();
    return 0;
}

火星探险问题

题目链接
题目描述
火星探险队的登陆舱将在火星表面着陆，登陆舱内有多部障碍物探测车。登陆舱着陆后，探测车将离开登陆舱向先期到达的传送器方向移动。

探测车在移动中还必须采集岩石标本。每一块岩石标本由最先遇到它的探测车完成采集。每块岩石标本只能被采集一次。岩石标本被采集后，其他探测车可以从原来岩石标本所在处通过。探测车不能通过有障碍的地面。

本题限定探测车只能从登陆处沿着向南或向东的方向朝传送器移动，而且多个探测车可以在同一时间占据同一位置。如果某个探测车在到达传送器以前不能继续前进，则该车所采集的岩石标本将全部损失。

用一个 p × q p \times q p×q 网格表示登陆舱与传送器之间的位置。登陆舱的位置在 ( x 1 , y 1 ) (x_1,y_1) (x1​,y1​) 处，传送器的位置在 ( x p , y q ) (x_p,y_q) (xp​,yq​) 处。
在这里插入图片描述给定每个位置的状态，计算探测车的最优移动方案，使到达传送器的探测车的数量最多，而且探测车采集到的岩石标本的数量最多。

输入格式
第一行为探测车数 n n n，接下来两行分别为 p , q p,q p,q。

接下来的 q q q 行是表示登陆舱与传送器之间的位置状态的 p × q p \times q p×q网格。
用三种数表示火星表面位置的状态：0 表示平坦无障碍，1 表示障碍，2 表示石块。

输出格式
每行包含探测车号和一个移动方向，0 表示向南移动，1 表示向东移动。

输入输出样例

输入 #1
2
10
8
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 1 0 0 0
0 0 0 1 0 2 0 0 0 0
1 1 0 1 2 0 0 0 0 1
0 1 0 0 2 0 1 1 0 0
0 1 0 1 0 0 1 1 0 0
0 1 2 0 0 0 0 1 0 0
0 0 0 0 0 0 0 0 0 0
输出 #1
1 1
1 1
1 1
1 1
1 0
1 0
1 1
1 1
1 1
1 1
1 0
1 0
1 1
1 0
1 0
1 0
2 1
2 1
2 1
2 1
2 0
2 0
2 0
2 0
2 1
2 0
2 0
2 1
2 0
2 1
2 1
2 1
数据范围
1 ≤ n , p , q ≤ 35 1 \le n,p,q \le 35 1≤n,p,q≤35

分析
典型的拆点跑费用流
建图思路很简单

1.拆点，两个点连上流量为INF的边，当这个点有岩石时在连一条流量为1费用为1的边，表示岩石只能采集一次但可以多次通过这个点。
2.只能向下和向右走，所以如果能往两边走(另一边不为死路)就连流量为INF费用为0的边
3.（1，1）不是死路就由S流向，（n，n）不是死路就流向T。流量为INF费用为0

建图跑费用流
完结撒花 好像题目不是算最大费用emmmmmm

输出路径的话，首先我们想的话，路径的条数肯定就是最大流。
每个机器人走其中一条路径，那么我们就从1开始遍历到最大流

思考如果机器人走了这条路径，那么路径会有什么变化，首先正向边的流量减少1，反向边的流量就是加上1，然而反向边一开始的流量就是0。
所以如果最大流走的是这一条边的话，那么反向边就不为0，那我们就找反向边权不为0的边走，走过之后让反向边的边权减少1。
然后dfs遍历即可(代码70到91行)
注意点：

1.我们每次都是遍历拆点后的B点。注意点的编号pos
2.如果遍历到S,T和他的A点，边权也不为0，但我们不会在遍历下去，所以直接continue；

这下是真的AC了

AC代码

#include<bits/stdc++.h>
#define pll pair<int,int>
#define pb push_back
#define FAST std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define ll long long
#define INF 1e18
#define inf 0x3f3f3f3f
#define pi acos(-1)
#define debug(x) cout<<x<<endl
//#define ls now<<1
//#define rs now<<1|1
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e7 + 10;
const int N = 5e3 + 10;
int n,m,s,t;
struct node{
	int t,nex;
	ll w,c;
}e[MAXN];
ll ans,cost;
int head[N],cnt=1;
void add(int a,int b,ll c,ll d)
{
	e[++cnt].t=b;e[cnt].nex=head[a];e[cnt].w=c;	e[cnt].c=d;head[a]=cnt;
	e[++cnt].t=a;e[cnt].nex=head[b];e[cnt].w=0;e[cnt].c=-d;head[b]=cnt;
}
ll st[N];
int pre[N];
bool vs[N];
bool spfa() 
{
	queue<int>q;
	for(int i=0;i<=t;i++)
	{
		vs[i]=0;st[i]=-INF;pre[i]=-1;
	}
	q.push(s);st[s]=0;vs[s]=1;
	while(!q.empty())
	{
		int u=q.front();q.pop();vs[u]=0;
		for(int i=head[u];i!=-1;i=e[i].nex)
		{
			int v=e[i].t;
			if(st[v]<st[u]+e[i].c&&e[i].w)
			{
				st[v]=st[u]+e[i].c;pre[v]=i;
				if(!vs[v]){vs[v]=1;q.push(v);}
			}
		}
	}
	if(st[t]==-INF)return false;
	ll d=INF;
	for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        d=min(d,e[i].w);
    }
    for(int i=pre[t];i!=-1;i=pre[e[i^1].t]){
        e[i].w-=d;
        e[i^1].w+=d;
        cost+=e[i].c*d;
    }
    ans+=d;
    return true;
}
int get(int i,int j)
{
	return (i-1)*m+j;
}
int ff[40][40];
void dfs(int x,int y,int pos,int k)
{
	for(int i=head[pos];~i;i=e[i].nex)
	{
		int v=e[i].t;
		if(v==s||v==t||v==pos-n*m)continue;
		if(!e[i^1].w)continue;
		e[i^1].w--;
		if((v-1)%m+1==y+1)
		{
			cout<<k<<" "<<1<<endl;
			dfs(x,y+1,v+n*m,k);
			return;
		}
		else
		{
			cout<<k<<" "<<0<<endl;
			dfs(x+1,y,v+n*m,k);
			return;
		}
	}
}
void work() 
{
	memset(head,-1,sizeof(head));
	int k;cin>>k;
	cin>>m>>n;
	int o=n*m;
	s=0;t=n*m*2+1;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>ff[i][j];
			if(ff[i][j]==1)continue;
			add(get(i,j),get(i,j)+o,INF,0);
			if(ff[i][j]==2)add(get(i,j),get(i,j)+o,1,1);
		}
	}
	if(ff[1][1]!=1);add(s,get(1,1),k,0);
	if(ff[n][m]!=1)add(get(n,m)+o,t,INF,0);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(i<n&&ff[i+1][j]!=1)
			{
				add(get(i,j)+o,get(i+1,j),INF,0);
			}
			if(j<m&&ff[i][j+1]!=1)
			{
				add(get(i,j)+o,get(i,j+1),INF,0);
			}
		}
	}
	while(spfa());
	for(int i=1;i<=ans;i++)
	{
		dfs(1,1,1+n*m,i);
	}
}
int main() {
	FAST;
	int t = 1;
	//cin >> t;
	while (t--)work();
	return 0;
}
不会编程的耿鬼
关注
专栏目录
网络流习题集合
Gene_I must wait for the sunrise
10-30 1851
网络流习题 1. 餐巾计划问题 题意: 一共 nnn 天，餐厅每天需要 rir_iri​ 块餐巾。餐厅每天可以花 ppp 购买一块新餐巾；或者花 fff 将脏餐巾送到快洗部，mmm 天后洗好；或者花 sss 将脏餐巾送到慢洗部，nnn 天后洗好，求最小总花费。(1≤n≤2000,ri≤107,p、f、s≤104)(1\leq n\leq 2000,r_i\leq 10^7,p、f、s\leq 10...
网络流习题
Tekim的博客
10-31 282
网络流这东西其实就是建模，对于算法本身需要深度理解它的基础模型，即对货物的来回传递，还要求掌握算法每一步的效果和作用（其实对每一个算法都是如此），我记录博客主要是为了防止自己忘记。 昨天学长出了一道题，1e5对10的二分图，1e5的人分配在10个星球上，实际上加边优化跑dinic可以过，但是有一种更优的算法，因为每个人最多只有2^10种状态，那么可以把人压缩为2^10个点，跑dinic更快。 ...
网络流题集
热门推荐
夏天的风
07-24 1万+
【HDU】 1532 Drainage Ditches(入门)    [最大流] 3549 Flow Problem(入门)    [最大流] 3572 Task Schedule(基础)    [最大流]任务分配,判断满流 2732 Leapin' Lizards(较难)    [最大流] 3338 Kakuro Extension(较难，好题)    [最大流][数和]神奇最大流行进
网络流刷题总结（基础题）
weixin_30408739的博客
09-27 172
用网络流解题，其实就是把问题抽象成水流去思考。 1，sap算法比dinic算法求最大流快很多，当点数超过1000时，需采用sap算法。 2，建双向边时，只需把反向边的的容量0改为c 题目一：有F种食物D种饮料，每种食物或饮料只能分配给一头牛。最多能有多少头牛可以同时得到喜欢的食物和饮料。 建图 : 食物连源点，饮料连汇点，牛在中间，并且把牛拆成两个点，中间连一条容量为1的边...
POJ 1273 网络流基础题
09-08 319
Drainage Ditches Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 70082 Accepted: 27205 DescriptionEvery time it rains on Farmer John’s fields, a pond forms over Bessie’s favor
网络流入门习题
weixin_43145397的博客
10-30 235
文章目录最大流模型二分图问题[1. 飞行员配对方案问题](https://www.acwing.com/problem/content/2177/) 最大流模型 二分图问题 习题1是普通二分图，也可以用匈牙利算法做，但是匈牙利算法复杂度略高； 习题2是多重匹配二分图，直接上最大流。 普通二分图和多重匹配二分图的区别： 普通二分图：S到左边的容量是1，如图1所示。通过这些容量为1的边限制左边到右边只能流0或1条边。 多重匹配二分图：S到左边的容量是a[i]，如图2所示。这些容量为a[i]的边限制从i流到右边的
网络流基础
~
08-13 211
网络流基础 网络流的相关定义： 源点：有n个点，有m条有向边，有一个点很特殊，只出不进，叫做源点。 汇点：另一个点也很特殊，只进不出，叫做汇点。 容量和流量：每条有向边上有两个量，容量和流量，从i到j的容量通常用c[i,j]表示,流量则通常是f[i,j]. 通常可以把这些边想象成道路，流量就是这条道路的车流量，容量就是道路可承受的最大的车流量。很显然的，流量<=容量。而对于每个不是源...
2022年计算机网络基础知识试题及答案.doc
11-19
计算机网络基础知识是IT领域不可或...以上就是从试题中提炼出的计算机网络基础知识，这些知识点对于理解网络原理、网络设备以及网络通信机制至关重要。学习这些内容有助于提升在网络设计、管理、故障排查等方面的能力。
计算机网络应用基础习题带答案.docx
06-05
本题涉及的知识点主要涵盖计算机网络的层次结构、网络体系、网络协议和服务、网络类型以及传输层协议的功能。 1. 网络的体系结构：网络层次结构模型和各层协议定义了网络的体系结构，如OSI七层模型或TCP/IP四层模型...
计算机网络基础试题.pdf
10-04
【计算机网络基础试题解析】 计算机网络是信息技术领域的重要组成部分，主要涉及将分布在不同地理位置的计算机设备通过通信线路连接，实现信息交换和资源共享的系统。在本试题中，主要考察了以下几个核心概念： 1....
计算机网络基础知识试题及答案(事业单位考试必看) (2).docx
03-13
【计算机网络基础知识试题及答案解析】 1. 快速以太网的介质访问控制方法是CSMA/CD（载波监听多路访问/冲突检测），这意味着在网络中，多个设备通过监听信道是否空闲来决定是否发送数据，如果发生冲突，则会退避重...
一些网络流的题目
Vampire
10-25 1986
bzoj1433假期的宿舍：裸的二分图。 bzoj1412狼和羊的故事：从源点向狼和从羊向汇点连inf的边，再从狼向羊和空格，从空格向空格和羊连1的边，跑最小割就好了。 bzoj1066蜥蜴：很容易可以想到需要拆点。将a拆成a1和a2，从源点向a1(开始时有蜥蜴的各子)连1的边，再从a1向a2连a的高度的边，从a2向b1(a2与b1的距离小于等于d)连a的高度的边，再从a2向汇点连高度的边，跑最
网络流24题QAQ（思路+代码，简单易懂~）
weixin_43945141的博客
12-06 1247
顺序 问题名称 问题模型 转化模型 1 飞行员配对方案问题 二分图最大匹配 网络最大流 2 太空飞行计划问题 最大权闭合图 网络最小割 3 最小路径覆盖问题 有向无环图最小路径覆盖 网络最大流 4 魔术球问题 有向无环图最小路径覆盖 网络最大流 5 圆桌问题 二分图多重匹配 网络最大流 6 最长递增子序列问题 最多不相交路径 网络最大流 7 试题库问题 二分图多重匹配 网络最大流 8 机器人路径规划问题 (未解决) 最小费用最大流 9 方格取数问题 二分图点权...
网络流24题（持续更新）和一些好题
m0_53688600的博客
08-12 1595
记录下网络流的学习，以及自己的一些理解 1.DAG最小路径覆盖 题目大意：DAG求最小路径覆盖，输出方案 思路：将n个点看成单独n条路径，接下来拆点，将每个点放在入点出点两个集合中，如果有边x->y，则x出指向y入，初始化时候所有点出点连源点，入点连汇点，最小路径数 = 总路径n - 最大流，最大流就是我们去匹配出入点的最大边数，实质就是匈牙利算法啊 建图示意 ，图中只有1->3一条路径可以从原始n条路径中拼接起来，即3-1=2，最小路径数，我们发现，连向汇点的点如果不和源点联.
网络流题目集锦
hqd_acm的专栏
09-06 1710
红色为已经做了：最大流 POJ 1273 Drainage Ditches POJ 1274 The Perfect Stall (二分图匹配) POJ 1698 Alice's Chance POJ 1459 Power Network POJ 2112 Optimal Milking (二分) POJ 2455 Secret Milking Machine (二分) POJ 3189 Steady Cow Assignment (枚举) POJ 1637 Sightseeing tour (混合图欧拉回
图论 —— 网络流
Alex_McAvoy的博客
04-06 3294
【概述】 网络流是一个适用范围极广的模型，相关的算法也很多，大体分为最大流、最小割、费用流三类。 对于网络流类型的题来说，一般根据题意，分析后建出图后，套用相关模版，即可解决问题。 关于网络流的基本概念与建模技巧：点击这里 【算法】 1.最大流算法 求最大流算法分为两类，一种是增广路算法，一种是预留推进算法。 增广路算法，常用的有时间复杂度 O(n*m*m) 的 FF 算法、EK 算...
各种函数声明和定义模块
最新发布
09-16
各种函数声明和定义模块
网络安全基础试题与解析
"网络管理2012试题包含关于网络安全的多项选择题，涉及信息安全基本属性、会话攻击类型、攻击可能性分析、网络攻击分类、防范黑客技术等多个方面。" 网络安全是信息技术领域的一个核心组成部分，它关注的是保护数据...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值