Sie befinden sich in einem einstöckigen Kerker. Es gibt einen Schatz, der durch verschlossene Türen geschützt ist. Türen können geöffnet werden, indem die entsprechenden Schlüssel gefunden werden. Ihr Ziel ist es, den kürzesten Weg zum Schatz zu finden.

Eingang

Die Eingabe erfolgt in Form eines zweidimensionalen Rasters, das das ursprüngliche Layout des Dungeons darstellt.

###########
#$   #   g#
#    # ####
###G##    #
#    ####C#
#c  @     #
###########

Das bist du: @
Das sind Wände: #
Das ist der Schatz: $
Verschlossene Türen sind Großbuchstaben: A... Z
Jede Tür hat einen entsprechenden Kleinbuchstabenschlüssel: a...z

• Es wird immer eins @und eins geben $.
• Der Dungeon wird immer rechteckig sein.

• Es kann nicht garantiert werden, dass die Außenkante des Dungeons eine Wand ist. Dies ist ein gültiger Dungeon:

    $ 
  A## 
  @ a
  

• Es ist nicht garantiert, dass der Schatz erreichbar ist. Einige Dungeons sind möglicherweise nicht lösbar.
• Es kann Türen ohne Schlüssel geben, und es kann Schlüssel geben, die keine Türen öffnen.
• Es wird niemals doppelte Türen oder Schlüssel geben.

Ausgabe

Ihr Programm soll eine Folge von Druck R, L, U, D(oder 4 andere verschiedene Symbole) , um die repräsentieren kürzesten möglichen Weg zum Schatz. Hier RLUDsteht für rechts, links, oben und unten. Wenn es mehrere kürzeste Pfade gibt, muss Ihr Programm nur einen davon drucken.

• Du kannst nicht an eine Wand gehen.
• Sie können sich nicht außerhalb der Dungeongrenzen bewegen.
• Sie können eine Tür nicht betreten, ohne den Schlüssel aufzuheben.
• Gehe auf einen Schlüssel, um ihn aufzuheben.
• Es ist nicht notwendig, jede einzelne Tür zu öffnen.

Wenn es nicht möglich ist, den Schatz durch eine gültige Folge von Zügen zu erreichen, muss Ihr Programm beendet werden, ohne etwas zu drucken. (Ein abschließender Zeilenumbruch ist zulässig.)

Wertung

Das ist Code-Golf, also gewinnt die Antwort mit der niedrigsten Byteanzahl.

Testfälle

Jeder Testfall enthält die Höhe und Breite des Dungeons in der ersten Zeile und einen möglichen Pfad mit der optimalen Anzahl von Zügen in der letzten Zeile.

1 2
@$
R (1)

3 3
  $
#Z#
@ z
RRLUUR (6)

3 5
c#d#$
 #C#D
@    
UUDDRRUUDDRRUU (14)

7 16
c   # b #  ###@ 
###     #       
  A #####  #### 
d #           e 
  B    ## ##### 
###    C   ##   
       # a DE $ 
RDDDDDDL (8)

16 37
#####################################
#    #ijk #a M   ##m##   #    #  R  #
#    #    #  #           #       ####
###J#### ############# ###    #  P b#
#e                       N  h #  ####
##########  ###########  ######     #
#        #  #    $    #  #    #  ####
#  D     H  #         #  #       Q f#
# EcF    #  #####A#####  ######  ####
#  G     #  #####B#####  #          #
#        K  #####C#####  ############
#        #                          #
########### #         #### ##### ####
#     # p   #         # n    #      #
# d         #    @    #     o#   r  #
#################Z###################
UUULLLLLLDDLLLDLLLLLLRRRRRRRRRUUURRRRRRRRRRRRRRRDDLLRRUULLUUUUUUURRRRRUURRRDRRRLLLLULLLLLDDLLLLUULLLUDLLLLLULLLRRRRRDRRRRRRDDLLLLLLLLLLLLDDDLLLLLLLDURRRRRRRRDDDDRRRRRRUUUUU (172)

Es ist nicht möglich, den Schatz in den folgenden Dungeons zu erreichen. Für diese Testfälle sollte keine Ausgabe erfolgen.

1 3
@#$

