hdu 1532 最简单的最大流

哥第一次写dinic,参考了一下sphinx的模版。。哥菜,写了两天了。。。不过总算是写出来了~优化中~~注意这个是多重图~~
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<stack>
#include<cstdio>
#include<iomanip>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=222;
int c[maxn][maxn];
int f[maxn][maxn];
bool you[maxn][maxn];
int cen[maxn];
int n,m;
int tx,ty,tc;
vector<int>g[maxn];
queue<int>q;
bool bfs()
{
    memset(cen,-1,sizeof(cen));
    while (!q.empty()) q.pop();
    q.push(1);
    cen[1]=0;   
    int now;
    while(!q.empty()) 
    {
        now=q.front();
        q.pop();
        for(int i=0;i<g[now].size();i++)
        {
            if(you[now][g[now][i]] && cen[g[now][i]] == -1)
            {   
                cen[g[now][i]]= cen[now] + 1;
                q.push(g[now][i]);
            }
        }    
    }  
    return cen[n]!=-1; 
}
int dfs(int flow=inf,int now=1)
{
    if(cen[now] == cen[n] )
    {       
        if(now == n)
        {
            return flow;
        }
        else
        {   
            return 0;
        }
    }
    int temp,sum;
    sum = 0;
    for(int i=0;i<g[now].size();i++)
    {
        if(cen[g[now][i]] - cen[now]  !=1 || !you[now][g[now][i]] || cen[g[now][i]] > cen[n] )
        {
            continue;
        }
        temp = dfs (min(c[now][g[now][i]] - f[now][g[now][i]] , flow) , g[now][i]);        
        f[now][g[now][i]] += temp;
        f[g[now][i]][now] -= temp;
        if(f[now][g[now][i]] == c[now][g[now][i]]) 
        {
            you[now][g[now][i]] = false;
        }            
        you[g[now][i]][now] = true;
        sum += temp;
        flow -= temp;
    }            
    return sum;
}
int dinic()
{
    int ans=0;
    while( bfs() )
    {
        ans+=dfs();    
    }      
    return ans;
}
int main()
{
    while(cin>>m>>n)
    {                           
        memset(c,0,sizeof(c));
        memset(f,0,sizeof(f));
        memset(you,false,sizeof(you));
        for(int i=1;i<=n;i++)
        {   
            g[i].clear();
        }
        for(int i=1;i<=m;i++)
        {
            cin>>tx>>ty>>tc;
            c[tx][ty]+=tc;
            you[tx][ty]=true;
            g[tx].push_back(ty);
            g[ty].push_back(tx);
        }
        cout<<dinic()<<endl;       
    }   
    return 0; 
}

### 关于网络流算法的模板题目 网络流是一种经典的图论算法,主要用于解决最大流、最小割等问题。以下是几个常见的网络流算法模板及其对应的经典题目。 #### 1. 最大流问题 最大流问题是网络流中最基本的问题之一,通常可以通过 **Edmonds-Karp 算法** 或者 **Dinic 算法** 解决。下面是一个简单的 Edmonds-Karp 算法实现: ```python from collections import deque class Edge: def __init__(self, v, flow, rev): self.v = v self.flow = flow self.rev = rev def add_edge(u, v, capacity, graph): edge_u_to_v = Edge(v, capacity, len(graph[v])) edge_v_to_u = Edge(u, 0, len(graph[u])) graph[u].append(edge_u_to_v) graph[v].append(edge_v_to_u) def bfs(s, t, parent, graph): visited = [False] * len(graph) queue = deque([s]) visited[s] = True while queue: u = queue.popleft() for idx, edge in enumerate(graph[u]): if not visited[edge.v] and edge.flow > 0: queue.append(edge.v) visited[edge.v] = True parent[edge.v] = u if edge.v == t: return True return False def edmonds_karp(n, s, t, graph): parent = [-1] * n max_flow = 0 while bfs(s, t, parent, graph): path_flow = float('Inf') v = t while v != s: u = parent[v] path_flow = min(path_flow, graph[u][next(i for i, e in enumerate(graph[u]) if e.v == v)].flow) v = u v = t while v != s: u = parent[v] index = next(i for i, e in enumerate(graph[u]) if e.v == v) graph[u][index].flow -= path_flow graph[v][graph[u][index].rev].flow += path_flow v = u max_flow += path_flow return max_flow ``` 上述代码实现了基于 BFS 的 Edmonds-Karp 算法来求解最大流问题[^4]。 --- #### 2. 最小费用最大流问题 如果需要考虑每条边的成本,则可以使用 **SPFA** 或 **Bellman-Ford** 结合最短路径的思想来计算最小费用的最大流。以下是一个 SPFA 实现的例子: ```python import heapq INF = int(1e9) def spfa_min_cost_max_flow(n, edges, start, end): adj_list = [[] for _ in range(n)] residual_graph = [[None]*n for _ in range(n)] for u, v, cap, cost in edges: adj_list[u].append((v, cap, cost)) adj_list[v].append((u, 0, -cost)) dist = [INF] * n potential = [0] * n prev_node = [-1] * n prev_edge = [-1] * n total_flow = 0 total_cost = 0 while True: pq = [] dist[start] = 0 heapq.heappush(pq, (dist[start], start)) while pq: d, node = heapq.heappop(pq) if d > dist[node]: continue for idx, (neighbor, cap, cost) in enumerate(adj_list[node]): if cap > 0 and dist[neighbor] > dist[node] + cost + potential[node] - potential[neighbor]: dist[neighbor] = dist[node] + cost + potential[node] - potential[neighbor] prev_node[neighbor] = node prev_edge[neighbor] = idx heapq.heappush(pq, (dist[neighbor], neighbor)) if dist[end] == INF: break for i in range(n): potential[i] += dist[i] flow = INF cur = end while cur != start: previous = prev_node[cur] edge_index = prev_edge[cur] flow = min(flow, adj_list[previous][edge_index][1]) cur = previous total_flow += flow total_cost += flow * potential[end] cur = end while cur != start: previous = prev_node[cur] edge_index = prev_edge[cur] adj_list[previous][edge_index] = ( adj_list[previous][edge_index][0], adj_list[previous][edge_index][1] - flow, adj_list[previous][edge_index][2] ) back_edge_index = None for j, (back_neighbor, _, _) in enumerate(adj_list[cur]): if back_neighbor == previous: back_edge_index = j break adj_list[cur][back_edge_index] = ( adj_list[cur][back_edge_index][0], adj_list[cur][back_edge_index][1] + flow, adj_list[cur][back_edge_index][2] ) cur = previous return total_flow, total_cost ``` 该代码通过调整势能函数优化了 SPFA,在处理负权边时更加高效[^5]。 --- #### 3. 经典模板题推荐 以下是几道经典的网络流算法模板题,适合初学者练习: 1. **POJ 1273 Drainage Ditches**: 这是一道典型的 Edmonds-Karp 算法入门题。 2. **HDU 3549 Flow Problem**: 需要使用 Dinic 算法提高效率。 3. **Codeforces Round #XXX Div.2 C**: 涉及到最小费用最大流的应用场景。 4. **LeetCode 787 Cheapest Flights Within K Stops**: 虽然不是纯网络流问题,但可以用类似思路建模。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值