Dinic bzoj1084草地排水

多路增广+当前弧优化

#include <bits/stdc++.h>
#define N 1000010
#define M 8000010
#define INF INT_MAX
using namespace std;
int n,m,s,t,fir[N],nxt[M],to[M],res[M],tot(1),dis[N],q[N],ans,cur[N];

inline int read(){
	int s=0; char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) s=s*10+c-'0',c=getchar();
	return s;
}

inline void add(int u,int v,int w){
	to[++tot]=v; nxt[tot]=fir[u]; fir[u]=tot; res[tot]=w;
	to[++tot]=u; nxt[tot]=fir[v]; fir[v]=tot; res[tot]=0;
}

int dfs(int x,int limit){
	if (x==t || !limit)
		return limit;
	int i,flow,cnt(0);
	for (i=cur[x];i;i=nxt[i])
		if (dis[to[i]]==dis[x]+1 && res[i]){
		flow=dfs(to[i],min(limit-cnt,res[i]));
		cnt+=flow;
		res[i]-=flow,res[i^1]+=flow;
		if (cnt==limit)
			break;
	}
	if (cnt<limit)
		dis[x]=-1;
	cur[x]=i;
	return cnt;
}

bool bfs(int s){
	for (int i=1;i<=n;i++)
		dis[i]=-1; 
	int head(1),tail(1);
	for (dis[s]=1,q[1]=s;head<=tail;head++){
		int x=q[head];
		for (int i=fir[x];i;i=nxt[i])
			if (!~dis[to[i]] && res[i]){
				dis[to[i]]=dis[x]+1;
				if (to[i]==t)
					return 1;
				q[++tail]=to[i];
			}
	}
	return 0;
}

void dinic(){
	ans=0;
	while (bfs(s)){
		for (int i=1;i<=n;i++)
			cur[i]=fir[i];
		ans+=dfs(s,INF);
	}
}

int main(){
	n=read(),m=read(),s=read(),t=read();
	int u,v,w;
	for (int i=1;i<=m;i++){
		u=read(),v=read(),w=read();
		add(u,v,w);
	}
	dinic();
	printf("%d\n",ans);
	return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dinic算法是一种用来解决最大流问题的算法,它的核心思想是构建分层图和阻塞量的概念。通过多次增广路径的查找来找出最大流。 在Python中实现Dinic算法可以参考以下步骤: 1. 首先,需要定义一个图的类,包括节点数和邻接表等属性,用来存储图的结构。 2. 实现图的构建函数,根据边的信息添加邻接表。 3. 基于Dinic算法,需要实现一个辅助函数来在网络中查找增广路径。可以使用广度优先搜索(BFS)或深度优先搜索(DFS)来实现。通过不断搜索增广路径,直到找不到增广路径为止。 4. 实现Dinic算法的主函数,其中包括初始化量和残余网络,以及进行多次增广路径搜索的过程。 5. 在每一次增广路径搜索中,需要更新量和残余网络,并计算每一条边的容量。 6. 最后,需要输出最大流的值。 以下是一种可能的实现方式: ```python class Graph: def __init__(self, nodes): self.nodes = nodes self.adjacency = [[] for _ in range(nodes)] def add_edge(self, u, v, capacity): self.adjacency[u].append([v, capacity, 0, len(self.adjacency[v])]) self.adjacency[v].append([u, 0, 0, len(self.adjacency[u]) - 1]) def bfs(self, start, end): # 使用BFS查找增广路径 level = [-1] * self.nodes level[start] = 0 queue = [start] while queue: current_node = queue.pop(0) for neighbor in self.adjacency[current_node]: if level[neighbor[0]] < 0 and neighbor[1] > neighbor[2]: # 更新节点的层级 level[neighbor[0]] = level[current_node] + 1 queue.append(neighbor[0]) return level[end] >= 0 def dfs(self, current_node, end, flow): # 使用DFS查找增广路径 if current_node == end: return flow while self.adjacency[current_node][current_edge[current_node]][1] <= self.adjacency[current_node][current_edge[current_node]][2]: current_edge[current_node] += 1 for i in range(current_edge[current_node], len(self.adjacency[current_node])): neighbor = self.adjacency[current_node][i] if level[neighbor[0]] == level[current_node] + 1 and neighbor[1] > neighbor[2]: min_flow = min(flow, neighbor[1] - neighbor[2]) temp_flow = self.dfs(neighbor[0], end, min_flow) if temp_flow > 0: neighbor[2] += temp_flow self.adjacency[neighbor[0]][neighbor[3]][2] -= temp_flow return temp_flow return 0 def dinic(self, start, end): level = [0] * self.nodes max_flow = 0 while self.bfs(start, end): current_edge = [0] * self.nodes while True: flow = self.dfs(start, end, float('inf')) if not flow: break max_flow += flow return max_flow g = Graph(4) g.add_edge(0, 1, 3) g.add_edge(0, 2, 2) g.add_edge(1, 2, 2) g.add_edge(1, 3, 1) g.add_edge(2, 3, 3) print("最大流为:", g.dinic(0, 3)) ``` 这个实现中,以一个简单的图作为例子进行了测试。首先,创建一个有4个节点的图,然后添加边和容量。最后,通过调用dinic函数来计算最大流的值,并将结果输出。 希望以上回答对你有所帮助,如果有任何问题需要进一步解答,请随时提问。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值