POJ_1273 Drainage Ditches 【网络流】

一、题面

　　Drainage Ditches

二、分析

　　网络流的裸题。

　　1　Edmonds-Karp算法

　　　　求解网络流其实就是一个不断找增广路，然后每次找到一条增广路后更新残余网络的一个过程。

　　　　EK算法主要就是用bfs去找增广路，然后不断更新残余网络得到最终答案。

　　2　Dinic算法

　　　　对于Ford-Fulkerson和Edmonds-Karp算法，求解网络流都是一次次用DFS或者BFS，这其实是很费时的，Dinic相当于就是一次BFS然后DFS求解出多条增广路。

　　3　ISAP

三、AC代码

//Edmonds-Karp
#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;
#define ll long long
const int maxn = 2e2 + 13;
const int INF = 1e8 + 1;
int N, M;
int Flow[maxn]; //找到的最小的容量
int Pre[maxn];  //记录父节点
struct edge
{
    //终点、容量、反边
    int to, cap, rev;
};
int G[maxn][maxn];
void add_edge(int from, int to, int cap)
{
    G[from][to] += cap;
}

int BFS(int s, int t)
{
    memset(Pre, -1, sizeof(Pre));
    queue<int> Q;
    Q.push(s);
    Pre[s] = -1;
    Flow[s] = INF;
    while(!Q.empty())
    {
        int q = Q.front();
        if(q == t)
            break;
        Q.pop();
        for(int i = 1; i <= M; i++)
        {
            if(i != s && G[q][i] > 0 && Pre[i] == -1)
            {
                Pre[i] = q;
                Flow[i] = min(Flow[q], G[q][i]);
                Q.push(i);
            }
        }
    }
    if(Pre[t] == -1)
        return 0;
    else
        return Flow[t];
}

ll EK(int s, int t)
{
    ll ans = 0;
    int f = BFS(s, t);
    while(f)
    {
        ans += f;
        int p = t;
        while(Pre[p] != -1)
        {
            G[Pre[p]][p] -= f;
            G[p][Pre[p]] += f;
            p = Pre[p];
        }
        f = BFS(s, t);
    }
    return ans;
}

int main()
{
    freopen("input.txt", "r", stdin);
    while(scanf("%d%d", &N, &M) != EOF)
    {
        memset(G, 0, sizeof(G));
        int from, to, cap;
        for(int i = 0; i < N; i++)
        {
            scanf("%d%d%d", &from, &to, &cap);
            add_edge(from, to, cap);
        }
        printf("%I64d
", EK(1, M));
    }
    return 0;
}

//Dinic
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;
#define ll long long
#define Min(a,b) ((a)>(b)?(b):(a))
#define Max(a,b) ((a)>(b)?(a):(b))
const int INF = 1e9;
const int maxn = 5e2 + 13;
struct edge
{
    int to, cap, rev;
};
vector<edge> G[maxn];
int N, M;
int level[maxn], iter[maxn];
//iter数组的作用就是记录DFS时该结点已经访问到的邻接点的位置
void add_edge(int from, int to, int cap)
{
    G[from].push_back( (edge){to, cap, G[to].size()});
    G[to].push_back( (edge){from, 0, G[from].size() - 1});
}

void BFS(int s)
{
    memset(level, -1, sizeof(level));
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front();
        que.pop();
        for(int i = 0; i < G[v].size(); i++)
        {
            edge &e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0)
            {
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int DFS(int s, int t, int f)
{
    if(s == t)
        return f;
    for(int &i = iter[s]; i < G[s].size(); i++)
    {
        edge &e = G[s][i];
        if(e.cap > 0 && level[s] < level[e.to])
        {
            int d = DFS(e.to, t, Min(f, e.cap));
            if(d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int Dinic(int s, int t)
{
    int flow = 0;
    while(1)
    {
        BFS(s);
        if(level[t] < 0)
            return flow;
        memset(iter, 0, sizeof(iter));
        int f = DFS(s, t, INF);
        while(f > 0)
        {
            flow += f;
            f = DFS(s, t, INF);
        }
    }
}

int main()
{
    //freopen("input.txt", "r", stdin);
    int from, to, cap;
    while(~scanf("%d%d", &N, &M))
    {
        for(int i = 0; i < N; i++)
        {
            scanf("%d%d%d", &from, &to, &cap);
            add_edge(from, to, cap);
        }
        printf("%d
", Dinic(1, M));
        for(int i = 1; i < M; i++)
        {
            G[i].clear();
        }
    }
    return 0;
}

//ISAP
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;
#define ll long long
#define Min(a,b) ((a)>(b)?(b):(a))
#define Max(a,b) ((a)>(b)?(a):(b))
const int INF = 1e9;
const int maxn = 2e2 + 13;
struct edge{
    int v, w, nxt;
} e[maxn<<1];
int h[maxn], tot, n, m, gap[maxn], last[maxn], d[maxn],que[maxn], ql, qr;
vector<int> inv[maxn];

int read() {
    int x=0,f=1;
    char c=getchar();
    for (;!isdigit(c);c=getchar()) if (c=='-') f=-1;
    for (;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}

void add(int u, int v, int w)
{
    e[++tot] = (edge){v, w, h[u]};
    h[u] = tot;
    e[++tot] = (edge){u, 0, h[v]};
    h[v] = tot;
}

void init(int s, int t)
{
    memset(gap, 0, sizeof(gap));
    memset(d, 0, sizeof(d));
    ++gap[d[t] = 1];
    for(int i = 1; i <= n; i++)
        last[i] = h[i];
    que[ql = qr = 1] =  t;
    while(ql <= qr)
    {
        int x = que[ql++];
        for(int i = h[x], v = e[i].v;i; i = e[i].nxt, v = e[i].v)
        {
            if(!d[v])
            {
                ++gap[d[v] = d[x] + 1];
                que[++qr] = v;
            }
        }
    }
}

int aug(int x, int s, int t, int mi)
{
    if(x == t)
        return mi;
    int flow = 0;
    for(int &i = last[x], v = e[i].v;i;i = e[i].nxt, v = e[i].v)
    {
        if(d[x] == d[v] + 1)
        {
            int tmp = aug(v, s, t, min(mi, e[i].w));
            flow += tmp;
            mi -= tmp;
            e[i].w -= tmp;
            e[i^1].w += tmp;
            if(!mi)
                return flow;
        }
    }
    if(!(--gap[d[x]])) 
        d[s] = n + 1;
    ++gap[++d[x]];
    last[x] = h[x];
    return flow;
}

int maxflow(int s, int t)
{
    init(s, t);
    int ret = aug(s, s, t, INF);
    while(d[s] <= n)
        ret += aug(s, s, t, INF);
    return ret;
}

int main()
{
    freopen("input.txt", "r", stdin);
    while(~scanf("%d%d", &m, &n))
    {
        tot = 1;
        memset(h, 0, sizeof(h));
        for(int i = 1; i <= n; i++)
            inv[i].clear();
        for(int i = 1; i <= m; i++)
        {
            int u = read();
            int v = read();
            int w = read();
            add(u, v, w);
            if(w)
                inv[v].push_back(u);
        }
        int ans = maxflow(1, n);
        printf("%d
", ans);
    }
    return 0;
}