Um den Algorithmus von Dijkstra in die Version
LabyrinthBasis000 einzufügen, ersetze in der
Methode ladelabyrinth () der Klasse
DickwandigesLabyrinth das Codestück


        /*
         * Ermittle den Eingang und die Anzahl der Schaetze.
         */
        positionX = -1;
        positionY = -1;
        
        schaetze = 0;
        
        for (int x = 0; x < hoehe; x++)
        {
            for (int y = 0; y < breite; y++)
            {
                switch (labyrinth[x][y])
                {
                    case EINGANG:
                    positionX = x;
                    positionY = y;
                    break;
                    
                    case SCHATZ:
                    schaetze++;
                    break;
                }
            }
        }


durch


        /*
         * Ermittle den Eingang.
         */
        positionX = -1;
        positionY = -1;

        for (int x = 0; x < hoehe; x++)
        {
            for (int y = 0; y < breite; y++)
            {
                switch (labyrinth[x][y])
                {
                    case EINGANG:
                    positionX = x;
                    positionY = y;
                    break;
                }
            }
        }

        /*
         * Es folgt der Algorithmus nach Dijkstra.
         * 
         * Für jedes Labyrinthkästchen ermitteln wir die Entfernung vom
         * Eingang und speichern, ob es schon besucht wurde.
         */
        double[][]  entfernung = new double[hoehe][breite];
        boolean[][] besucht    = new boolean[hoehe][breite];

        /*
         * Am Anfang habe alle Kästchen unendliche Entfernung vom Eingang und
         * sind noch nicht besucht.
         */
        for (int x = 0; x < hoehe; x++)
        {
            for (int y = 0; y < breite; y++)
            {
                entfernung[x][y] = Double.POSITIVE_INFINITY;
                besucht[x][y]    = false;
            }
        }

        /*
         * Der Eingang hat Entfernung 0 vom Eingang.
         */
        entfernung[positionX][positionY] = 0;

        /*
         * Die Koordinaten des aktuellen Kästchens.
         */
        int aktuellX = -1;
        int aktuellY = -1;

        /*
         * Die minimale Entfernung eines noch nicht besuchten Kästchens vom
         * Eingang.
         */
        double e;

        /*
         * Wiederhole ...
         */
        do
        {
            /*
             * Nimm als aktuelles Kaestchen dasjenige noch nicht besuchte
             * Kästchen, das am nächsten am Eingang ist.
             */
            e = Double.POSITIVE_INFINITY;

            for (int x = 0; x < hoehe; x++)
            {
                for (int y = 0; y < breite; y++)
                {
                    if (!besucht[x][y] && entfernung[x][y] < e)
                    {
                        e = entfernung[x][y];
                        aktuellX = x;
                        aktuellY = y;
                    }
                }
            }
            
            /*
             * Wenn die minimale Entfernung endlich ist ...
             */
            if (e < Double.POSITIVE_INFINITY)
            {
                /*
                 * ... markiere das aktuelle Kaestchen als besucht.
                 */
                besucht[aktuellX][aktuellY] = true;
                
                /*
                 * Setze bei allen Nachbarkästchen, die keine Wände und noch
                 * nicht besucht sind, die Entfernung auf e + 1.
                 */
                if (gibLabyrinthinhalt (aktuellX, aktuellY + 1) != WAND
                            && !besucht[aktuellX][aktuellY + 1])
                {
                             entfernung[aktuellX][aktuellY + 1] = e + 1;
                }
                
                if (gibLabyrinthinhalt (aktuellX, aktuellY - 1) != WAND
                            && !besucht[aktuellX][aktuellY - 1])
                {
                             entfernung[aktuellX][aktuellY - 1] = e + 1;
                }
                
                if (gibLabyrinthinhalt (aktuellX + 1, aktuellY) != WAND
                            && !besucht[aktuellX + 1][aktuellY])
                {
                             entfernung[aktuellX + 1][aktuellY] = e + 1;
                }
                
                if (gibLabyrinthinhalt (aktuellX - 1, aktuellY) != WAND
                            && !besucht[aktuellX - 1][aktuellY])
                {
                             entfernung[aktuellX - 1][aktuellY] = e + 1;
                }  
            }

            /*
             * Solange die minimale Entfernung kleiner als unendlich ist,
             * wiederhole weiter.
             */
        }
        while (e < Double.POSITIVE_INFINITY);

        /*
         * Ende des Algorithmus von Dijkstra.
         * 
         * Ermittle die Anzahl der Schaetze. Lösche dabei gleich diejenigen
         * Schätze, die vom Eingang aus nicht erreichbar sind.
         */
        schaetze = 0;

        for (int x = 0; x < hoehe; x++)
        {
            for (int y = 0; y < breite; y++)
            {
                switch (labyrinth[x][y])
                {
                    case SCHATZ:
                    if (entfernung[x][y] < Double.POSITIVE_INFINITY)
                    {
                        schaetze++;
                    }
                    else
                    {
                        labyrinth[x][y] = LEERRAUM;
                    }
                    break;
                }
            }
        }
        
        /*
         * Falls es keine Schätze gibt, platziere einen Schatz an die am
         * weitesten vom Eingang entfernte, erreichbare Stelle. Sollte das
         * der Eingang selbst sein, gibt es keinen Schatz.
         */
        if (0 == schaetze)
        {
            /*
             * Das am weitesten entfernte Kästchen ist das letzte aktuelle
             * Kästchen bei Dijkstra.
             * 
             * Wenn dieses Kästchen vom Eingang verschieden ist ...
             */
            if (aktuellX != positionX || aktuellY != positionY)
            {
                /*
                 * ... platziere dort einen Schatz.
                 */
                labyrinth[aktuellX][aktuellY] = SCHATZ;
                schaetze++;
            }
        }