网络流——最大流-Dinic算法

#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAX_V= 510;
const int MAX_E= 60000;
const int INF= 0x3f3f3f3f;
struct ENode
{
    int to;
    int c;  //容量;
    int Next;
};
ENode edegs[MAX_E];
int Head[MAX_V], tnt;
void Add_ENode(int a, int b, int c)
{
    /**建边*/
    edegs[++ tnt].to= b;
    edegs[tnt].c= c;
    edegs[tnt].Next= Head[a];
    Head[a]= tnt;
    edegs[++ tnt].to= a;
    edegs[tnt].c= 0;
    edegs[tnt].Next= Head[b];
    Head[b]= tnt;
}
void into()
{
    /**初始化*/
    memset(Head, -1, sizeof(Head));
    tnt= -1;
}

int level[MAX_V];
bool bfs_level (int s, int t)
{
    memset(level, -1, sizeof(level)); //所有点的等级初始化为-1;
    level[s]= 1; //源点的等级为1;
    int que[MAX_V];  //队列que：按序保存已搜索到的点;
    int iq= 0;
    que[iq ++]= s; //先将源点s 加入队列;
    for (int i= 0; i< iq; i ++)
    {
        int u= que[i];  //取出队首元素;
        if (u== t)
        {
            /*找到汇点t,返回*/
            return true;
        }
        for (int k= Head[u]; k!= -1; k= edegs[k].Next)
        {
            /*遍历，查找到之前未找到的、可抵达的点便加入队列*/
            int v= edegs[k].to;
            if (-1== level[v]&& edegs[k].c)
            {
                level[v]= level[u]+ 1;  //深度 +1;
                que[iq ++]= v;
            }
        }
    }
    return false;
}
int dfs(int now, int c_max, int t)
{
    /**DFS 实现多路增广*/
    /*now：起点；c_max：从源点s到节点now的最大流量；t：汇点、dfs结束的终点*/
    if (now== t) return c_max;  //当now== t时，c_max便是要求的最大流;
    int ret= 0, f;
    for (int k= Head[now]; k!= -1; k= edegs[k].Next)
    {
        if (edegs[k].c&& level[edegs[k] .to]== level[now]+ 1)
        {
            /**/
            f= dfs(edegs[k].to, min(c_max- ret, edegs[k].c), t);
            edegs[k].c-= f;
            edegs[k^1].c+= f;
            ret+= f;
            if(ret== c_max) return ret;
        }
    }
    return ret;
}
int dinic(int s, int t)
{
    int ans= 0;
    while(bfs_level(s, t))
    {
        ans+= dfs(s, INF, t);
    }
    return ans;
}

int main()
{
    /*建图（记得into()初始化）*/
    int answer= dinic(s, t);
    /*输出结果*/
    return 0;
}

#include<algorithm>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
const int maxv= 510;
const int maxe= 60000;
const int INF= 0x3f3f3f3f;
struct ENode
{
    int to;
    int c;  //容量;
    int Next;
};
ENode edegs[maxe];
int Head[maxv], tnt;
void Add_ENode(int a, int b, int c)
{
    /**建边*/
    edegs[++ tnt].to= b;
    edegs[tnt].c= c;
    edegs[tnt].Next= Head[a];
    Head[a]= tnt;
    edegs[++ tnt].to= a;
    edegs[tnt].c= 0;
    edegs[tnt].Next= Head[b];
    Head[b]= tnt;
}
void into()
{
    /**初始化*/
    memset(Head, -1, sizeof(Head));
    tnt= -1;
}

int level[maxv];
bool bfs_level(int s, int t)
{
    memset(level, 0, sizeof level);  //所有点的等级初始化为-1;
    level[s] = 1;  //源点的等级为1;
    queue<int> q;  //队列que：按序保存已搜索到的点;
    q.push(s);  //先将源点s 加入队列;

    while (!q.empty())
    {
        int u = q.front();  //取出队首元素;
        q.pop();
        for (int k = Head[u]; k!= -1; k = edegs[k].Next)
        {
            /*遍历，查找到之前未找到的、可抵达的点便加入队列*/
            int v = edegs[k].to;
            if (level[v] || ! edegs[k].c) continue;
            level[v] = level[u] + 1;  //深度 +1;
            q.push(v);
        }
    }
    return level[t];
}

int dfs(int now, int c_max, int t)
{
    /**DFS 实现多路增广*/
    /*now：起点；c_max：从源点s到节点now的最大流量；t：汇点、dfs结束的终点*/
    if (now == t) return c_max;  //当now== t时，c_max便是要求的最大流;
    int ret = 0;
    for (int k = Head[now]; c_max && k!= -1; k = edegs[k].Next)
    {
        int v = edegs[k].to;
        if (level[v]== level[now]+ 1&& edegs[k].c)
        {
            int f = dfs(v, min(c_max, edegs[k].c), t);
            edegs[k].c-= f;
            edegs[k^ 1].c+= f;
            ret+= f;
            c_max-= f;
        }
    }
    if (!ret) level[now] = 0;
    return ret;
}
int dinic(int s, int t)
{
    int ret = 0;
    while (bfs_level(s, t))
    {
        ret += dfs(s, INF, t);
    }
    return ret;
}

int main()
{
    /*建图（记得into()初始化）*/
    int answer= dinic(s, t);
    /*输出结果*/
    return 0;
}