Implement weighted graph - c++

Question

Say I have the following adjacency matrix:
A B C D
A 0 9 0 5
B 9 0 0 0
C 0 0 0 2
D 5 0 2 0
How would this acutally be implemented? I realize I can use a 2D array to represent the weighted edges between vertices but I'm not sure how to represent the vertices.
int edges[4][4];
string vertices[4];
Is this the way to do it? The index in the vertices array corresponds to the row index in the edges array.

Answer 1

You can use a two dimensional std::map
Using this method allows for the matrix to grow and shrink when ever you want.
#include <map>
#include <string>
#include <iostream>
int main()
{
std::map<std::string, std::map<std::string, int>> vertices;
vertices["A"]["A"] = 0; vertices["A"]["B"] = 9; vertices["A"]["C"] = 0; vertices["A"]["D"] = 5;
vertices["B"]["A"] = 9; vertices["B"]["B"] = 0; vertices["B"]["C"] = 0; vertices["B"]["D"] = 0;
vertices["C"]["A"] = 0; vertices["C"]["B"] = 0; vertices["C"]["C"] = 0; vertices["C"]["D"] = 2;
vertices["D"]["A"] = 5; vertices["D"]["B"] = 0; vertices["D"]["C"] = 2; vertices["D"]["D"] = 0;
std::cout << vertices["A"]["A"] << std::endl;
std::cout << vertices["A"]["B"] << std::endl;
}

Answer 2

Going by the indexes of adjacency matrix as vertices is common practice.

Answer 3

If there are a fixed number of vertices in the graph. You could declare the vertices as an enum and index the array directly using the enumerated vertex names. I think it makes the mapping a little clearer.
enum VERTEX
{
A = 0,
B,
C,
D,
LAST = D
};
int edge[LAST+1][LAST+1];
edge[A][A] = 0;
edge[A][B] = edge[B][A] = 9;
edge[A][C] = edge[C][A] = 0;
// etc.
This keeps things simple and quick by allowing you to use an array without any look-up penalty while keeping things easy to understand.

Answer 4

For most intents and purposes it's usually more efficient to represent the graph as an adjentacy list:
std::vector< std::list<int> > graph;
So graph[i] is all neighboring vertexes of i. The advantage being that when dealing with graphs we usually want to traverse i's neighbors. Also, for large sparse graphs, space complexity is much lower. This of course could also be extended to include weights with something like:
std::vector< std::list<std::pair< int, int> > > graph;
or for more complex types, define a type Vertex...
EDIT: If you require indices as strings, this could easily be done by opting to std::map instead of std::vector:
std::map< std::string, std::list<std::pair< std::string /*vertex*/, int/*weight*/> > > graph;
But it appears from your original post that you just wish to map indexes to vertex names, in which case I'd go with the first soluion but also keep the vertex name mapped to the index:
std::vector< std::pair< std::string/*name*/, std::list<std::pair< int /*index*/, int/*weight*/> > > > graph;