最大流问题预流推进算法(邻接表relabel_to_front)

/*
  Name: 最大流问题预流推进算法
  Copyright: 
  Author: 巧若拙 
  Date: 14-06-17 09:26
  Description: 改进的预流推进算法，有如下优化：
  进行了预先逆序BFS分层，
  利用结点链表，每次都是从高度最大的结点开始处理.
  利用指向各顶点的边表结点的指针，记录已经访问到该顶点的第几条边了，
  下次推进时可直接从该条边操作，不用从第一条边开始一路找过来。 
*/
#include<iostream>    
#include <fstream>  
    
using namespace std;   

typedef struct EdgeNode{ //边表结点
    int adjvex;  //邻接点域，存储该顶点对应的下标
    int weight; //权值，对于非网图可以不需要
    struct EdgeNode *next; //链域，指向下一个邻接点
} EdgeNode;

typedef struct VertexNode{ //顶点表结点
    int data; //顶点域，存储顶点信息
	EdgeNode *firstEdge; //边表头指针
} VertexNode;

typedef struct VertexNodeLink{ //结点链表 
    int num;  //存储该顶点对应的下标
    struct VertexNodeLink *next; //链域，指向下一个结点
} VertexNodeLink;
    
const int MAXV=2000;   //最大顶点数量     
const int MAXE=2000;   //最大边数量    
const int INFINITY = 0x7fffffff;   //无穷大     
VertexNode GL[MAXV]; //存储顶点表结点信息 
EdgeNode * EdgeNodePoint[MAXV]; //存储指向各顶点的边表结点的指针 
int flow[MAXV];  //标记当前节点的剩余流量     
int dis[MAXV]; //标记节点所在的层次  
VertexNodeLink *head; //结点链表头结点 
    
int MaxFlow_relabel_to_front(int src, int des, int n) ;    
bool BFS(int src, int des, int n); //广度优先搜索构造分层网络   
void Check(int u); //对顶点u进行预流推进或重新标号操作，直到其剩余流量为0  
void AddFlow(int u, int v, int w); //增加残流网络边<u,v>的容量 
void PrintGraph(int n);//输出图
    
int main()    
{   
    int  m, n, u, v, w;   
    ifstream fcin("maxflow.txt");  
    
    for (int i=0; i<MAXV; i++)//初始化图 
    {
	 	GL[i].data = i;
        GL[i].firstEdge = NULL;
    }
      
    if (!fcin.is_open())  
    {  
        cout << "Error opening file"; exit (1);  
    }  
    
    fcin >> n >> m;  
     
   	EdgeNode *e; 
    for(int i=0; i<m; ++i)    
    {    
        fcin >> u >> v >> w;    
	 	e = new EdgeNode;; //采用头插法插入边表结点
		if (!e)
		{
			puts("Error");
			exit(1);
		}
		e->adjvex = v;
		e->weight = w;
		e->next = GL[u].firstEdge;
 		GL[u].firstEdge = e;    
 		
 		//为了构造残流网络，还要生成一条逆向边，根据weight的值确定该边是否存在
	    e = new EdgeNode;; //采用头插法插入边表结点
		if (!e)
		{
			puts("Error");
			exit(1);
		}
		e->adjvex = u;
		e->weight = 0;
		e->next = GL[v].firstEdge;
 		GL[v].firstEdge = e; 	  
    }    
    
    PrintGraph(n);   
        
    cout << MaxFlow_relabel_to_front(0, n-1, n) << endl;   
    
    system("pause");                       
    return 0;    
}  

void PrintGraph(int n)//输出图
{
    int i, j;
    EdgeNode *e;
    
    for (i=0; i<n; i++)
    {
        printf("G[%d] = %d: ", i, i);
        for(e=GL[i].firstEdge; e!=NULL; e=e->next) 
        {
		    printf("->%d,%d", e->adjvex, e->weight);
        }  
        printf("\n");
    }
    printf("\n");
} 

