title: Dijkstra algorithm for 2D array in Java
body: <p>This is for a school project; I'm running into a huge amount of trouble, and I can't seem to find a understandable solution.</p>
  
  <pre><code>   a b c d e z
   a - 2 3 - - -
   b 2 - - 5 2 -
   c 3 - - - 5 -
   d - 5 - - 1 2
   e - 2 5 1 - 4
   z - - - 2 4 -
  </code></pre>
  
  <p>That's the two dimensional array. So if you want to find the shortest path, its from a,b,e,d,z = 7, and (a,b) = (b,a) -- it takes you to the new row to for the row's adjacent paths</p>
  
  <p>Is there anyone that can help me implement Dijkstra's algorithm for this example? I'd really appreciate it. (I seem to like arrays best, maps and sets confuse me a bit, lists are manageable -though I'm willing to look into any sort of solution at this point)</p>
  
  <p>[At least I'm not just ripping off a source from the net. I actually wanna learn these things... It's just really hard (>.&lt;)]</p>
  
  <p>Oh, start point is A and end point is Z</p>
  
  <hr>
  
  <p>As most people, I don't find the concept of the algorithm difficult -- I just can see to get the coding right... Help please?</p>
  
  <p>Sample code-- a friend helped me with this a lot (though its filled with data structures that I find difficult to follow) I"ve also tried adapting the C++ code from dreamincode.net/forums/blog/martyr2/index.php?showentry=578 into java, but that didn't go so well ...</p>
  
  <pre><code>import java.util.*;
  
  public class Pathy{
  
      private static class pathyNode{
          public final String name;
          public Map&lt;pathyNode, Integer&gt; adjacentNodes;
  
          public pathyNode(String n){
              name = n;
              adjacentNodes = new HashMap&lt;pathyNode, Integer&gt;();
          }
  
      }
  
      //instance variables
  
      //constructors
  
      //accessors
  
      //methods
      public static ArrayList&lt;pathyNode&gt; convert(int[][] inMatrix){
          ArrayList&lt;pathyNode&gt; nodeList = new ArrayList&lt;pathyNode&gt;();
          for(int i = 0; i &lt; inMatrix.length; i++){
              nodeList.add(new pathyNode("" + i));
          }
          for(int i = 0; i &lt; inMatrix.length; i++){
              for(int j = 0; j &lt; inMatrix[i].length; j++){
                  if(inMatrix[i][j] != -1){
                      nodeList.get(i).adjacentNodes.put(nodeList.get(j),
                              new Integer(inMatrix[i][j]));
                  }
              }
          }
          return nodeList;
      }
  
      public static Map&lt;pathyNode, Integer&gt; Dijkstra(ArrayList&lt;pathyNode&gt; inGraph){
          Set&lt;pathyNode&gt; visited = new HashSet&lt;pathyNode&gt;();
          visited.add(inGraph.get(0));
          pathyNode source = inGraph.get(0);
          Map answer = new TreeMap&lt;pathyNode, Integer&gt;();
          for(pathyNode node : inGraph){
              dijkstraHelper(visited, 0, source, node);
              answer.put(node, dijkstraHelper(visited, 0, source, node));
          }
          return answer;
      }
  
      private static int dijkstraHelper(Set&lt;pathyNode&gt; visited, int sum, pathyNode start, pathyNode destination){
          Map&lt;pathyNode, Integer&gt; adjacent = new HashMap&lt;pathyNode, Integer&gt;();
  
          for(pathyNode n : visited){
              for(pathyNode m: n.adjacentNodes.keySet()){
                  if(adjacent.containsKey(m)){
                      Integer temp = n.adjacentNodes.get(m);
                      if(temp &lt; adjacent.get(m)){
                          adjacent.put(m, temp);
                      }
                  }
                  else{
                      adjacent.put(m, n.adjacentNodes.get(m));
                  }
              }
          }
  
          Map&lt;pathyNode, Integer&gt; adjacent2 = new HashMap&lt;pathyNode, Integer&gt;();
          Set&lt;pathyNode&gt; tempSet = adjacent.keySet();
          tempSet.removeAll(visited);
          for(pathyNode n: tempSet){
              adjacent2.put(n, adjacent.get(n));
          }
          adjacent = adjacent2;
          Integer min = new Integer(java.lang.Integer.MAX_VALUE);
          pathyNode minNode = null;
  
          for(pathyNode n: adjacent.keySet()){
              Integer temp = adjacent.get(n);
              if(temp &lt; min){
                  min = temp;
                  minNode = n;
              }
          }
          visited.add(minNode);
          sum += min.intValue();
          sum = dijkstraHelper(visited, sum, start, destination);
          return sum;
      }
  
      //main
      public static void main(String[] args){
  
          int[][] input = new int[][] { {-1, 2, 3, -1, -1, -1},
                            {2, -1, -1, 5, 2, -1},
                            {3, -1, -1, -1, 5, -1},
                            {-1, 5, -1, -1, 1, 2},
                            {-1, 2, 5, 1, -1, 4},
                            {-1, -1, -1, 2, 4, -1},
                          };
                          //-1 represents an non-existant path
  
          System.out.println(Dijkstra(convert(input)));
      }
  }
  </code></pre>