洛谷 P4015 运输问题 题解

本文深入解析费用流算法在解决货物运输问题中的应用。针对供需平衡场景,介绍如何建立模型,连接源点、仓库、商店及汇点,实现最小成本的货物配送方案。通过具体代码实现,展示算法细节。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目链接

题目大意

W W W 公司有 m m m 个仓库和 n n n 个零售商店。第 i i i 个仓库有 a i a_i ai​ 个单位的货物;第 j j j 个零售商店需要 b j b_j bj 个单位的货物。

货物供需平衡.

从第 i i i 个仓库运送每单位货物到第 j j j 个零售商店的费用为 c i j c_{ij} cij​​ 。

试设计一个将仓库中所有货物运送到零售商店的运输方案,使总运输费用最少。

题解

费用流模板题。

建源点和汇点连边。

源点向每个仓库 i i i连边,流量为仓库 i i i的货物数量,费用为 0 0 0.
每个商店 j j j向汇点连边,流量为商店 j j j的需求量,费用为 0 0 0.

以上两种边的目的都是限制流量,同时因为货物供需平衡,最后一定能全部满足。

最后每个仓库 i i i向商店 j j j连边,流量为 i n f inf inf,费用为 c i j c_{ij} cij. 如果这种边通过流量,那么就说明仓库 i i i运送了货物到商店 j j j.

最后跑费用流就好了。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

const int maxn=105;
const int maxm=1000005;
const int inf=0x7f7f7f7f;
const long long linf=1e18;

struct node
{
	int to,next,flow;
	long long cost;
} edge[maxm<<1];

bool vis[maxn<<2];
int head[maxn<<2],k,s,t;
long long dist[maxn<<2],tot_cost;

void add(int u,int v,int w,long long c)
{
	edge[++k].to=v;
	edge[k].next=head[u];
	head[u]=k;
	edge[k].flow=w;
	edge[k].cost=c;
	swap(u,v);
	edge[++k].to=v;
	edge[k].next=head[u];
	head[u]=k;
	edge[k].flow=0;
	edge[k].cost=-c;
}
bool spfa()
{
	for(int i=0;i<=t;i++) dist[i]=linf;
	memset(vis,false,sizeof(vis));
	queue<int> q;dist[t]=0;q.push(t);
	while(!q.empty())
	{
		int x=q.front();q.pop();vis[x]=false;
		for(int i=head[x];i;i=edge[i].next)
		{
			if(dist[edge[i].to]>dist[x]-edge[i].cost&&edge[i^1].flow)
			{
				dist[edge[i].to]=dist[x]-edge[i].cost;
				if(!vis[edge[i].to])
				{
					vis[edge[i].to]=true;
					q.push(edge[i].to);
				}
			}
		}
	}
	return dist[s]!=linf;
}
int dfs(int x,int f)
{
	vis[x]=true;
	if(x==t||!f) return f;
	int flow=0;
	for(int i=head[x];i;i=edge[i].next)
	{
		if(vis[edge[i].to]) continue;
		if(dist[edge[i].to]==dist[x]-edge[i].cost&&edge[i].flow)
		{
			int temp=dfs(edge[i].to,min(f-flow,edge[i].flow));
			edge[i].flow-=temp;
			edge[i^1].flow+=temp;
			flow+=temp;
			tot_cost+=(long long)temp*edge[i].cost;
			if(f==flow) break;
		}
	}
	return flow;
}
void zkw()
{
	tot_cost=0;
	while(spfa())
	{
		vis[t]=true;
		while(vis[t])
		{
			memset(vis,false,sizeof(vis));
			dfs(s,inf);
		}
	}
	if(tot_cost>=0) printf("%lld\n",tot_cost);
	else printf("%lld\n",-tot_cost);
}
int n,m,a[maxn],b[maxn],cost[maxn][maxn];

