bool WorstBalancedPathEdge::findPairOfBalancedPaths(Graph g,int source,int target)
{
// cout<<" source "<<source<<" target "<<target<<endl;
vector< vector<int> > pairOfPaths;
vector<pair<int,int>> distance;
vector<int> path;
int sum = g.getNumberOfNodes()+1;//somatório dos caminhos mínimos encontrados pelo algoritmo
int diff = sum+1; //iniciando com número infinito
int a = 0, b = 0, m = 0, p = 0, w = 0, z = 0, c = 0;
vector<vector<int>> pairTemp;
int limit = 2; //inicia limit com dois nós para tamanho máximo do caminho, ou seja, com 1 hop
int diameterGraph = g.getNumberOfNodes();
while(limit <= diameterGraph && c <= 1)
{
pairOfPaths = findAllPaths(distance,g,source,target,limit);
if ( (int) pairOfPaths.size() <= 1 )
{
limit++;
distance.clear();
pairOfPaths.clear();
continue;
}
sortDatas(distance);//ordena vetor de pares
sum = g.getNumberOfNodes()+1;//somatório dos caminhos mínimos encontrados pelo algoritmo
diff = sum+1; //iniciando com número infinito
a = 0, b = 0, m = 0, p = 0;
unsigned int n = distance.size();
for (unsigned int i = 0; i < n-1; i++)
{
if ( ( a != b) && (m != p) )
{
if ((int)pairOfPaths[a].size() > (int)pairOfPaths[b].size())
{
n = m;
}
else
{
n = p;
}
}
/**
* Encontrou um caminho de par disjuntos
* E pelo menos um dos caminhos é menor que o novo
*/
for (unsigned int j = i+1; j < n; j++)
{
int u = distance[i].first;
int v = distance[j].first;
if (pairOfPaths[u][1] == pairOfPaths[v][1])
{
continue;
}
if (pairOfPaths[u][(int)pairOfPaths[u].size()-2] == pairOfPaths[v][(int)pairOfPaths[v].size()-2])
{
continue;
}
vector< vector<int> > paths = compareWithOthers(g,pairOfPaths[u],pairOfPaths[v]);
if ((int)paths.size() <= 0)
{
continue;
}
int newDiff = abs( (int)paths[0].size() - (int)paths[1].size() );
int s = (int)( (double)paths[0].size() + (double)paths[1].size() )/2;
if ( s > sum && (a != b) )
{
break;
}
else if ( s < sum )
{
a = u;
b = v;
diff = newDiff;
sum = s;
m = i; p = j;
}
else if (s == sum)
{
if (newDiff > diff)
{
a = u;
b = v;
diff = newDiff;
sum = s;
m = i; p = j;
}
}
}
}
//encontrou dois nós
if (a != b )
{
w = a, z = b;
if ((int)pairTemp.size() >= 2)
{
pairTemp.clear();
}
pairTemp.push_back(pairOfPaths[a]);
pairTemp.push_back(pairOfPaths[b]);
diameterGraph = (int)pairTemp[0].size()+(int)pairTemp[1].size();
c++;
}
distance.clear();
pairOfPaths.clear();
limit++;
}
if (w == z)
{
return false;
}
vector< vector<int> > paths = compareWithOthers(g,pairTemp[0],pairTemp[1]);
printPaths(paths[0],paths[1], g);
paths[0].clear();paths[1].clear();paths.clear();
distance.clear();
pairOfPaths.clear();
return true;
}
void Search::Run(const Inputs &inputs) {
for(Inputs::const_iterator ngi = inputs.begin(); ngi!=inputs.end(); ++ngi) {
node_iter ni;
for(ni = nodes().begin(); ni!=nodes().end(); ++ni)
if(gd<Name>(*ni)==ngi->first) {
StrGraph &dest = gd<SearchStage>(*ni).result;
dest = *ngi->second;
break;
}
/*
if(ni==nodes().end())
throw StageNotFound(ngi->first);
*/
}
while(1) {
Node *stage = 0;
// find a stage for which all prereq stages are done
for(node_iter ni = nodes().begin(); ni!=nodes().end(); ++ni) {
if(gd<SearchStage>(*ni).done)
continue;
inedge_iter ei;
for(ei = (*ni)->ins().begin(); ei!=(*ni)->ins().end(); ++ei)
if(!gd<SearchStage>((*ei)->tail).done)
break;
if(ei==(*ni)->ins().end()) {
stage = *ni;
break;
}
}
if(!stage)
break;
SearchStage &earchage = gd<SearchStage>(stage);
Search::inedge_iter ei = stage->ins().begin();
if(ei!=stage->ins().end())
switch(earchage.type) {
case UnionInquiry:
earchage.result = gd<SearchStage>((*ei)->tail).result;
for(; ei!=stage->ins().end(); ++ei)
earchage.result |= gd<SearchStage>((*ei)->tail).result;
break;
case IntersectionInquiry:
earchage.result = gd<SearchStage>((*ei)->tail).result;
for(; ei!=stage->ins().end(); ++ei)
earchage.result &= gd<SearchStage>((*ei)->tail).result;
break;
case PatternInquiry: {
if(!earchage.pattern)
throw PatternNotThere();
earchage.result.clear();
queue<Match> Q;
PathsFollowed followed;
for(; ei!=stage->ins().end(); ++ei) {
Name inputname = gd<Name>(*ei);
Pattern::node_iter ni;
for(ni = earchage.pattern->nodes().begin();
ni!=earchage.pattern->nodes().end(); ++ni)
if(gd<Name>(*ni)==inputname) {
StrGraph &input = gd<SearchStage>((*ei)->tail).result;
for(StrGraph::node_iter inpi = input.nodes().begin(); inpi !=input.nodes().end(); ++inpi) {
earchage.result.insert(*inpi);
Q.push(Match(*ni,source.find(*inpi)));
}
break;
}
if(ni==earchage.pattern->nodes().end())
throw PatternStateNotFound(inputname);
}
runPattern(Q,followed,earchage.limit,&earchage.result);
break;
}
case PathInquiry: {
earchage.result.clear();
StrGraph *a = 0, *b = 0;
for(; ei!=stage->ins().end(); ++ei) {
DString inputname = gd<Name>(*ei);
if(inputname=="a")
a = &gd<SearchStage>((*ei)->tail).result;
else if(inputname=="b")
b = &gd<SearchStage>((*ei)->tail).result;
}
if(a&&b)
if(earchage.shortest)
findShortestPaths(source,*a,*b,earchage.weightattr,earchage.limit,earchage.result);
else
findAllPaths(source,*a,*b,earchage.goOut,earchage.goIn,earchage.firstOnly,earchage.limit,earchage.result);
}
}
earchage.done = true;
}
}
