void findMSF(graph &g, graph &sf, int start)
// finds a minimum spanning tree in graph 'g'
{
priority_queue<edge, vector<edge>, CompareEdge> pq;
vector<int> lst = getNeighbors(start, g);
// build our priority queue
for (int i = 0; i < lst.size(); i++)
{
pq.push(g.getEdge(start, lst[i]));
g.mark(start, lst[i]);
}
// visit the start node
g.visit(start);
int src, dst, w;
edge top;
while (!pq.empty())
{
top = pq.top();
pq.pop();
src = top.getSource();
dst = top.getDest();
w = top.getWeight();
// add edges
if (!sf.isEdge(src, dst))
{
sf.addEdge(src, dst, w);
sf.addEdge(dst, src, w);
// delete edges if we make a cycle
if (isCyclic(sf))
{
sf.removeEdge(src, dst);
sf.removeEdge(dst, src);
}
else
{
g.visit(src);
lst = getNeighbors(dst, g);
for (int i = 0; i < lst.size(); i++)
{
if (!g.isMarked(dst, lst[i]))
{
pq.push(g.getEdge(dst, lst[i]));
g.mark(dst, lst[i]);
}
} // for
} // else
} // if
} // while
} // findMSF
vector<stack<int> > nonRecursiveDFS(int startId, int dstId, graph &g )
// implement a version of Depth First Search that uses a stack data structure
// and does not use recursion returns all paths
{
vector< stack<int> > paths;
stack<int> st;
stack<edge> edges;
st.push(startId);
stack<int> path;
while (!st.empty())
{
int top = st.top();
//check if before we had gone into a sink and remove from path
while (!edges.empty() && path.top() != edges.top().getSource())
{
path.pop();
}
path.push(top);
if (!edges.empty())
{
edges.pop();
}
st.pop();
g.visit(top);
if (top == dstId)
{
paths.push_back(path);
}
vector<int> lst = getNeighbors(top, g);
for (int i = 0; i < lst.size(); i++)
{
if (!g.isVisited(lst[i]))
{
st.push(lst[i]);
edges.push(g.getEdge(top, lst[i]));
}
}
}
return paths;
}
