网络最大流量问题（数据结构实验三）

#include "stdafx.h"
#include <algorithm>

#include <iostream>

#include <string>
#include<list>
# define maxnum 6//图的结点个数

using namespace std;

class elge;

class elge
{
public:
int start;
int target;
int flow;
operator =(elge x)
{
start=x.start;
flow=x.flow;
target=x.target;
}

};

class point
{
public:

list<elge> adjacent;//邻接表
int num;//序号

 

 

public:
// ~point(void);
};

class path
{
public:
list<elge> p;
int flow;
int onpath(int g)
{
list<elge>::iterator iter3;

for (iter3=p.begin();iter3!=p.end();iter3++)

{
if( (*iter3).target==g)

return 1;

 

 

}
return 0;
}

};

class pathlist
{
public:
list<path> r;
};

 

int main(int argc, char* argv[])
{

pathlist search;//查找过程中用的

pathlist result;//最终结果

int count=0;

point pp[maxnum];

 

list<point> qq[maxnum];//固定为6个点
//图的初始化完成，以下形成邻接表
for (int t=0; t<maxnum; t++)
{//**
int flow;
int w=100000;
cout<<t<<"号节点的邻接表(节点号和边的流量)"<<endl;
while(w!=99)
{//****
cin>> w;

 

if (w!=99)//输入99此队结束

 

{
cin >> flow;
elge * ll;
ll=new elge ;
ll->start=t;
ll->target=w;
ll->flow=flow;
pp[t].adjacent.push_back(*ll);

}

}//****

}//**

 

int haspath=0;
//下面开始查找路径

 

 

do///
{
haspath=0;
search.r.clear();
while(!search.r.empty())
search.r.erase(search.r.begin());//clear search list

 

elge e;

list<elge>::iterator iter4;

for (iter4=pp[0].adjacent.begin();iter4!=pp[0].adjacent.end();iter4++)

{

e=(*iter4);

path y;
y.p.push_back(e);

search.r.push_back(y);

}
if( search.r.empty())
{
cout<<"empty path"<<endl;
break;
}

do//
{
e= search.r.front().p.back(); //first path 's last elge
path hh= search.r.front();
search.r.pop_front();
cout<<hh.p.front().flow<<endl;

 

// find
if(e.target==maxnum-1)
{
haspath=1;

//
int min=10000;
list<elge>::iterator iter ,iter2;

for (iter=hh.p.begin();iter!=hh.p.end();iter++)

{
if( (*iter).flow<min)
{
min=(*iter).flow;

}

}

//确认路径
hh.flow=min;
cout<<min<<endl;
result.r.push_back(hh);
for (iter=hh.p.begin();iter!=hh.p.end();iter++)
{
//修改或者删除边
int i;
for (i=0;i<maxnum;i++)
for (iter2=pp[i].adjacent.begin();iter2!=(pp[i].adjacent.end());iter2++)
{
if ((*iter2).start==(*iter).start&&(*iter2).target==(*iter).target&&(*iter2).flow-min!=0)
(*iter2).flow=(*iter).flow-min ;

if ((*iter2).start==(*iter).start&&(*iter2).target==(*iter).target&&(*iter2).flow-min==0)
{
pp[i].adjacent.erase(iter2);
break;
}

}

//补偿反向边
elge dd;
dd.start=(*iter).target;
dd.target=(*iter).start;
dd.flow=min;
pp[(*iter).target].adjacent.push_back(dd);

}

 

 

 

break;

}//if

 

 

 

//find
//延长路径
//对于每条路径先删除，然后补上所有与为节点相邻的点构成新路径，再补回到
//search中

list<elge>::iterator iter;
//for
for (iter=pp[e.target].adjacent.begin();iter!=pp[e.target].adjacent.end();iter++)

{
//all extended path add into search

if (!hh.onpath((*iter).target))
{hh.p.push_back(*iter);

search.r.push_back(hh);
cout<<hh.flow<<"ext"<<endl;
hh.p.pop_back();}

}

}while (!search.r.empty());//

 

}while(haspath);///

list<path>::iterator ii;

for (ii=result.r.begin();ii!=result.r.end();ii++)
{
getchar();
cout<<(*ii).flow<<"*************"<<endl;//打印各路径流量
}
getchar();

 

return 0;
}