HLPP算法 一种高效的网络最大流算法

 #include <algorithm>
 #include <cstdio>
 #include <cctype>
 #include <queue>
 #define INF 0x3f3f3f3f
 #define MAXN 10010
 #define MAXM 300010
 using namespace std;
 int n, m, s, t, tot = ;
 int beginx[MAXN], endx[MAXM], nxt[MAXM], res[MAXM];
 inline void add_edge(int u, int v, int w)
 {
     nxt[++tot] = beginx[u], beginx[u] = tot, endx[tot] = v, res[tot] = w;
     nxt[++tot] = beginx[v], beginx[v] = tot, endx[tot] = u, res[tot] = ;
 }
 struct PQ
 {
     int x,h;
     PQ(int _x,int _h)
     {
         x = _x, h = _h;
     }
     bool operator <  (const PQ &tar) const
     {
         return h < tar.h;
     }
 };
 int gap[MAXN], d[MAXN], ans[MAXN];
 inline bool push(int x, int y, int ptr)
 {
     int w = min(ans[x], res[ptr]);
     res[ptr] -= w, res[ptr^] += w;
     ans[x] -= w, ans[y] += w;
     return w;
 }
 inline void Gap(int val)
 {
     for (int i = ; i <= n; ++i)
         if(i != s && i != t && val < d[i] && d[i] <= n)
             d[i] = n + ;
 }
 inline int HLPP()
 {
     priority_queue<PQ> pq;
     d[s] = n, ans[s] = INF, pq.push(PQ(s, d[s]));
     int u;
     while(!pq.empty())
     {
         u = pq.top().x, pq.pop();
         if(!ans[u]) continue;
         for(int i = beginx[u], v = endx[i]; i; i = nxt[i], v = endx[i])
             if((u == s || d[u] == d[v] + ) && push(u, v, i) && v != t && v != s)
                 pq.push(PQ(v, d[v]));
         if (u != s && u != t && ans[u])
         {
             if(!(--gap[d[u]])) Gap(d[u]);
             ++gap[++d[u]];
             pq.push(PQ(u, d[u]));
         }
     }
     return ans[t];
 }
 int main()
 {
     scanf("%d%d%d%d",&n,&m,&s,&t);
     for(int i = ; i <= m; i++)
     {
         int u,v,r;
         scanf("%d%d%d",&u,&v,&r);
         add_edge(u, v, r);
     }
     printf("%d", HLPP());
     return ;
 }

HLPP

主程序仅有35行，可能会TLE，需要卡卡常数。

暴露出的问题：

- priority_queue太慢，用pq比普通队列还慢。

- STL效率差到爆炸，明明是需要多次BFS，入队出队次数很多，然而效率低，没办法，卡死了。

 #include <cstdio>
 #include <cctype>
 using namespace std;
 #define MAXN 10005
 #define MAXM 200010
 #define INF 0x3f3f3f3f

 inline char get_char()
 {
     static char buf[], *p1 = buf, *p2 = buf;
     return p1 == p2 && (p2 = (p1 = buf) + fread(buf, , , stdin), p1 == p2) ? EOF : *p1 ++;
 }
 inline int read()
 {
     register int num = ;
     char c;
     while (isspace(c = get_char()));
     while (num = num *  + c - , isdigit(c = get_char()));
     return num;
 }
 inline void upmin(int &a, const int &b)
 {
     if(a > b) a = b;
 }

 int beginx[MAXN], endx[MAXM], nxt[MAXM], res[MAXM];

 struct Q
 {
     int s, t;
     Q()
     {
         s =  , t = ;
     }
     int q[MAXM];
     inline bool empty()
     {
         return s > t;
     }
     inline int front()
     {
         return q[s++];
     }
     inline void push(int tar)
     {
         q[++t] = tar;
     }
 } mession;

 int main()
 {
     register int n = read(), m = read(), s = read(), t = read(), tot = ;
     for(int i = ; i <= m; i++)
     {
         int u = read(), v = read(), c = read();
         nxt[++tot] = beginx[u], beginx[u] = tot, endx[tot] = v, res[tot] = c;
         nxt[++tot] = beginx[v], beginx[v] = tot, endx[tot] = u, res[tot] = ;
     }
     register int ar = s, r = INF, ans = ;
     bool done;
     int d[MAXN], num[MAXN], cur[MAXN], pre[MAXN];
     mession.push(t);
     d[t] = ;
     register int u, v;
     while(!mession.empty())
     {
         u = mession.front();
         num[d[u]]++;
         for(int i = beginx[u]; i; i = nxt[i])
         {
             v = endx[i];
             if(!d[v] && res[i ^ ])
             {
                 d[v] = d[u] + ;
                 mession.push(v);
             }
         }
     }
     for(int i = ; i <= n; i++) cur[i] = beginx[i];
     while(d[s] != n + )
     {
         if(ar == t)
         {
             while(ar != s)
             {
                 res[pre[ar]] -= r, res[pre[ar] ^ ] += r;
                 ar = endx[pre[ar] ^ ];
             }
             ans += r, r = INF;
         }
         done = false;
         for(int &i = cur[ar]; i; i = nxt[i])
         {
             int v = endx[i];
             if(res[i] && d[v] == d[ar] - )
             {
                 done = true, pre[v] = i, ar = v;
                 upmin(r, res[i]);
                 break;
             }
         }
         if(!done)
         {
             register int heig = n + ;
             for(int i = beginx[ar]; i; i = nxt[i])
             {
                 int v = endx[i];
                 if(res[i]) upmin(heig, d[v] + );
             }
             if(--num[d[ar]] == ) break;
             cur[ar] = beginx[ar];
             num[d[ar] = heig]++;
             if(ar != s) ar = endx[pre[ar] ^ ];
         }
     }
     printf("%d", ans);
     return ;
 }