private Site updateUseSite() {
if (TRACE_USE_SITES) {
Site here = new Site();
useSites.add(here);
return here;
} else if (TRACE_SINGLE_USE_SITE) {
if (multipleUseSites) {
return null;
} else {
Site here = new Site();
if (singleUseSite == null) {
singleUseSite = here;
} else {
if (!here.equals(singleUseSite)) {
multipleUseSites = true;
singleUseSite = null;
}
}
return here;
}
} else {
return null;
}
}
/**
* Implements a bidirectional breadth-first search to find the shortest path between Sites from
* and to. Currently not completely implemented. More detailed notes in the code for the method.
* If it worked it would be quadratic (O(n^2)), but would still be a bit faster than a non-bidi
* search.
*
* @param from Starting position
* @param to Ending position
* @return Stack of Sites containing the shortest path in order to be taken.
*/
public Stack<Site> bidiShortestSiteStack(Site from, Site to) {
boolean fFound = false, tFound = false;
Site fConnectSite = null, tConnectSite = null;
Queue<Site[]> fTemp = new LinkedList<Site[]>(), tTemp = new LinkedList<Site[]>();
ArrayList<Site> fromList = new ArrayList<Site>(), toList = new ArrayList<Site>();
Stack<Site[]> fMoves = new Stack<Site[]>(), tMoves = new Stack<Site[]>();
Stack<Site> moves = new Stack<Site>();
graph.mark(from);
for (Site site : graph.neighbors(from)) {
if (site.equals(to)) {}
fTemp.add(new Site[] {from, site});
graph.mark(site);
fromList.add(site);
}
graph.mark(to);
for (Site site : graph.neighbors(to)) {
tTemp.add(new Site[] {to, site});
if (graph.isMarked(site) && fromList.contains(site)) {
tFound = true;
break;
}
toList.add(site);
graph.mark(site);
}
if (tFound) {
moves.add(to);
return moves;
}
bigBreak:
while (!fTemp.isEmpty() && !tTemp.isEmpty()) {
Site[] fSites = fTemp.poll();
fMoves.push(fSites);
Site[] tSites = tTemp.poll();
tMoves.push(tSites);
for (Site site : graph.neighbors(fSites[1])) {
fTemp.add(new Site[] {fSites[1], site});
if (graph.isMarked(site) && toList.contains(site)) {
fromList.add(site);
fConnectSite = site;
fFound = true;
break bigBreak;
} else graph.mark(site);
}
for (Site site : graph.neighbors(tSites[1])) {
tTemp.add(new Site[] {tSites[1], site}); // I chose to put them in the same way.
// While this does make it a bit more difficult to code, the consistency makes it less
// confusing.
if (graph.isMarked(site) && fromList.contains(site)) {
toList.add(site);
tConnectSite = site;
tFound = true;
break bigBreak;
} else graph.mark(site);
}
}
if (fFound) {
Stack<Site> fTempMoves = pathFromStack(from, fMoves);
Site[] sites = null;
while (!tMoves.isEmpty()) {
sites = tMoves.pop();
if (sites[1].equals(fConnectSite)) break;
}
fMoves.push(sites);
Stack<Site> tTempMoves = pathFromStack(to, tMoves);
// need to combine them
} else if (tFound) {
Stack<Site> tTempMoves = pathFromStack(to, tMoves);
Site[] sites = null;
while (!fMoves.isEmpty()) {
sites = fMoves.pop();
if (sites[1].equals(tConnectSite)) break;
}
tMoves.push(sites);
Stack<Site> fTempMoves = pathFromStack(from, fMoves);
// need to combine them
}
return moves;
}