title: Representing a graph with a 2D array
body: <p>I have a question where I represent a graph in terms of a 2D array.
  I have a sample as well, but I have no idea, how it works....
  This is the graph I am given
  <a href="https://i.stack.imgur.com/ZIZr0.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/ZIZr0.png" alt="enter image description here" /></a></p>
  <p>And this is how they represent it using a 2D array
  <a href="https://i.stack.imgur.com/phDMm.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/phDMm.png" alt="enter image description here" /></a></p>
  <p>How does one translate to the other?</p>
  <p>Also, this is a part of an implementation of Dijsktra's algorithm.
  Here is the code for your reference, it is taken from
  <a href="https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/" rel="nofollow noreferrer">geeksforgeeks</a></p>
  <pre><code>// A Java program for Dijkstra's single source shortest path algorithm.
  // The program is for adjacency matrix representation of the graph
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  
  class ShortestPath {
      // A utility function to find the vertex with minimum distance value,
      // from the set of vertices not yet included in shortest path tree
      static final int V = 9;
      int minDistance(int dist[], Boolean sptSet[])
      {
          // Initialize min value
          int min = Integer.MAX_VALUE, min_index = -1;
  
          for (int v = 0; v &lt; V; v++)
              if (sptSet[v] == false &amp;&amp; dist[v] &lt;= min) {
                  min = dist[v];
                  min_index = v;
              }
  
          return min_index;
      }
  
      // A utility function to print the constructed distance array
      void printSolution(int dist[])
      {
          System.out.println(&quot;Vertex \t\t Distance from Source&quot;);
          for (int i = 0; i &lt; V; i++)
              System.out.println(i + &quot; \t\t &quot; + dist[i]);
      }
  
      // Function that implements Dijkstra's single source shortest path
      // algorithm for a graph represented using adjacency matrix
      // representation
      void dijkstra(int graph[][], int src)
      {
          int dist[] = new int[V]; // The output array. dist[i] will hold
          // the shortest distance from src to i
  
          // sptSet[i] will true if vertex i is included in shortest
          // path tree or shortest distance from src to i is finalized
          Boolean sptSet[] = new Boolean[V];
  
          // Initialize all distances as INFINITE and stpSet[] as false
          for (int i = 0; i &lt; V; i++) {
              dist[i] = Integer.MAX_VALUE;
              sptSet[i] = false;
          }
  
          // Distance of source vertex from itself is always 0
          dist[src] = 0;
  
          // Find shortest path for all vertices
          for (int count = 0; count &lt; V - 1; count++) {
              // Pick the minimum distance vertex from the set of vertices
              // not yet processed. u is always equal to src in first
              // iteration.
              int u = minDistance(dist, sptSet);
  
              // Mark the picked vertex as processed
              sptSet[u] = true;
  
              // Update dist value of the adjacent vertices of the
              // picked vertex.
              for (int v = 0; v &lt; V; v++)
  
                  // Update dist[v] only if is not in sptSet, there is an
                  // edge from u to v, and total weight of path from src to
                  // v through u is smaller than current value of dist[v]
                  if (!sptSet[v] &amp;&amp; graph[u][v] != 0 &amp;&amp; dist[u] != Integer.MAX_VALUE &amp;&amp; dist[u] + graph[u][v] &lt; dist[v])
                      dist[v] = dist[u] + graph[u][v];
          }
  
          // print the constructed distance array
          printSolution(dist);
      }
  
      // Driver method
      public static void main(String[] args)
      {
          /* Let us create the example graph discussed above */
          int graph[][] = new int[][] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
                                      { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
                                      { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
                                      { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
                                      { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
                                      { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
                                      { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
                                      { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
                                      { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
          ShortestPath t = new ShortestPath();
          t.dijkstra(graph, 0);
      }
  }
  </code></pre>
  <p>If this is the graph given to me, for example, how would I represent it using a 2D array?
  <a href="https://i.stack.imgur.com/hZWP9.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/hZWP9.png" alt="enter image description here" /></a></p>