网络流

最大流：

最大流是网络流的一种，他表示从起始点s出发，引出无穷的流量，每条边上允许通过一个最大的流量，求最终能够到达目的地的最大流量是多少。

由于还是在图上进行操作，因此最大流的求解方法依然是基于dfs或者bfs的做法。故网络流比较耗费时间，常常所需要的点数不能够过大，大概在1k左右。

最大流的一般方法：

1.Ford_Fulkerson算法

从源点s开始，不断进行dfs遍历，寻找到一条能够走到t的道路，记录这条道路上的最小边的值，将这条路上所有道路的cap减去该值，并将这些道路rev道路上的的cap加上对应值。

每次dfs返回这个最小值，用一个大大的while循环去不断进行dfs，在dfs的参数中保存当前所在结点，目的结点，以及能够到达当前节点的流量的最小值。

目的结点用于判定dfs结束，当前所在结点用于dfs向下遍历，采用used数组存储已经访问的点。

复杂度：o(F|E|)；F表示最大流量

struct edge
{
    int to;
    int cap;
    int rev;
    edge(){}
    edge(int a,int b,int c)
    {
        to=a;cap=b;rev=c;
    }
};

vector<edge> g[maxn];
bool used[maxn];

//单向流通!!!!
void add_edge(int f,int t,int c)
{
    g[f].push_back(edge(t,c,g[t].size()));
    g[t].push_back(edge(f,0,g[f].size()-1));
}

int dfs(int v,int t,int f)
{
    if(v==t)
        return f;
    used[v]=true;

    int len=g[v].size();
    for(int i=0;i<len;i++)
    {
        edge &e=g[v][i];
        if(used[e.to]==false && e.cap>0)
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap=e.cap-d;
                g[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow(int s,int t)
{
    int flow=0;
    while(true)
    {
        memset(used,0,sizeof(used));
        int f=dfs(s,t,inf);
        if(f==0)
            break;
        flow=flow+f;
    }
    return flow;
}

 

2.dinic算法：

一种比较优秀的基于bfs与dfs结合的网络流最大流算法，常常作为模版算法

复杂度：o(|E|V^2)；

struct edge
{
    int to;
    int cap;
    int rev;
    edge(){}
    edge(int a,int b,int c){to=a;cap=b;rev=c;}
};

vector<edge> g[maxn];
int level[maxn];  //顶点到原点的距离编号
int iter[maxn];   //当前弧，在其之前的都没用了

//单向流通!!!!
void add_edge(int f,int t,int c)
{
    g[f].push_back(edge(t,c,g[t].size()));
    g[t].push_back(edge(f,0,g[f].size()-1));
}

//先用bfs为每一个有价值的点计算到s点距离标号
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int> que;
    while(!que.empty())
        que.pop();

    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        int len=g[u].size();
        for(int i=0;i<len;i++)
        {
            edge &e=g[u][i];
            if(e.cap>0 && level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v,int t,int f)
{
    if(v==t)
        return f;

    int len=g[v].size();
    for(int &i=iter[v];i<len;i++) //当前弧优化的方法，一种思想
    {
        edge &e=g[v][i];
        if(e.cap>0 && level[v]<level[e.to])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0)
            {
                e.cap=e.cap-d;
                g[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

int maxflow(int s,int t)
{
    int flow=0;
    while(true)
    {
        bfs(s);
        if(level[t]<0)
            break;

        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0 )
            flow=flow+f;
    }
    return flow;
}

 

优化技巧

缩点：

在实际情况中，我们常常会遇到一些问题，使得有的点的规模比较大，比如｛a1，a2....an｝与｛b1,b2......bn｝相互连接形成的二分图中，我们发现a的规模达到了极其高，b的规模很小只有10左右。

我们就发现这样一个事实，对于两个不同的ai和aj来说，他们连接到b的方式很可能完全相同(一定要相同才行)，我们将其完全独立进行流量算法的时候会计算两次，但是如果我们将他们合并成一个点，对应边上流量通过量求和，我们就可以将点缩成一个点。因此可以极大的减少运算的复杂度。

对b的处理采用二进制位处理进行判断和连接对应边