在 C++ 中将邻接列表转换为有向无环图的邻接矩阵

Question

I was trying to implement topological sort in C++ using DFS but I got stuck with the conversion of an adjacency list to an adjacency matrix for the purpose. The problem I am encountering is that for a DAG every node might not have an outgoing edge so I can't simply create an adjacency list with a function like this which is valid for an undirected graph:-

void addEdge(list <int> l,int u,int v)
{
        l[u].push_back(v);
        l[v].push_back(u);
}

So it would be of great help if you could provide a way to implement an adjacency list for a DAG and suggest the code to convert it into an adjacency matrix. An implementation avoiding the use of structs and classes is highly appreciated.

Answer 1

You would only require to add a single edge in that case.

void addEdge (vector <list <int>> l, int u, int v)
{
    l[u].emplace_back (v); // u directs to v 
}

Run this function for all the edge pairs, and your adjacency list l will be completed.

Now, create an adjacency matrix as a square 2D array, initialising all the elements initially to 0 .

int mat[V][V] = {}; // V is the total number of vertices in the graph 

Now, simply traverse the adjacency list and for every edge (u, v) , set mat[u][v] = 1 , denoting that vertex u directs to vertex v .

for (int u = 0; u < V; ++u)
    for (auto v: l[u])
        mat[u][v] = 1;

Make sure that l has memory allocated beforehand till atleast V elements so as to not get a Segmentation Fault:

vector <list <int>> l(V);

Answer 2

Actually you can implement DFS (and so the topological sort) in terms of an adjacency list. In fact, adjacency list is the most efficient way to represent a graph for DFS (see below).

All you need for DFS is an ability to see, which vertices are adjacent to the current vertex:

vector<list<int>> graph;
vector<bool> visited;

void dfs(int current) {
  visited[current] = true;

  // iterating over adjacent vertices
  for (int other : graph[current])
    if (not visited[other])
      dfs(other);
}

So your topological sort can look something like this:

enum class status { unseen, entered, left };

vector<list<int>> graph;
vector<status> visited;
vector<int> topsorted;

void topsort_impl_dfs(int current) {
  visited[current] = status::entered;

  // iterating over adjacent vertices
  for (int other : graph[current]) {
    if (visited[other] == status::unseen) {
      dfs(other);
    } else if (visited[other] == status::entered) {
      // found a loop, not a DAG
    }
    // ignoring vertices with status::left, because they're already processed
  }

  topsorted.push_back(current);
  visited[current] = status::left;
}

void topsort() {
  fill(visited.begin(), visited.end(), status::unseen);

  topsorted.clear();
  topsorted.reserve(VERTEX_COUNT);

  for (int v = 0; v < VERTEX_COUNT; ++v) {
    if (visited[v] == status::unseen) {
      topsort_impl_dfs(v);
    }
  }

  // vertices are added to topsorted in an inverse order
  reverse(topsorted.begin(), topsorted.end());
}

If we compare the implementation of DFS with adjacency matrix and list, there is what we get ( V is vertex count, E is edge count):

• for an adjacency matrix: in each call to dfs(v) (one call for each vertex, V in total) we will iterate over the corresponding matrix row ( V iterations). So we get O(V*V) complexity.

• for an adjacency list: for every vertex we iterate only over the adjacent ones. It is harder to analyze this from that perspective because vertices have different count of adjacent vertices. But we can look at it like this: for each vertex we iterate over all outgoing edges. Each edge has exactly one start point, so, in total, we make exactly E iterations, and the complexity is O(E). It isn't worse than the first way, because in the worst case (full graph) we'll have E = O(V*V) .

So if your graph has V=1000 E=1000 , then the second way will be ~1000 times faster.