Изминување на лавиринт

import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.Stack;


public class Lavirint {


    Graph graph;
    int start;
    int end;
    Hashtable<Integer, String> hash;
    Hashtable<String, Integer> rehash;

    Lavirint() {
        hash = new Hashtable<>();
        rehash = new Hashtable<>();
    }

    void createGraph(int rows, int columns, String [] input) {

        int numNodes = 0;
        String key;
        GraphNode nodes[] = new GraphNode[rows * columns];

        for (int i=0; i < rows; ++i) {
            for (int j=0; j < columns; ++j) {
                if (input[i].charAt(j) != '#') {
                    key = i + "," + j;
                    hash.put(numNodes,key);
                    rehash.put(key, numNodes);
                    nodes[numNodes] = new GraphNode(numNodes, key);
                    if (input[i].charAt(j) == 'S')
                        start = numNodes;
                    if (input[i].charAt(j) == 'E')
                        end = numNodes;
                    ++numNodes;
                }
            }
        }

        graph = new Graph(numNodes,nodes);
        int x;
        int y;
        for (int i=0; i < rows; ++i) {
            for (int j=0; j < columns; ++j) {

                if (input[i].charAt(j) != '#') {
                    if (input[i].charAt(j-1) != '#') {
                        x = rehash.get(i + "," + j);
                        y = rehash.get(i + "," + (j-1));
                        graph.addEdge(x, y);
                    }

                    if (input[i].charAt(j+1) != '#') {
                        x = rehash.get(i + "," + j);
                        y = rehash.get(i + "," + (j+1));
                        graph.addEdge(x, y);
                    }

                    if (input[i-1].charAt(j) != '#') {
                        x = rehash.get(i + "," + j);
                        y = rehash.get((i-1) + "," + j);
                        graph.addEdge(x, y);
                    }

                    if (input[i+1].charAt(j) != '#') {
                        x = rehash.get(i + "," + j);
                        y = rehash.get((i+1) + "," + j);
                        graph.addEdge(x, y);
                    }

                }

            }
        }

    }

    void findPath() {
        boolean visited[] = new boolean[graph.num_nodes];
        for (int i = 0; i < graph.num_nodes; i++)
            visited[i] = false;
        visited[start] = true;
        Stack<Integer> s = new Stack<Integer>();
        s.push(start);

        GraphNode pom;

        while (!s.isEmpty()&&s.peek() != end) {
            pom = graph.adjList[s.peek()];
            GraphNode tmp=null;
            for (int i = 0; i < pom.getNeighbors().size(); i++) {
                tmp = pom.getNeighbors().get(i);
                if (!visited[tmp.getIndex()])
                    break;
            }
            if(tmp!=null&&!visited[tmp.getIndex()]){
                visited[tmp.getIndex()] = true;
                s.push(tmp.getIndex());
            }
            else
                s.pop();
        }

        if(s.isEmpty())
            System.out.println("Nema reshenie");
        else{
            Stack<Integer> os = new Stack<Integer>();
            while(!s.isEmpty())
                os.push(s.pop());
            while(!os.isEmpty())
                System.out.println(hash.get(os.pop()));
        }

    }

    @Override
    public String toString() {
        return graph.toString();
    }

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        Lavirint lavirint = new Lavirint();
        String line = scan.nextLine();
        String parts[] = line.split(",");

        int rows = Integer.parseInt(parts[0]);
        int columns = Integer.parseInt(parts[1]);

        String input[] = new String[rows];

        for (int i=0; i < rows; ++i) {
            input[i] = scan.nextLine();
        }

        lavirint.createGraph(rows, columns, input);
        lavirint.findPath();
    }



}

class GraphNode {
    private int index;//index (reden broj) na temeto vo grafot
    private String info;
    private LinkedList<GraphNode> neighbors;

    public GraphNode(int index, String info) {
        this.index = index;
        this.info = info;
        neighbors = new LinkedList<GraphNode>();
    }

    boolean containsNeighbor(GraphNode o){
        return neighbors.contains(o);
    }

    void addNeighbor(GraphNode o){
        neighbors.add(o);
    }

    void removeNeighbor(GraphNode o){
        if(neighbors.contains(o))
            neighbors.remove(o);
    }

    @Override
    public boolean equals(Object obj) {
        @SuppressWarnings("unchecked")
        GraphNode pom = (GraphNode)obj;
        return (pom.info.equals(this.info));
    }

    @Override
    public String toString() {
        return index + " " + info;
    }


    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    public LinkedList<GraphNode> getNeighbors() {
        return neighbors;
    }

    public void setNeighbors(LinkedList<GraphNode> neighbors) {
        this.neighbors = neighbors;
    }

}

class Graph {

    int num_nodes;
    GraphNode adjList[];

    @SuppressWarnings("unchecked")
    public Graph(int num_nodes, GraphNode[] list) {
        this.num_nodes = num_nodes;
        adjList = new GraphNode[num_nodes];
        for (int i=0; i < num_nodes; ++i)
            adjList[i] = list[i];
    }

    int adjacent(int x, int y) {
        // proveruva dali ima vrska od jazelot so
        // indeks x do jazelot so indeks y
        return (adjList[x].containsNeighbor(adjList[y])) ? 1 : 0;
    }

    void addEdge(int x, int y) {
        // dodava vrska od jazelot so indeks x do jazelot so indeks y
        if (!adjList[x].containsNeighbor(adjList[y])) {
            adjList[x].addNeighbor(adjList[y]);
        }
        if (!adjList[y].containsNeighbor(adjList[x])) {
            adjList[y].addNeighbor(adjList[x]);
        }
    }

    void deleteEdge(int x, int y) {
        adjList[x].removeNeighbor(adjList[y]);
        adjList[y].removeNeighbor(adjList[x]);
    }

    @Override
    public String toString() {
        String ret = new String();
        for(int i=0;i<this.num_nodes;i++)
            ret+=adjList[i]+"\n";
        return ret;
    }

}