7 11
#a#j#$#i#f#
# #E#F#c#H#
# #K#D#A#G#
#         #
#C#J# #I#B#
#h#d# #L#g#
#l#e#@#b#k#

10 25
#########################
   # fgh  #  # c B b #  #
 $ #      #  #   #   #  #
   ###### #  ##H###E##  #
   #                    #
   #     #########  ##e##
   Z @   D     y #  #   #
   #     #########  F  C#
   #     G          # Ad#
#########################

Das folgende Snippet kann zur Validierung von Antworten verwendet werden.

function run() {var dungeonText = document.getElementById("dungeon").value;var dungeonLines = dungeonText.split("\n");var height = dungeonLines.length;var width = dungeonLines[0].length;var dungeon = new Array(height);for (i = 0; i < dungeon.length; i++) {var dungeonLine = dungeonLines[i];if (dungeonLine.length != width) {return error("The dungeon is not rectangular");} dungeon[i] = dungeonLines[i].split("");} var movesText = document.getElementById("moves").value;var moves = movesText.trim().split("");var moveCount = moves.length;var rowAt, colAt;for (r = 0; r < dungeon.length; r++) {for (c = 0; c < dungeon[r].length; c++) {if (dungeon[r][c] == '@') {rowAt = r;colAt = c;}}} var treasure = false;while (moves.length > 0) {var move = moves[0];var row = rowAt,col = colAt;switch (move) {case 'R':col++;break;case 'L':col--;break;case 'U':row--;break;case 'D':row++;break;default:return print(dungeon, moves, "Invalid move");} if (row < 0 || col < 0 || row >= height || col >= width) {return print(dungeon, moves, "Out of bounds");} var target = dungeon[row][col];if (target.match(/[A-Z#]/)) {return print(dungeon, moves, "Path blocked");} if (target.match(/[a-z]/)) {var door = target.toUpperCase();for (r = 0; r < dungeon.length; r++) {for (c = 0; c < dungeon[r].length; c++) {if (dungeon[r][c] == door) {dungeon[r][c] = ' ';}}}} if (target == '$') {treasure = true;} dungeon[row][col] = '@';dungeon[rowAt][colAt] = '.';rowAt = row;colAt = col;moves.shift();} if (treasure) {print(dungeon, moves, "Got the treasure in " + moveCount + " moves!");} else {print(dungeon, moves, "Failed to reach treasure");}} function error(message) {var result = document.getElementById("result");result.innerHTML = message;} function print(dungeon, moves, message) {var output = message + "\n";for (r = 0; r < dungeon.length; r++) {for (c = 0; c < dungeon[r].length; c++) {output += dungeon[r][c];} output += "\n";} for (i = 0; i < moves.length; i++) {output += moves[i];} var result = document.getElementById("result");result.innerHTML = output;}

Dungeon:<br/><textarea id="dungeon" name="dungeon" rows="20" cols="40"></textarea><br/>Moves:<br/><textarea id="moves" name="moves" cols="40"></textarea><br/><button id="run" name="run" onclick="run();">Start</button><br/><br/>Result:<br/><textarea id="result" name="result" rows="20" cols="40" disabled></textarea><br/>

Perl, 157 152 151 Bytes

Beinhaltet +4 für -p0(kann nicht nur als Erweiterung von gezählt werden, -eda es 'an mehreren Stellen verwendet wird)

Lauf mit dem Labyrinth auf STDIN:

./keymaze.pl < maze.txt

keymaze.pl:

#!/usr/bin/perl -p0
1until$n{map/\n/&&"L1R-1U@+D-@+"=~s%\pL%$t=$1{$_}.$&;pos=$^H=-$'+s'@' '*"@-",s/\G[a-z\$ ]/\@/+s/$&/ /i?/\$/?$1{$_}:$\||=$t:0for"$_"%reg,$_,%1}++.$\}{

Ersetzen \n und ^Hdurch ihre wörtlichen Versionen für die beanspruchte Kerbe. Benötigt ca. 1 Stunde und etwas weniger als 2 Gigabyte auf meinem Rechner, um das große Labyrinth zu lösen.

Java 8 - 1282 1277 1268 1259 1257 Bytes

Dies besteht alle Tests. Für einige von ihnen ergeben sich jedoch leicht unterschiedliche Ergebnisse (wenn es mehr als einen optimalen Weg gibt, was kein Problem darstellt).

Für den 4. Test gibt es folgendes:

RDDDDDLD

An Stelle von:

RDDDDDDL

Für den 5. Test gibt es folgendes:

LLLLUUULLDDLLLLDLLLLLRRRRRRURRRUURRRRRRRRRRRRRRRDDLLRRUULLUUUUUUURRRRRUURRRDRRRLLLLULLLDDLLLLLLUULLLUDLLLLLULLLRRRRRDRRRRRRDDLLLLLLLLLLLLDDDLLLLLLLDURRRRRRRRDDDDRRRRRRUUUUU

An Stelle von:

UUULLLLLLDDLLLDLLLLLLRRRRRRRRRUUURRRRRRRRRRRRRRRDDLLRRUULLUUUUUUURRRRRUURRRDRRRLLLLULLLLLDDLLLLUULLLUDLLLLLULLLRRRRRDRRRRRRDDLLLLLLLLLLLLDDDLLLLLLLDURRRRRRRRDDDDRRRRRRUUUUU

Golf Version:

import java.util.*;class G{int y,w,h,p;String C="",S,o,v;Map m=new HashMap();String q(int a){return a<1?"":"#"+q(a-1);}public static void main(String[]a)throws Exception{new G(new String(java.nio.file.Files.readAllBytes(new java.io.File(a[0]).toPath())));}G(String a){w=(a+"\n").indexOf(10)+3;String t=q(w)+a.replace("\n","##")+q(w);for(char j=65,k=97;j<91;j++,k++){if(t.indexOf(j)*t.indexOf(k)<0)t=t.replace(j,'#').replace(k,' ');}h=t.length()/--w;S=v=q(w*h);t=g(t);if(t!=v)System.out.print(t);}String g(String t){o=(String)m.get(t);if(o!=null)return o;if(t.indexOf(36)<0){if(S.length()>C.length())S=C;return"";}String d="";int f=t.indexOf(64),M[]=new int[w*h],N[]=new int[w*h];Queue<Integer>s=new ArrayDeque();s.add(f);while(!s.isEmpty()){y=s.poll();int[]P={y+1,y-1,y+w,y-w};for(int v:P){char j=t.replaceAll("[A-Z]","#").charAt(v);if(v!=f&j!=35&(N[v]<1|M[y]+1<M[v])){M[v]=M[y]+1;N[v]=y;s.add(v);if(j>32)d+=j;}}}o=d.chars().distinct().mapToObj(e->{String z="",c=C;for(y=t.indexOf(e);y!=f;y=N[y]){p=y-N[y];z=(p==w?"D":p==-w?"U":p==1?"R":"L")+z;}if(S.length()<=(C+z).length())return v;C+=z;String u=g(t.replace('@',' ').replace((char)e,'@').replace((char)(e-32),' '));C=c;return u==v?v:z+u;}).reduce(v,(a,b)->a.length()<b.length()?a:b);m.put(t,o);return o;}}

Ungolfed-Version

Eigenschaften:

• Informative Variablennamen;
• Explizite und detaillierte Kommentare;
• Richtige Identifikation.

import java.util.*;

/**
 * @author Victor Stafusa
 */
class TreasureHunt {

    // Note: on normal (non-golfing programming) those variables should have been scoped properly.
    // They are instance variables just for golfing purposes.
    // On the golfed version, nextCellIndex and waypointCellIndex are the same variable. The same also happens to cachedValue and result. This happens is for golfing purposes.

    int nextCellIndex,
            width,
            height,
            waypointCellIndex,
            cellIndexDifference;

    String previousPath = "",
            bestSolutionSoFar,
            cachedValue,
            result,
            failureFlag;

    // This should be Map<String, String>, but the generics were omitted for golfing.
    // It is needed to avoid recomputing long partial dungeons (i.e. dynamic programming).
    Map cachedResults = new HashMap();

    // Returns a lot of hashes. Like aLotOfHashes(7) will return "#######".
    String aLotOfHashes(int howMany) {
        return howMany < 1 ? "" : "#" + aLotOfHashes(howMany - 1);
    }

    // Here is where our program starts.
    public static void main(String[] args) throws Exception {
        // Read all the content of the file from args[0] and put it into a string.
        // Pass that string as a parameter to the constructor.
        // The instance itself is useless - it is just a golfing trick.
        new TreasureHunt(new String(java.nio.file.Files.readAllBytes(new java.io.File(args[0]).toPath())));
    }

    // Pre-processs the source in order to format it in the way that we want:
    // * No separators between rows. It uses the (row * width + column) formula, so no separators are needed.
    // * An extra layer of wall is added in all sides. This naturally fix up problems about walking out of the edges of the board, wrapping-around or acessing invalid array indexes.
    // This is a constructor just for golfing purposes. Its instances are worthless.
    TreasureHunt(String originalSource) {

        // Finds the width by searching the first line-feed.
        // If there is just one line and no line-feed, the [+ "\n"] will ensure that it will not break.
        // The [+ 3] is because we will add a layer of walls around, so it will be widen by one cell in the left and one in the right (which is +2).
        // We still get one more in the width that will be decremented later to use that in the aLotOfHashes method below.
        // 10 == '\n'.
        width = (originalSource + "\n").indexOf(10) + 3;

        // Add a layer of walls in the top and in the bottom (using a lot of hashes for that).
        // Replaces the line-feed by a pair of walls, representing the rightmost wall of a row and the leftmost row of the following row.
        // Since there is no line-feed before the first line nor after the last line, we add more two walls to fill those.
        String newSource = aLotOfHashes(width) + originalSource.replace("\n", "##") + aLotOfHashes(width);

        // Remove the keys without door (replaces them as blank spaces) and the doors without keys (replaces them with walls.
        // This way, the resulting dungeon will always have matching keys and doors.
        // 65 == 'A', 97 == 'a', 91 == 'z'+1
        for (char door = 65, key = 97; door < 91; door++, key++) {

            // Now a little math trick. For each key or door, we find an index. If the key or door exist, it will be a positive number. Otherwise it will be negative.
            // The result will never be zero, because the zeroey position is filled with part of the layer of wall that we added.
            // If only one of the key and the door exist, the multiplication will be the product of two numbers with opposite signals, i.e. a negative number.
            // Otherwise (both exists or both don't), then the product will be positive.
            // So, if the product is negative, we just remove the key and the door (only one of them will be removed of course, but we don't need to care about which one).
            if (newSource.indexOf(door) * newSource.indexOf(key) < 0) {
                newSource = newSource.replace(door, '#').replace(key, ' ');
            }
        }

        // Knowing the source length and the width (which we fix now), we can easily find out the height.
        height = newSource.length() / --width;

        // Creates a special value for signaling a non-existence of a path. Since they are sorted by length, this must be a sufficiently large string to always be unfavoured.
        bestSolutionSoFar = failureFlag = aLotOfHashes(width * height);

        // Now, do the hard work to solve the dungeon...
        // Note: On the golfed version, newSource and solution are the same variable.
        String solution = solvingRound(newSource);

        // If a solution is found, then show it. Otherwise, we just finish without printing anything.
        // Note: It is unsafe and a bad practice to compare strings in java using == or != instead of the equals method. However, this code manages the trickery.
        if (solution != failureFlag) System.out.print(solution);
    }

    // This does the hard work, finding a solution for a specific dungeon. This is recursive, so the solution of a dungeon involves the partial solution of the dungeon partially solved.
    String solvingRound(String dungeon) {
        // To avoid many redundant computations, check if this particular dungeon was already solved before. If it was, return its cached solution.
        cachedValue = (String) cachedResults.get(dungeon);
        if (cachedValue != null) return cachedValue;

        // If there is no treasure in the dungeon (36 == '$'), this should be because the adventurer reached it, so there is no further moves.
        if (dungeon.indexOf(36) < 0) {
            if (bestSolutionSoFar.length() > previousPath.length()) bestSolutionSoFar = previousPath;
            return "";
        }

        String keysOrTreasureFound = ""; // Initially, we didn't found anything useful.
        int adventurerSpot = dungeon.indexOf(64), // 64 == '@', find the cell index of the adventurer.
                cellDistance[] = new int[width * height],
                previousWaypoint[] = new int[width * height];

        // Use a queue to enqueue cell indexes in order to floodfill all the reachable area starting from the adventurer. Again, screw up the proper user of generics.
        Queue<Integer> floodFillQueue = new ArrayDeque();
        floodFillQueue.add(adventurerSpot); // Seed the queue with the adventurer himself.

        // Each cell thies to populate its neighbours to the queue. However no cell will enter the queue more than once if it is not featuring a better path than before.
        // This way, all the reachable cells will be reached eventually.
        while (!floodFillQueue.isEmpty()) {
            nextCellIndex = floodFillQueue.poll();

            // Locate the four neighbours of this cell.
            // We don't need to bother of checking for wrapping-around or walking into an invalid cell indexes because we added a layer of walls in the beggining,
            // and this layer of wall will ensure that there is always something in each direction from any reachable cell.
            int[] neighbourCells = {nextCellIndex + 1, nextCellIndex - 1, nextCellIndex + width, nextCellIndex - width};

            // For each neighbouring cell...
            for (int neighbourCellIndex : neighbourCells) {
                // Find the cell content. Considers doors as walls.
                char neighbourCellContent = dungeon.replaceAll("[A-Z]", "#").charAt(neighbourCellIndex);

                if (neighbourCellIndex != adventurerSpot // If we are not going back to the start ...
                        & neighbourCellContent != 35 // ... nor walking into a wall or a door that can't be opened (35 == '#') ...
                        & (previousWaypoint[neighbourCellIndex] < 1 // ... and the neighbour cell is either unvisited ...
                            | cellDistance[nextCellIndex] + 1 < cellDistance[neighbourCellIndex])) //  ... or it was visited before but now we found a better path ...
                { // ... then:
                    cellDistance[neighbourCellIndex] = cellDistance[nextCellIndex] + 1; // Update the cell distance.
                    previousWaypoint[neighbourCellIndex] = nextCellIndex; // Update the waypoint so we can track the way from this cell back to the adventurer.
                    floodFillQueue.add(neighbourCellIndex); // Enqueue the cell once again.
                    if (neighbourCellContent > 32) keysOrTreasureFound += neighbourCellContent; // If we found something in this cell (32 == space), take a note about that.
                }
            }
        }

        // Brute force solutions chosing each one of the interesting things that we found and recursively solving the problem as going to that interesting thing.
        // Warning: This has an exponential complexity. Also, if we found something interesting by more than one path, it will compute that redundantly.
        result = keysOrTreasureFound.chars().distinct().mapToObj(keyOrTreasure -> {
            String tracingWay = "", savedPreviousPath = previousPath;

            // From our keyOrTreasure, trace back the path until the adventurer is reached, adding (in reverse order) the steps needed to reach it.
            for (waypointCellIndex = dungeon.indexOf(keyOrTreasure); waypointCellIndex != adventurerSpot; waypointCellIndex = previousWaypoint[waypointCellIndex]) {

                // Use the difference in cell indexes to see if it is going up, down, right or left.
                cellIndexDifference = waypointCellIndex - previousWaypoint[waypointCellIndex];
                tracingWay = (cellIndexDifference == width ? "D" : cellIndexDifference == -width ? "U" : cellIndexDifference == 1 ? "R" : "L") + tracingWay;
            }

            // If this path is going to surely be longer than some other path already found before, prune the search and fail this path.
            if (bestSolutionSoFar.length() <= (previousPath + tracingWay).length()) return failureFlag;

            // Prepare for recursion, recording the current path as part of the next level recursion's previous path.
            previousPath += tracingWay;

            // Now that we traced our way from the adventurer to something interesting, we need to continue our jorney through the remaining items.
            // For that, create a copy of the dungeon, delete the door of the key that we found (if it was a key),
            // move the adventurer to the thing that we just found and recursively solve the resulting simpler problem.
            String nextRoundPartialSolution = solvingRound(dungeon
                        .replace('@', ' ') // Remove the adventurer from where he was...
                        .replace((char) keyOrTreasure, '@') // ... and put him in the spot of the key or treasure.
                        .replace((char) (keyOrTreasure - 32), ' ')); // ... and if it was a key, delete the corresponding door ([- 32] converts lowercase to uppercase, won't do anything in the case of the treasure).

            // Recursion finished. Now, get back the previous path of the previous recursion level.
            previousPath = savedPreviousPath;

            // If the subproblem resulted in a failure, then it is unsolvable. Otherwise, concatenates the subproblem solution to the steps that we took.
            return nextRoundPartialSolution == failureFlag ? failureFlag : tracingWay + nextRoundPartialSolution;

        // From all the paths we took, choose the shorter one.
        }).reduce(failureFlag, (a, b) -> a.length() < b.length() ? a : b);

        // Now that we have the result of this recursion level and solved this particular dungeon instance,
        // cache it to avoid recomputing it all again if the same instance of the dungeon is produced again.
        cachedResults.put(dungeon, result);
        return result;
    }
}

Eingaben nehmen

Versuchen Sie Folgendes, um es auszuführen:

javac G.java
java G ./path/to/file/with/dungeon.txt

Oder, wenn Sie die ungolfed Version laufen lassen, ersetzen Sie die GdurchTreasureHunt .

Die Datei sollte den Dungeon enthalten. Die Eingabe sollte nicht mit einem Zeilenvorschub enden. Außerdem werden nur Zeilenenden im \nFormat akzeptiert . Es funktioniert nicht mit \r\noder mit \r.

Außerdem werden die Eingaben nicht überprüft oder bereinigt. Wenn die Eingabe fehlerhaft ist, ist das Verhalten undefiniert (wahrscheinlich wird eine Ausnahme ausgelöst). Wenn die Datei nicht gefunden werden kann, wird eine Ausnahme ausgelöst.

Bemerkungen

Meine erste Implementierung irgendwo in der Nähe von 1100 Bytes konnte den 5. Testfall nicht in angemessener Zeit lösen. Der Grund dafür ist, dass meine Implementierung alle möglichen Permutationen von sammelbaren Gegenständen (dh den Schlüsseln und dem Schatz), die zugänglich sind (dh nicht in einem unzugänglichen Raum eingeschlossen sind), brachial erzwingt.

Im schlimmsten Fall wären das mit allen 26 Schlüsseln und dem Schatz 27! = 10.888.869.450.418.352.160.768.000.000 verschiedene Permutationen.

Das OP hat nicht festgelegt, dass die Antwort in angemessener Zeit erfolgen soll. Ich halte dies jedoch für eine Lücke, die ich nicht ausnutzen möchte. Also habe ich beschlossen, es für alle Testfälle in akzeptabler Zeit laufen zu lassen. Um dies zu erreichen, werden in meinem überarbeiteten Programm Suchpfade beschnitten, die nachweislich schlechter sind als einige bereits bekannte Lösungen. Außerdem werden Unterauflösungen (dh dynamische Programmierung) zwischengespeichert, um zu vermeiden, dass möglicherweise viele identische Dungeons neu berechnet werden. Damit ist es möglich, den 5. Testfall in etwas mehr als einer Minute auf meinem Computer zu lösen.

Die Lösung ist rekursiv. Die Idee ist zunächst, den Abenteurer zu einem Gegenstand (einem Schlüssel oder dem Schatz) zu bringen. Im Fall eines Schlüssels wird, nachdem der Abenteurer ihn erreicht hat, ein neuer, ähnlicher Dungeon erstellt, in dem sowohl der Schlüssel als auch die Tür gelöscht werden und der Abenteurer dorthin verschoben wird, wo sich der Schlüssel befand. Damit wird der erzeugte einfachere Dungeon rekursiv gelöst, bis der Punkt erreicht ist oder der Algorithmus feststellt, dass es keinen erreichbaren Gegenstand gibt. Die Reihenfolge der zu besuchenden Elemente wird mit Bereinigen und Zwischenspeichern brachial erzwungen, wie oben erläutert.

Die Wegfindung zwischen dem Abenteurer und den Gegenständen erfolgt mit einem Algorithmus, der sowohl Floodfill als auch Dijkstra ähnelt.

Schließlich vermute ich, dass dieses Problem NP-vollständig ist (nun, die verallgemeinerte Version davon ohne Beschränkung der Anzahl der Türen / Schlüssel). Wenn dies zutrifft, erwarten Sie keine Lösungen, die sehr große Verliese mit unzähligen Türen und Schlüsseln in angemessener Zeit optimal lösen. Wenn suboptimale Pfade zugelassen würden, wäre dies mit einigen Heuristiken leicht zu verfolgen (gehen Sie nach Möglichkeit zum Schatz, andernfalls zum nächsten Schlüssel).