Find perfect maze path, using Graph structure

Question

I have this classes and code that solve the maze, but i don't understand why solution is written this way... it doesn't even use the graph...

Here is the GraphNode : http://pastebin.com/DMprKQAN

Here is the Graph : http://pastebin.com/ueCWqPww

Maze class:

public class Lavirint {
    Graph<String> g;
    int start_node; 
    int end_node;

    Hashtable<String, Integer> h;

    public Lavirint() {
        h = new Hashtable<String, Integer>();
        g= null;
    }

    void generateGraph(int rows, int columns, String[] in) {

        int num_nodes = 0;
        String key;
        for(int i=1; i<rows-1; i++){
            for(int j=1; j<columns-1; j++){
                if(in[i].charAt(j)!='#'){
                    key = i+","+j;
                    h.put(key, num_nodes);
                        if(in[i].charAt(j)=='S')
                            start_node = num_nodes;
                            if(in[i].charAt(j)=='E')
                                end_node = num_nodes;
                num_nodes++;
                }
            }
        }

        g = new Graph<String>(num_nodes);
        int x, y;
            // Generating neighbours matrix
        for(int i=1; i<rows-1; i++){ 
            for(int j=1; j<columns-1; j++){
                if(in[i].charAt(j)!='#'){
                    if(in[i].charAt(j-1)!='#'){ 
                        x = h.get(i+","+j); y = h.get(i+","+(j-1));
                        g.addEdge(x, y);
                    }
                    if(in[i].charAt(j+1)!='#'){
                        x = h.get(i+","+j); y = h.get(i+","+(j+1));
                        g.addEdge(x, y);
                    }
                    if(in[i-1].charAt(j)!='#'){
                        x = h.get(i+","+j); y = h.get((i-1)+","+j);
                        g.addEdge(x, y);
                    }
                    if(in[i+1].charAt(j)!='#'){
                        x = h.get(i+","+j); y = h.get((i+1)+","+j);
                        g.addEdge(x, y);
                    }
                }
            }
        }
    }

    void findPath() {
        boolean visited[] = new boolean[g.num_nodes];
        for (int i = 0; i < g.num_nodes; i++)
            visited[i] = false;
        visited[start_node] = true;
        Stack<Integer> s = new Stack<Integer>();
        s.push(start_node);
        int pom,pom1;
        while (!s.isEmpty() && s.peek()!=end_node) {
            pom = s.peek();
            pom1 = pom;
        for (int i = 0; i < g.num_nodes; i++) {
            if(g.adjacent(pom,i)==1){
                pom1 = i;
                if(!visited[i])
                    break;
            }
        }
        if(!visited[pom1]){
            visited[pom1] = true;
            s.push(pom1);
        }
        else
            s.pop();
        }
        Stack<Integer> os = new Stack<Integer>();
        while(!s.isEmpty())
            os.push(s.pop());
        while(!os.isEmpty()) {
            String t=null;
            Iterator<Entry<String,Integer>> it=(h.entrySet()).iterator();
            int i=os.pop();
            while(it.hasNext()) {
                Entry<String, Integer> entry=it.next();
                if (entry.getValue()==i) {
                    System.out.println(entry.getKey());
                    break;
                }
            }

        }
    }

    public static void main(String args[]) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Lavirint l = new Lavirint();
        String pom = br.readLine();
        String[] ppom = pom.split(",");
        int rows = Integer.parseInt(ppom[0]);
        int columns = Integer.parseInt(ppom[1]);
        String[] in = new String[rows];

        for (int i = 0; i < rows; i++) 
            in[i] = br.readLine();

        l.generateGraph(rows, columns, in);

        l.findPath();
    }

}

I don't understand why when the Graph is being generated GraphNode.info is empty and only Edges are marked, so because it is done, finding the path() has weird solution... All i wanna know is this is good or right approach and if i solve this maze using Char for info variable in GraphNode will be bad solution??

Test Cases:

1.

6,6
######
#S# E#
# # ##
#   ##
######
######

Answer:

1,1
2,1
3,1
3,2
3,3
2,3
1,3
1,4

2.

8,8
########
#  S####
# ##   #
#    # #
###### #
#####  #
#####E##
########

Answer:

1,3
1,2
1,1
2,1
3,1
3,2
3,3
3,4
2,4
2,5
2,6
3,6
4,6
5,6
5,5
6,5

Answer 1

The findPath() method does use the graph. The graph allows you to check adjacent tiles to the one you're currently checking using the g.adjacent() call. (Haven't looked at the code in the links but I assume that's what it does since your algorithm works). The approach of solving the labyrinth like this seems fine to me.