网络流

最大网络流

思路:

不断寻找增广路

#include<bits/stdc++.h>
#define MAX 10000
#define CanToNode Edges[CanTo[Top][i]]
#define Min(a,b) (a)<(b)?(a):(b)
using namespace std;
struct EdgeType{
    int  To, Cap, Flow;     //To能去的点，Cap容量，Flow流量 
};
struct NetworkType{
    int N,M;
    int Layer[MAX+5];   //存层数 
    vector <EdgeType> Edges;            //存下每条边，会发现，所有偶数下标都是存的正向边，奇数下标都是存的反向边 
    vector <int> CanTo[MAX+5];          //存每个点可以走到的边【真正的是存Edges里的下标，因此是采用的邻接表存储【其实应该就是前向星！不过这两个总感觉很神似orz…… 
    //但是为什么要这样存不直接 vector <EdgeType> CanTo[MAX+5]; ?
    //因为这样好定位反向边，因为直接Edges n+1或n-1即是反向边，而直接领接表存不好确定谁是谁的反向边
    /*举例 连边 1 2 10
    则 Edges[0]={2,10}; CanTo[1][0]=0; Edges[1]={1,10} CanTo[2][0]=1; 
    所以1节点的第一条边便是存在Edges的下表为0当中的，调用的时候直接Edges[CanTo[n][i]] 
    并且找0的反向边是1, 1的反向边是0;
    再连边2 3 10 
    Edges[2]={3,10}; CanTo[2][1]=2; Edges[3]={2,10} CanTo[3][0]=3;
    也即 
     */ 
    void AddEdge(int From, int To, int Cap)     //连点 
    {
        Edges.push_back((EdgeType){To,Cap,0});  //正向边，容量为Cap 
        Edges.push_back((EdgeType){From,0,0});      //反向边，容量为0【解释一波要 
        int T=Edges.size();                             //这里为了存CanTo这个数组用 
        CanTo[From].push_back(T-2);                     //正向边，是T-2 
        CanTo[To].push_back(T-1);                       //反向边，是T-1 
    }

    void Test()     //用来测试而已…… 
    {
        for (int i=1; i<=N; i++)
        {
            printf("The Node is:%d  CanTo Many:%d",i,CanTo[i].size());
            for (int j=0; j<CanTo[i].size(); j++) printf("\n%d : To: %d, Flow: %d, Cap: %d, In Array<Edges>'s Top:%d",j,Edges[CanTo[i][j]].To,Edges[CanTo[i][j]].Flow,Edges[CanTo[i][j]].Cap,CanTo[i][j]);
            printf("\n\n");
        }
    } 

    bool Bfs(int S, int E)      //用来分层
    {
        queue <int> Line;
        memset(Layer,0,sizeof(Layer));
        Layer[S]=1;//注意这里必须要赋成1而不能0，因为后面是用!Layer来判断的，所以赋0，起点的层数会被更改 
        Line.push(S);
        while (!Line.empty())       //一直增广直到不能增break 
        {
            int Top=Line.front();
            Line.pop();
            for (int i=0; i<CanTo[Top].size(); i++) if (!Layer[CanToNode.To] && CanToNode.Flow<CanToNode.Cap)   //如果这个节点没有走过并且流量小于容量则可以增广。【这里就可以解释为什么反向边时是减了，因为反向边定义Cap为0，所以通过减来证明可以回流 
            {
                Layer[CanToNode.To]=Layer[Top]+1;
                Line.push(CanToNode.To);
            }       //这里用CanToNode代替了 Edges[CanTo[Top][i]], 简化代码 
        }
        return Layer[E];//这里如果LayerE找到层数，返回真，否则没找到层数即为0，返回0为假 
    } 

    int Dfs(int Top, int MinF, int &E)
    {
        if (Top == E || MinF == 0) return MinF; //如果已经找到终点，或者所能增的流为0，则不用继续找，返回所能增得流
        int Ans=0,Remain;
        for (int i=0; i<CanTo[Top].size(); i++)
        if (Layer[CanToNode.To] == Layer[Top] + 1&& (Remain = Dfs(CanToNode.To,Min(MinF,CanToNode.Cap-CanToNode.Flow),E)) > 0)
        {
            CanToNode.Flow+=Remain;
            Edges[CanTo[Top][i] ^ 1].Flow-=Remain;
            Ans+=Remain; 
            MinF-=Remain;
            if (!MinF) break; 
        }
        return Ans;
    }

