LibreOJ #6000. 「网络流 24 题」搭配飞行员

二次联通门 : LibreOJ #6000. 「网络流 24 题」搭配飞行员

/*
    LibreOJ #6000. 「网络流 24 题」搭配飞行员

    二分图最大匹配
    Dinic最大流 + 当前弧优化

*/
#include <cstring>
#include <cstdio>
#include <queue>

#define Max 10000
#define INF 1e5

int read (int &now)
{
    now = ;
    register char word = getchar ();
    while (word < '' || word > '')
        word = getchar ();
    while (word >= '' && word <= '')
    {
        now = now *  + word - '';
        word = getchar ();
    }
    if (now >= )
        return ;
}

inline int min (int a, int b)
{
    return a < b ? a : b;
}

class Net_Flow_Type
{

    private :

        int __to[Max << ], __next[Max << ];

        int __flow[Max << ];

        int edge_list[Max];
        int Edge_Count;

        int deep[Max], __tech_[Max];
        int T;

        int Answer;

    public :

        Net_Flow_Type ()
        {
            Edge_Count = ;
        }

        inline void Insert_edge (int from, int to)
        {
            Edge_Count ++;

            __to[Edge_Count] = to;
            __next[Edge_Count] = edge_list[from];
            edge_list[from] = Edge_Count;

            Edge_Count ++;

            __to[Edge_Count] = from;
            __next[Edge_Count] = edge_list[to];
            edge_list[to] = Edge_Count;

            __flow[Edge_Count - ] = ;
            __flow[Edge_Count] = ;
        }

        bool Bfs (int Start, int End)
        {
            std :: queue <int> Queue;

            Queue.push (Start);
            memset (deep, -, sizeof deep);

            int now;
            for (deep[Start] = ; !Queue.empty (); Queue.pop ())
            {
                now = Queue.front ();

                for (int i = edge_list[now]; i; i = __next[i])
                    if (__flow[i] && deep[__to[i]] == -)
                    {
                        deep[__to[i]] = deep[now] + ;
                        if (__to[i] == End)
                            return true;
                        Queue.push (__to[i]);
                    }
            } 

            return deep[End] != -;
        }

        int Flowing (int now, int flow)
        {
            if (now == T || flow <= )
                return flow;

            int res = , pos = ;
            for (int i = __tech_[now]; i; i = __next[i])
            {
                if (deep[__to[i]] != deep[now] +  || __flow[i] <= )
                    continue;
                res = Flowing (__to[i], min (flow, __flow[i]));

                if (res > )
                {
                    flow -= res;
                    pos += res;

                    __flow[i] -= res;
                    __flow[i ^ ] += res;
                    if (__flow[i])
                        __tech_[now] = i;

                    if (flow == )
                        return pos;
                }
            }
            return pos;
        }

        int Dinic (int Start, int End)
        {
            for (T = End; Bfs (Start, End); )
            {
                memcpy (__tech_, edge_list, sizeof edge_list);

                Answer += Flowing (Start, INF);
            }

            return Answer;
        }

};

int N, M;
Net_Flow_Type Make;

int main (int argc, char *argv[])
{
    read (N);
    read (M);

    int S = N + , T = N + ;

    for (int i = ; i <= M; i ++)
        Make.Insert_edge (S, i);

    for (int i = M + ; i <= N; i ++)
        Make.Insert_edge (i, T);

    for (int x, y; scanf ("%d %d", &x, &y) == ; Make.Insert_edge (x, y));

    printf ("%d", Make.Dinic (S, T));

    return ;
}