最高标号预留与推进算法 --- 就是要比 Dinic 快!

//Program HighestLablePreflowPush;HLPP

// 较快的网络流算法

//最高标号预留与推进算法

//记录d值，然后优先处理d值较高的，直至没有盈余。

// poj1459 Power Network

#include<cstdio>

#include<iostream>

#include<queue>

#include<algorithm>

#define maxn 105

#define max  210

using namespace std;

 

typedef struct node

{

     int num;

     int a[maxn];

}node;

 

int n,s,t,maxflow;

int map[maxn][maxn];        //边容量矩阵

int edge[maxn][maxn];       //邻接矩阵

int cur[maxn],d[maxn],e[maxn];

struct node list[2*maxn-1];

int flag;

 

void pagheuristic();

void insert(int level,int x)//加入标号为level的节点x

{    int num;

     list[level].num++;

     num = list[level].num;

     list[level].a[num] = x;

}

void BFS()//精确计算距离标号dijkstra 建层次表

{

     int p,q;int x[maxn];int i;

     fill(d,d+maxn,max);

     x[1] = t; d[t] = 0; q = 1; p = 0;

     while(p<q)

     {

         p++;

         for(i = 1; i <= edge[x[p]][0]; i++)

              if(d[ edge[x[p]][i] ] == max){

                   q++;

                   x[q] = edge[x[p]][i];

                   d[x[q]] = d[x[p]] + 1;

                   if(x[q] != s) insert(d[x[q]],x[q]);

              }

     }

     d[s] = n;

}

void push(int a,int b)

{

     int x;

     if(map[a][b] > e[a]) x = e[a];

     else x = map[a][b];

     map[a][b] -= x;

     map[b][a] += x;

     e[a] -= x;

     e[b] += x;

}

void relabel(int a)

{

     int i,min = max;

     for(i = 1; i <= edge[a][0]; i++)

         if(map[a][edge[a][i]] > 0 && d[edge[a][i]] < min)

              min = d[edge[a][i]];

     d[a] = min + 1;

     if(flag++ % n == 0) pagheuristic(); //此处加优化

}

bool check(int a)//discharge

{    bool chk = false;

     while(e[a] > 0)

     {

         if(cur[a] > edge[a][0]){

              relabel(a); chk = true; cur[a] = 1;

         }

         else if(map[a][ edge[a][cur[a]] ] > 0 && d[a] == d[ edge[a][cur[a]] ] + 1)

              push(a,edge[a][cur[a]]);//j = edge[a][cur[a]] -> b是a第j 个邻接点

         else cur[a]++;

     }

     return chk;

}

void update(int level)//将所有标号在level上的点抛上九天,会不会就是pagheuristic

{

     int j,k;

     for(j = level+1; j <= n; j++){

         for(k = 1; k <= list[j].num; k++){

              list[n+1].a[list[n+1].num + k] = list[j].a[k];

              d[list[j].a[k]] = n+1;

         }

         list[n+1].num += list[j].num;

         list[j].num = 0;

     }

}

void HLPP()

{   

     int i,b,level;

     fill(e,e+maxn,0);

     for(i = 1; i <= edge[s][0]; i++){//将所有s出发的弧充满

         b = edge[s][i];

         e[b] = map[s][b];

         e[s] -= map[s][b];

         map[b][s] = e[b];

         map[s][b] = 0;

     }

     level = n;flag = 0;

     while(level)

     {

         level--;

         for(i = list[level].num; i >= 1; i--){

              int a = list[level].a[i]; int num = list[level].num;

              if(check(a)){                                                //如果有被重标记

                   if(level > 0 &&  list[level].num == 1) update(level);//免除把余流送回S的操作,该层只剩下一个点将要断层才可update，因为在层次图中如果断层，则断层上的顶点有留流，它必流回S，这时不用再计算，把它上放到n+1 层上去

                   insert(d[a],a);                                                 

                   list[level].a[i] = list[level].a[num];                  //有标记过则排除该点，把后面没标记的移到前面来

                   list[level].num--;

                   level = d[a];                                           //level 回升

                   break;                                                       //从新的最高level重新开始

              }

         }

     }

}

int main()

{    void input(int node,int np,int nc,int m);

     void init();

     int node,np,nc,m;

     while(scanf("%d%d%d%d",&node,&np,&nc,&m)==4)

     {

         input(node,np,nc,m);

         init();

         BFS();

         HLPP();

         maxflow = e[t];

         printf("%d/n",maxflow);

     }

     return 0;

}

void init()

{

     int i,j;

     memset(edge,0,sizeof edge);

     for(i = 0; i < n; i++)

         for(j = i+1; j <= n; j++)

              if(map[i][j]||map[j][i]){//建立邻接矩阵

                   edge[i][0]++;

                   edge[j][0]++;

                   edge[i][edge[i][0]] = j;

                   edge[j][edge[j][0]] = i;

              }

     fill(cur,cur+maxn,1);

     for(i = 0; i <= n+1; i++) list[i].num = 0;

}

void input(int node,int np,int nc,int m)//complete map,mark s t n

{    int a,b,cap;int i;

     n = node+1;

     s = 0; t = node+1; maxflow = 0;

     fill(map[0],map[maxn],0);

     for (i = 0 ; i < m  ;i++)

     {

         while(getchar()!='(');

         scanf("%d,%d)%d",&a,&b,&cap);

         map[a+1][b+1] = cap;

     }

     for (i = 0 ; i < np ; i++)

     {

         while(getchar()!='(');

         scanf("%d)%d",&b,&cap);

         map[s][b+1] = cap;

     }

     for (i = 0 ; i < nc ; i++)

     {

         while(getchar()!='(');

         scanf("%d)%d",&b,&cap);

         map[b+1][t] = cap;

     }

}

//距离标号法与重标记与前移算法容易退化，所以加一个优化pagheuristic——若存在某一个k(k<n)，

//没有距离标号为k的点，则可以将标号为k--n的所有点移到标号为n+1，以此来提高效率。

//这个优化在relable时可以使用，为了节省时间，可以选在每k*n次检查一次。

void pagheuristic()

{

     int count[maxn*2];

     int i,j;

     fill(count,count+2*maxn,0);

     for(i = 1; i <= n; i++) count[d[i]]++;

     j = 1;

     while(j < n && count[j] != 0) j++;

     if(j == n) return;

     for(i = 1; i <= n; i++)

         if(i != s && d[i] > j && d[i] <= n)

              d[i] = n+1;

}

 

//http://billylinux.blog.hexun.com/16441424_d.html

//来自以上网址的翻译