DFS - finding Minimum Spanning Tree in a graph - algorithm

Question

l - adiacency list
x - starting vertex
dfst, q - empty array of vertex size
std::list <int> q;
std::vector<bool> visited(cols + 1);
for(int i = 0; i < cols; i++) visited[i] = false;
visited[x] = true;
if(!l[x].empty())
for(std::list<int>::iterator i = l[x].begin(); i != l[x].end(); i++)
{
q.push_back(x); q.push_back(* i);
}
while(!q.empty())
{
y = q.back(); q.pop_back();
x = q.back(); q.pop_back();
if(!visited[y])
{
visited[y] = true;
if(!l[y].empty())
for(std::list<int>::iterator i = l[y].begin(); i != l[y].end(); i++)
{
q.push_back(y); q.push_back(* i);
}
dfst[x].push_back(y);
dfst[y].push_back(x);
}
}
I just can't see why does this give wrong results...I don't know if you are familiar with this algorithm, but if you are, I hope you can see what's wrong here.
EDIT:
Adjacency list is:
1: 2, 3
2: 3
3: 4
4: 3
MST should here be something like:
1: 2, 3
3: 4
But instead it's:
2: 3
3: 2, 4
4: 3
And the current code is: (I used brackets where it was needed):
std::list <int> q;
std::vector<bool> visited(cols + 1);
for(int i = 0; i < cols; i++) visited[i] = false;
visited[x] = true;
if(!l[x].empty())
{
for(std::list<int>::iterator i = l[x].begin(); i != l[x].end(); i++)
{
q.push_back(x); q.push_back(* i);
}
while(!q.empty())
{
y = q.back(); q.pop_back();
x = q.back(); q.pop_back();
if(!visited[y])
{
visited[y] = true;
if(!l[y].empty())
for(std::list<int>::iterator i = l[y].begin(); i != l[y].end(); i++)
{
if(!visited[*i])
{q.push_back(y); q.push_back(* i);}
}
dfst[x].push_back(y);
dfst[y].push_back(x);
}
}
}

Answer 1

I worked through your code, it appears to be correct. However, keep in mind that there are multiple DFS trees if your input tree has a cycle. The tree that you get depends on the order in which you process your vertices. Perhaps your input has a cycle? If so, your code might be processing the nodes in an order different from the order that they are processed in the solution.
For example, take the following adjacency list for an input tree, where nodes are lettered:
a: b,c
b: a,d
c: a,c,e
d: b,c,e
e: c,d
Starting at a, if we look in the adjacency list for the next node based on alphabetical order, we get the following DFS tree:
a: b
b: a,d
c: d,e
d: b,d
e: c
Using your algorithm though, we get the following:
a: c
b: d
c: a,e
d: b,e
e: c,d
If this is happening, perhaps try a recursive approach.
Seeing some sample input and output would help further with ansering this question though, as this may not be your problem.
EDIT: I should clarify that the multiple DFS trees in a graph with a cycle applies where the cycle is bidirectional, such as with an undirected graph. The point is, you might be finding a DFS tree that is also correct, but not the same as the one that has been identified as correct.
EDIT (again): Another issue you may have: your algorithm appears to be for undirected graphs since you have the satements dfst[x].push_back(y); dfst[y].push_back(x);in your code, but your input graph given in your example looks like it's directed. Removing the second statement (dfst[y].push_back(x);) should correct this

Answer 2

Code looks little confusing actually i thought its BFS first..but its DFS
You should check if the node is visited before adding to the stack(back of list)
while(!q.empty())
{
y = q.back(); q.pop_back();
x = q.back(); q.pop_back();
if(!visited[y])
{
visited[y] = true;
if(!l[y].empty())
for(std::list<int>::iterator i = l[y].begin(); i != l[y].end(); i++)
{
if(!visited[*i])
{q.push_back(y); q.push_back(* i);}
}
dfst[x].push_back(y);
dfst[y].push_back(x);
}
}