POJ 3204 Ikki's Story I - Road Reconstruction 网络流初步 Dinic

POJ 3204 Ikki’s Story I - Road Reconstruction

网络流初步，理解Dinic

这题的价值大概就是稍微理解一下Dinic。。

传送门：POJ

---

题意

一个网络流，其中有一类边是你对这条边扩容后，网络流的总流量会变大。问你这种边有多少。

---

思路

• 注意Dinic算法分BFS与DFS两块，其中BFS就是普通的BFS，构造层次图，那个d数组存的就是到源点的最小距离，就是层次图。vis有两个作用，vis==1表示这个节点访问过，也表示源点到这个节点的流可以增广。

• DFS还是没太看懂，不过DFS的功能就是：之前BFS返回汇点的vis值，如果是1表示可以增广，DFS就是沿层次图增广的过程。

• 说回这题，扩容的边一定是满流的边，所以先跑网络流，在遍历边，满流就扩流1，在BFS，如果返回1就说明这条边扩容是有用的。

---

代码

//Dinic
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <cstdlib>
#include <stack>
using namespace std;

const int MAXN=100007;
const int oo=0x3f3f3f3f;
typedef long long LL;
struct Edge{
    int from,to,cap,flow;//cap容量 flow流量
    Edge(){}
    Edge(int u,int v,int c,int f){ from=u;to=v;cap=c;flow=f; }
}e[MAXN];

int m;
vector<Edge> edges;//顺序的插入边
vector<int> G[MAXN];//保存边号
bool vis[MAXN];//BFS使用
int d[MAXN];
int cur[MAXN];

void init(int n)
{
    for(int i=0;i<n;i++) G[i].clear();
    edges.clear();
}

void AddEdge(int from,int to,int cap)
{
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));//单向边第三个参数写0，双向边写cap
    m=edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}

bool BFS(int s,int t)
{
    memset(vis,0,sizeof(vis));
    queue<int> Q;
    Q.push(s);
    d[s]=0;
    vis[s]=1;
    while(!Q.empty())
    {
        int x=Q.front();Q.pop();
        for(int i=0;i<G[x].size();i++)
        {
            Edge& e=edges[G[x][i]];
            if(!vis[e.to]&&e.cap>e.flow)//残量网络
            {
                vis[e.to]=1;
                d[e.to]=d[x]+1;
                Q.push(e.to);
            }
        }
    }
    return vis[t];
}
int DFS(int x,int a,int s,int t)
{
    if(x==t||a==0) return a;
    int flow=0,f;
    for(int& i=cur[x];i<G[x].size();i++)
    {
        Edge& e=edges[G[x][i]];
        if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow),s,t))>0)
        {
            e.flow+=f;
            edges[G[x][i]^1].flow-=f;
            flow+=f;
            a-=f;
            if(a==0) break;
        }
    }
    return flow;
}
int Maxflow(int s,int t)
{
    int flow=0;
    while(BFS(s,t))
    {
        memset(cur,0,sizeof(cur));
        flow+=DFS(s,oo,s,t);
    }
    return flow;
}


int main()
{
    int n,m_m;
    scanf("%d%d",&n,&m_m);
    init(n);
    for(int i=0;i<m_m;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        AddEdge(a,b,c);
    }
    int maxf=Maxflow(0,n-1);
    int res=0;
    for(int i=0;i<m;i++)
    {
        if(edges[i].cap==edges[i].flow&&edges[i].cap!=0)
        {
            edges[i].cap++;
            if(BFS(0,n-1)) res++;
            edges[i].cap--;
        }
    }
    printf("%d\n",res);
    return 0;
}