    int Dinic(int S, int E)
    {
        int Ans=0;
        while (Bfs(S,E))
        {
            Ans+=Dfs(S,INT_MAX,E);
        }
        return Ans;
    }

    int EK(int S, int E)        //EK 
    {
        queue <int> Line;
        int FlowM[MAX+5],Pre[MAX+5],PreEdge[MAX+5],Ans=0;   //FlowM存所找到的增广路，Pre存所找到的上一个节点下标，而PreEdge则是存路 
        while (1)       //一直增广直到不能增break 
        {
            memset(FlowM,0,sizeof(FlowM));
            FlowM[S]=INT_MAX;   //先赋一个INF初值 
            Pre[S]=0;           //标记回溯更改的终点，即之后回溯更改Edge时用的 
            Line.push(S);
            while (!Line.empty())   //Dfs
            {
                int Top=Line.front();
                Line.pop();
                for (int i=0; i<CanTo[Top].size(); i++) if (!FlowM[CanToNode.To] && CanToNode.Flow<CanToNode.Cap)   //如果这个节点没有走过并且流量小于容量则可以增广。【这里就可以解释为什么反向边时是减了，因为反向边定义Cap为0，所以通过减来证明可以回流 
                {
                    FlowM[CanToNode.To]+=Min(FlowM[Top],CanToNode.Cap-CanToNode.Flow);  //存储这个节点所能增广的值，要与当前节点所能增广与所找到的节点所能增广的大小比较取小 
                    Pre[CanToNode.To]=Top;      //存节点 
                    PreEdge[CanToNode.To]=CanTo[Top][i];        //存增光路的边 
                    Line.push(CanToNode.To);
                }       //这里用CanToNode代替了 Edges[CanTo[Top][i]], 简化代码 
            }
            if (!FlowM[E]) break;   //如果没有找到到终点的路，增广完成 
            Ans+=FlowM[E];      //记录最大流 
            int Top=E;      //从终点，借用Pre和PreEdge来更改值 
            while (Pre[Top])
            {
                Edges[PreEdge[Top]].Flow+=FlowM[E];     
                //int AntiTop=PreEdge[Top]&1?PreEdge[Top]+1:PreEdge[Top]-1; //更改反边的下标，如果是%2==0则是正走的，==1则是反走的，存的是先正走再反走，
                //Edges[AntiTop].Flow-=FlowM[E];
                Edges[PreEdge[Top] ^ 1].Flow-=FlowM[E];     //这里是个位运算基础操作[虽然我也不知道，异或1是用来取代反边的 ，上面注释掉的则是原来所写的方法 
                /*详细给自己讲一下
                1^1=0;0^1=1; 即1异或1相当于-1，0异或1相当于+1 
                1^0=1;0^0=0; 即任何一个数异或0位本身 
                所以一个数n异或1；
                则1(2)=000000001
                  n(2)=101001010[随便打的]
                所以最后一位的前面的所有都是其本身，而最后一位则是相应的+1-1，
                所以 0^1=1,1^1=0;
                2^1=3;3^1=2;
                4^1=5;5^1=4;
                则完美匹配这种存储结构
                */ 
                Top=Pre[Top];
            }
        }
        return Ans;
    }
}Network;
int main()
{
    int Start,End,SR,ER,FR;
    cin >> Network.N >> Network.M >> Start >> End;
    for (int i=1; i<=Network.M; i++)
    {
        cin >> SR >> ER >> FR;
        Network.AddEdge(SR,ER,FR);
    }
    //Network.Test();
    //cout << Network.EK(Start,End) << endl;
    cout << Network.Dinic(Start,End);
}

maye看着脑壳昏先把代码存……【第一次写工程代码orz……
回家再补qwq……