void Check(int u) //对顶点u进行预流推进或重新标号操作，直到其剩余流量为0 
{
    int minFlow, minLevel, v;
    EdgeNode *e;
    
    while (flow[u] > 0)
    {
 	    e = EdgeNodePoint[u]; 
 	    if (e == NULL)//没有可以push的顶点,执行relabel  
 	    {   
            minLevel = INFINITY; 
 	        for (e=GL[u].firstEdge; e!=NULL; e=e->next) 
 	        {
 	            if (e->weight > 0 && minLevel > dis[e->adjvex]) //寻找下一层节点  
                {
		            minLevel = dis[e->adjvex];
                } 
            }
            dis[u] = minLevel + 1;
            EdgeNodePoint[u] = GL[u].firstEdge;
            printf("relabel %d height to %d\n", u, dis[u]); 
        }  
        else if (dis[u] == dis[e->adjvex]+1 && e->weight > 0) //寻找可行弧，并预流推进 
        {
            minFlow = (flow[u] < e->weight) ? flow[u] : e->weight;	   
            flow[u] -= minFlow;  
            flow[e->adjvex] += minFlow;  
			e->weight -= minFlow;  
			AddFlow(e->adjvex, u, minFlow);
			printf("push %d --%d--> %d, e[%d] = %d\n", u, minFlow, e->adjvex, u, flow[u]);  
		}
		else //处理下一条边 
		{
		 	EdgeNodePoint[u] = e->next;
		}
    }
}  

void AddFlow(int u, int v, int w) //增加残流网络边<u,v>的容量 
{
    EdgeNode *e; 
    for (e=GL[u].firstEdge; e!=NULL; e=e->next) //将源点的流量推进到邻接点 
    {
	 	if (e->adjvex == v)
	 	{
	        e->weight += w;
	        break;
	    }
	}
}
    
int MaxFlow_relabel_to_front(int src, int des, int n)    
{           
    int u, v, oldLevel, minFlow; 
	VertexNodeLink *p = head;
	EdgeNode *e; 
      
    if (BFS(src, des, n))//先逆向构造分层网络 
    {   
        dis[src] = n;  //直接设置源点的高度为n
	    for (e=GL[src].firstEdge; e!=NULL; e=e->next) //将源点的流量推进到邻接点 
		{  
	        if (e->weight > 0) //更新结点剩余流量和残流网络 
			{  
	            flow[src] -= e->weight;  
	            flow[e->adjvex] = e->weight;   
	            AddFlow(e->adjvex, src, e->weight);
	            e->weight = 0; 
	        }  
	    }   
	    
	    VertexNodeLink *pre = head;   
	    while (pre->next)
	    {
	 	    u = pre->next->num;
		 	oldLevel = dis[u];
		 	Check(u);
		 	
		 	if (oldLevel < dis[u])//层高增加了，插入到链表首部
			{
	 	        p = pre->next;
	 	        pre->next = p->next; //删除结点p 
	 	        p->next = head->next;//将结点p插入到头结点后面 
	 	        head->next = p;
	 	        pre = head;
			} 
			
			pre = pre->next; //查看下一个结点
		} 
    }
    
    p = head->next;
    while (p)
    {
	     delete head;
	     head = p;
	     p = head->next;
    }
    
    return flow[des];    
}    

bool BFS(int src, int des, int n)//逆向广度优先搜索构造分层网络，若不存在增广路，则返回false    
{    
    EdgeNode *e; 
    int Queue[MAXV];   //求最短增广路算法需要用到的队列 
    int v, front = 0, rear = 0; //清空队列     
        
    for(int i=0; i<n; ++i) //初始化列表     
    {    
        dis[i] = 0;  
        EdgeNodePoint[i] = GL[i].firstEdge; //初始化指向各顶点的边表结点的指针 
    }    
    //汇点加入队列   
    Queue[rear++] = des;    
        
    while (front < rear) //队列非空    
    {    
        v = Queue[front++];   
        for(e=GL[v].firstEdge; e!=NULL; e=e->next)//寻找逆向边，并设置层数 
        {    
            if (e->weight == 0 && dis[e->adjvex] == 0) //是一条逆向边
            {    
                dis[e->adjvex] = dis[v] + 1; 
                Queue[rear++] = e->adjvex;    
            }    
        }      
    }   
    
    if (dis[src] == 0) //未找到源点，说明不存在流
    {
        return false;
    }
    
    VertexNodeLink *s;
    head = new VertexNodeLink;
    head->next = NULL;
    for (front = 1; front < rear; front++)//使用头插法将结点按高度顺序插入链表 
    {
	 	if (Queue[front] != src)
	 	{ 				 
		 	s = new VertexNodeLink;
		 	s->num = Queue[front];  
		 	s->next = head->next;
		 	head->next = s;   
		}
	}  
           
    return true; 
}