int main()
{
	#ifdef lemon
	freopen("4015.txt","r",stdin);
	#endif
	scanf("%d%d",&m,&n);s=0;t=m+n+1;k=1;
	for(int i=1;i<=m;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n;i++) scanf("%d",&b[i]);
	//1-n store
	//n+1-m repo
	//0 source
	//n+m+1
	for(int i=1;i<=m;i++)
		for(int j=1;j<=n;j++)
			scanf("%d",&cost[i][j]);
	for(int i=1;i<=n;i++) add(i,t,b[i],0);
	for(int i=1;i<=m;i++) add(s,i+n,a[i],0);
	for(int i=1;i<=m;i++)
		for(int j=1;j<=n;j++)
			add(i+n,j,inf,cost[i][j]);
	zkw();
	memset(head,0,sizeof(head));k=1;
	for(int i=1;i<=n;i++) add(i,t,b[i],0);
	for(int i=1;i<=m;i++) add(s,i+n,a[i],0);
	for(int i=1;i<=m;i++)
		for(int j=1;j<=n;j++)
			add(i+n,j,inf,-cost[i][j]);
	zkw();
	return 0;
}
<think>好的,我现在需要帮用户解决P1656炸铁路的问题。用户想要题解、代码、解析思路。首先,我应该回顾一下题目内容。根据引用[2],题目可能涉及铁路被炸的情况,用户提供的示例代码中有结构体存储铁路的起点、终点状态,可能是在处理图的连通性问题。 用户提供的引用[2]中有一段代码,看起来像是在处理输入的铁路数据,每条铁路初始状态为未被炸(w=1)。这可能意味着问题需要找出关键边,也就是炸掉后会影响图的连通性的边。这类问题通常可以通过Tarjan算法求桥来解决,因为桥是图中的边,移除后会导致图不再连通。 接下来,我需要确认P1656的具体要求。根据常见的算法题,炸铁路很可能就是寻找无向图中的所有桥。桥的定义是,如果删除这条边,图会被分成两个或多个连通块。Tarjan算法可以在O(V+E)的时间内找到所有桥,这应该是解题的关键。 然后,我需要考虑如何构建图结构。通常,使用邻接表来存储图,每个节点有一个列表记录其连接的边。在实现Tarjan算法时,需要记录每个节点的发现时间low值,用于判断是否为桥。 接下来,代码实现部分需要包括以下步骤: 1. 读取输入,构建邻接表。 2. 使用Tarjan算法遍历所有节点,找出所有桥。 3. 将找到的桥按题目要求的顺序输出,通常是按端点升序排列,如果端点相同则按另一端升序。 在引用[3]中提到拓扑排序用于车站分级问题,但这里的问题不同,可能需要不同的方法。因此,引用[3][1]可能不适用,但引用[2]中的代码结构可能帮助理解输入处理。 用户可能需要详细的步骤解释,比如如何应用Tarjan算法,如何处理输入输出,以及如何排序结果。此外,需要确保代码正确,符合题目的要求,比如边的输出顺序。 最后,验证思路是否正确。例如,Tarjan算法确实用于找桥,而题目要求找出所有这样的边,因此这个方法是合适的。然后,编写代码时需要注意无向图的处理,避免重复访问同一条边,通常通过记录父节点来实现。 总结思路:使用Tarjan算法寻找无向图中的所有桥,并按规则排序输出。</think>### P1656 炸铁路 题解 #### 题目分析 题目要求找到所有「关键铁路」,即删除该铁路后会导致图的连通性被破坏的边。这类问题对应图论中的**桥(割边)**问题,可以通过**Tarjan算法**高效解决[^5]。 #### 算法思路 1. **桥的定义**:无向图中若删除边 $(u,v)$ 后图不再连通,则该边为桥。 2. **Tarjan算法**:通过DFS遍历图,记录每个顶点的访问顺序(`dfn`)能回溯到的最早祖先(`low`)。若对于边 $(u,v)$,满足 `low[v] > dfn[u]`,则说明 $(u,v)$ 是桥[^5]。 #### 代码实现 ```cpp #include <iostream> #include <vector> #include <algorithm> #include <cstring> using namespace std; const int MAXN = 155; vector<int> graph[MAXN]; vector<pair<int, int>> bridges; int dfn[MAXN], low[MAXN], parent[MAXN]; int timer = 0; void tarjan(int u) { dfn[u] = low[u] = ++timer; for (int v : graph[u]) { if (!dfn[v]) { parent[v] = u; tarjan(v); low[u] = min(low[u], low[v]); if (low[v] > dfn[u]) { // 找到桥 bridges.push_back({min(u, v), max(u, v)}); } } else if (v != parent[u]) { low[u] = min(low[u], dfn[v]); } } } int main() { int n, m; cin >> n >> m; for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); } for (int i = 1; i <= n; ++i) { if (!dfn[i]) { tarjan(i); } } sort(bridges.begin(), bridges.end()); for (auto &bridge : bridges) { cout << bridge.first << " " << bridge.second << endl; } return 0; } ``` #### 代码解析 1. **输入处理**:构建无向图的邻接表。 2. **Tarjan核心**:DFS遍历时维护`dfn``low`数组,判断桥的条件。 3. **结果排序**:将桥按字典序排序后输出,满足题目要求[^2]。 #### 复杂度分析 - 时间复杂度:$O(N + M)$,其中 $N$ 为顶点数,$M$ 为边数。 - 空间复杂度:$O(N + M)$,用于存储图结构中间数据。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值