Dinic模板

hhhh赛前自己写了一个版本的模板,也不知道效率咋样,但是亲手写出来的意义不同!嗯!

 

#include<bits/stdc++.h>
using namespace std;
#define INF (1e18)
typedef long long ll;
const ll maxn=205,maxm=50205;
ll n,m,S,T,sum,cnt;
ll l[maxm],head[maxn];//注意l是maxm
struct node{
    ll to,ne,w;
}e[maxm];
void add(ll u,ll v,ll w){
    e[cnt]=(node){v,head[u],w};head[u]=cnt++;
    e[cnt]=(node){u,head[v],0};head[v]=cnt++;
}
queue<ll>q;
ll d[maxn],cur[maxn];
ll bfs(){
    while(!q.empty()) q.pop();
    memset(d,0,sizeof(d));
    memcpy(cur,head,sizeof(head));
    d[S]=1;q.push(S);
    while(!q.empty()){
        ll u=q.front();q.pop();
        if(u==T) break;
        for(ll i=head[u];~i;i=e[i].ne){
            ll v=e[i].to;
            if(!e[i].w) continue;
            if(!d[v]) d[v]=d[u]+1,q.push(v);
        }
    }
    return d[T];
}
ll dfs(ll u,ll remain){
    if(u==T) return remain;
    ll use=0;
    for(ll &i=cur[u];~i;i=e[i].ne){
        ll v=e[i].to;
        if(e[i].w&&remain&&d[v]==d[u]+1){
            ll flow=dfs(v,min(remain-use,e[i].w));
            if(!flow) continue;
            use+=flow;e[i].w-=flow;e[i^1].w+=flow;
            if(use==remain) break;
        }
    }
    if(!use) d[u]=-1;
    return use;
}
ll dinic(){
    ll ans=0,tmp;
    while(bfs()){
        while(tmp=dfs(S,INF))   ans+=tmp;
    }
    return ans;
}
void getmap(){}
int main(){
    while(~scanf("%lld%lld",&n,&m)){
        cnt=0;
        memset(head,-1,sizeof(head));
        S=n+1;T=S+1;
        getmap();
        ll ans=dinic();
    }
    return 0;
}

 

  • 1
    点赞
  • 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、付费专栏及课程。

余额充值