Depth First Search on Adjacency Matrix - c++

Question

For this program, I am given a set of inputs that I need to store in an adjacency matrix. I've done this, so I have an adjacency matrix Matrix[11][11]. Now, using this matrix, I need to perform a depth first search and return the pi values.
I have the pseudocode for this, so I believe that I need two methods: DFS(graph) and DFS-VISIT(node). However, I'm having trouble actually implementing this. Can I do this using the adjacency matrix directly or do I somehow need to create a graph using the matrix? Any help with actually coding this would be appreciated.
DFS(G)
for each u ∈ V[G] do
color[u] = WHITE
∏[u] = NIL
time = 0
for each u ∈ V[G] do
if color[u] = WHITE then
DFS-VISIT(u)
DFS-VISIT(u)
color[u] = GRAY
time++
d[u] = time
for each v ∈ Adj[u] do
if color[v] = WHITE then
∏[v] = u
DFS-VISIT(v)
color[u] = BLACK
time++
f[u] = time

Answer 1

The pseudo-code you have there seems to assume an adjacency list.
Specifically this code: (indentation corresponding to code blocks assumed)
for each v ∈ Adj[u] do
if color[v] = white then
∏[v] = u
DFS-VISIT(v)
The difference is: with an adjacency matrix, all the vertices are there, and one typically uses 0/1 flags to indicate whether there's an edge between the current and target vertices.
So, you should loop through all vertices for that row in the adjacency matrix, and only do something when the flag is set to 1.
That part of the pseudo-code will look something like:
for v = 1 to n do // assuming 1-indexed
if color[v] = white && AdjMatrix[u][v] == 1 then
∏[v] = u
DFS-VISIT(v)
As far as I can tell, the rest of the psuedo-code should look identical.

Answer 2

Generally it is preferred to code DFS assuming graph to be represented as an adjacency list because the time complexity that results is O(|V| + |E|). But with adjacency matrix the time complexity becomes O(|V|*|V|). Below is an implementation of dfs assuming adjacency matrix representation:
#define WHITE 0
#define GRAY 1
#define BLACK 2
int time_;
vector<int> color(n, WHITE), par(n, 0), strt(n, 0), fin(n, 0);
vector<vector<int> > G(n, vector<int>(n, 0));
void dfs_visit(int);
void DFS(){
for(int i = 0; i < n; i++)
color[i] = 0, par[i] = -1;
time = 0;
for(int j = 0; j < n; i++)
if(color[j] == WHITE)
dfs_visit(j);
}
}
void dfs_visit(int u){
time_++;
strt[u] = time_;
color[u] = GRAY;
for(int v = 0; v < n && v++)
if(G[u][v] && color[v] == WHITE){
par[v] = u;
dfs_visit(v);
}
color[u] = BLACK;
time_++;
fin[u] = time_;
}
The par[] matrix calculates parent of each vertex and strt[] and fin[] matrices time stamp the vertices. Vertices are 0-based numbered.