खजाना पाने के लिए इंडियाना जोन्स की मदद करें


45

कहानी

इंडियाना जोन्स एक गुफा की खोज कर रहा था जहां एक कीमती खजाना स्थित है। अचानक, एक भूकंप आया।

जब भूकंप समाप्त हो गया, तो उसने देखा कि छत से गिरने वाली कुछ चट्टानों ने उसके खजाने के रास्ते को अवरुद्ध कर दिया था। उसने यह भी देखा कि वह एक पत्थर को धक्का दे सकता है, लेकिन चूंकि पत्थर बहुत भारी थे, इसलिए वह लगातार दो पत्थर नहीं चला सकता था ।

आपका उद्देश्य इंडियाना जोन्स को खजाना पाने में मदद करना है। चूंकि किसी एक पत्थर को भी धकेलना बहुत कठिन होता है, इसलिए धकेलने की संख्या बहुत महत्वपूर्ण होती है।

मुसीबत

सबसे अच्छा तरीका खोजें (जहां इंडियाना जोन्स जितना संभव हो सके पत्थरों को धक्का देता है), खजाने को खोजने के लिए।

नक्शा (इनपुट)

नक्शा एक है mद्वारा n(दोनों से बड़ा 1) मैट्रिक्स जो सेल के पांच प्रकार हो सकते हैं:

  • 0 जिसका मतलब है खाली सेल,
  • 1 जिसका मतलब दीवार है,
  • 2 जो इंडियाना जोन्स में स्थित है (केवल एक ही मौजूद है),
  • 3 जिसमें खजाना स्थित है (केवल एक ही मौजूद है),
  • और 4, जिसका अर्थ है एक चट्टान।

नक्शे की पहली पंक्ति में, नक्शे के आयाम को निर्दिष्ट किया जाता है 4 6, और दूसरी पंक्ति से नक्शे की अंतिम पंक्ति तक, गुफा की संरचना कुछ इस तरह निर्दिष्ट होती है।

110131
104040
100101
200000

इसलिए, पूरा नक्शा है:

4 6
110131
104040
100101
200000

जिसका मतलब है

नक्शा

नक्शा स्टडिन द्वारा दिया जाता है, एक फ़ाइल (आप फ़ाइल का नाम निर्दिष्ट कर सकते हैं), या कोड में एक सरणी जिसमें केवल उपरोक्त जानकारी होती है।

उत्पादन

न्यूनतम राशि इंडियाना जोन्स को धक्का देना चाहिए। यदि ऐसा कोई तरीका नहीं है, तो आउटपुट X

ऊपर के मामले में , वह एक पत्थर को ऊपर की ओर धकेल सकता है, फिर वह खजाने को पाने के लिए दाईं ओर एक पत्थर को धकेल सकता है। इसलिए, इस मामले में आउटपुट है 2

हालाँकि। इस मामले में :

4 6
111131
104040
100101
200000

(नीचे अनुभाग देखें) वह सही पत्थर को नहीं धकेल सकता है क्योंकि यह खजाने को नष्ट कर देगा। इसके अलावा, बाएं पत्थर को दाहिने ओर धकेलने से कुछ नहीं बदलता है। इसलिए, उत्पादन होता है X

नियम

  • वह केवल चार दिशाओं में बढ़ सकता है, ऊपर, नीचे, बाएँ और दाएँ।
  • वह लगातार दो पत्थर नहीं चला सकता ।
  • वह किसी पत्थर को नहीं खींच सकता, और वह एक पत्थर को केवल एक दिशा ('आगे') में धकेल सकता है।
  • वह दीवारों से नहीं जा सकता। केवल वे ही जा सकते हैं जो रिक्त स्थान हैं और खजाना सेल हैं।
  • पत्थर को खजाने पर नहीं रखा जा सकता है। जो कि खजाने को नष्ट कर देगा। :(
  • वह नक्शे के बाहर नहीं जा सकता।

लक्ष्य

कार्यक्रम जो उचित समय (विशेष रूप से, 10 सेकंड) में सबसे अधिक नक्शे ('उदाहरण' अनुभाग + अन्य पर प्रदान) को संभाल सकता है और सही उत्तर जीतता है।

यहाँ 'अन्य' का अर्थ है उत्तर में दिए गए उदाहरण इनपुट। इसका मतलब है कि आपको एक स्मार्ट एल्गोरिदम बनाना चाहिए ताकि अन्य प्रोग्राम उन मानचित्रों को हल न कर सकें जिन्हें आपका प्रोग्राम हल कर सकता है, और अन्य कार्यक्रमों द्वारा हल किए गए नक्शे आपके प्रोग्राम से हल किए जा सकते हैं। हालांकि, कोड में समाधान डालना वैध नहीं माना जाएगा।

ध्यान दें

यह मूल रूप से एआई वर्ग की एक मध्य-अवधि की परियोजना थी जो मैंने सुनी थी, केवल एक चीज अलग थी: यह कहा गया था कि केवल दो चट्टानें थीं ।

यह कहा गया था कि यह समस्या एनपी है, लेकिन यह भी कहा गया था कि एक अच्छा अनुमानी एल्गोरिथ्म समस्या को काफी कुशलता से हल कर सकता है। मैंने समस्या को कुशलता से हल करने के लिए कुछ विचारों और अनुमानों का उपयोग किया, और मेरा कोड नमूनों के सभी समाधान बहुत जल्दी (एक सेकंड से भी कम) पा सकता है।

हालांकि, जब दो से अधिक चट्टानें थीं, तो कुछ मामले ऐसे थे जहां कोड उचित समय में जवाब नहीं दे सका। मेरे पास कुछ विचार थे, लेकिन उनमें से कुछ 'गलत' थे, और मैं अन्य विचारों को कोड में व्यक्त नहीं कर सकता था। मैं देखना चाहता था कि इस समस्या को हल करने के लिए स्मार्ट एल्गोरिदम मौजूद हैं, इसलिए मैंने यह लिखा।

चूंकि मैंने पहले ही परियोजना पूरी कर ली है (btw, चित्र मेरे नहीं हैं - मैंने उन लोगों को गुगली दी), आपको इसके बारे में चिंता करने की ज़रूरत नहीं है।

उदाहरण

उदाहरण यहां देखे जा सकते हैं। आप उदाहरण भी देख सकते हैं, और यहां अपने परिणामों का परीक्षण कर सकते हैं (यह आधुनिक ब्राउज़रों में काम करना चाहिए)। आप whatisthis()जेएस कंसोल में टाइप करके मानचित्र को ऊपर वर्णित प्रारूप में प्राप्त कर सकते हैं ।

http://bit.sparcs.org/~differ/sokoban/#0 ~ http://bit.sparcs.org/~differ/sokoban/#19 में ऐसे उदाहरण हैं, जो मूल रूप से प्रदान किया गया वर्ग है।

नतीजा

क्षमा करें, मुझे देर हो गई थी .. वास्तव में काफी। : पी (मैं स्कोर करने के लिए बहुत आलसी था। क्षमा करें।)

नीचे परिणाम है। (एक्स: गलत, ओ: सही ;: कम से कम 10s, रुका हुआ)

Map#: 0 1 2 3 4 5 12 15 19 T1 T2 T3 T4 T5 T6 T7
Ruby: X O O ? O O  O  X  ?  ?  O  ?  ?  ?  ?  ?
Java: O O X O X X  O  O  ?  ?  O  O  O  X  O  O

(जावा 19: 25 का समय लिया, परिणाम सही था।) (मैंने माणिक 1.9.3 और जावाैक 1.7.0_13 का इस्तेमाल किया)

ऐसा लगता है कि जावा एल्गोरिथ्म वास्तव में बेहतर था। (वैसे, मैंने एक समान विधि के बारे में सोचा था, लेकिन मुझे एहसास हुआ कि परीक्षण मानचित्र 5 जैसे नक्शे मौजूद हैं।)


7
यह एक मुश्किल है।
फ़ूजएक्सएक्सएक्सएल

8
यह मुझे पहेली की जटिलता के आधार पर एक यादृच्छिक संख्या जनरेटर लिखना चाहता है, हमेशा अंडरशूटिंग ... लोग कठिन पहेली बनाते हैं, फिर अपने सिर को दिनों के लिए खरोंचते हुए सोचते हैं कि मेरे कार्यक्रम ने इसे केवल 4 पुश के साथ कैसे हल किया ...: )
नाथन व्हीलर

@NathanWheeler, हाँ, एक अनिश्चितकालीन सॉल्वर का निर्माण करें। यह काम करता है, लेकिन आपको इसे क्वांटम कंप्यूटर में चलाना होगा। : पी
नील

यह इंडियाना जोन्स को खजाने पर शुरू करने और पीछे की ओर काम करने की गणना करना होगा, जैसे आप एक भूलभुलैया को हल करेंगे। उस स्थिति का अंतर केवल स्थिति से नहीं, बल्कि रॉक पोजिशनिंग से भी निर्धारित किया जा सकता है (यदि एक ही स्थान पर दो बार जाया जा सकता है तो चट्टानों को स्थानांतरित कर दिया गया है)। हम्म, मुझे इस बारे में अधिक सोचना होगा ..
नील

जवाबों:


11

जावा - थोड़ा चालाक / तेज

वहाँ थोड़ा कोड। मैं "खजाने के लिए एक तरह से मुक्त होने की संभावना कितनी है" के क्रम में पुलों का मूल्यांकन करके तेजी से होने की कोशिश कर रहा हूं, जो खुद दो डेजक्स्ट्रा ट्रैवर्सल्स पर आधारित है (चट्टानों से मुठभेड़ करते समय एक बंद हो जाता है, अन्य चट्टानों की उपेक्षा करता है)। यह बहुत अच्छी तरह से काम कर रहा है, और अतीत के एक उदाहरण से जो लेखक के लिए परेशानी भरा प्रतीत होता है, इस कार्यान्वयन के द्वारा लगभग 2 सेकंड में हल हो जाता है। कुछ अन्य उदाहरणों में 30-40 सेकंड लगते हैं, जो मुझे अभी भी बहुत लंबे लगते हैं, लेकिन मुझे उस सामान को सुधारने का कोई तरीका नहीं मिल रहा है: सामान को तोड़ने के बिना :)

मैंने एक बेहतर संरचना प्राप्त करने के लिए कई फाइलों में अपना सामान विभाजित किया है (यह भी कि मैंने जावा को माणिक से क्यों स्विच किया)

प्रवेश बिंदु:

import java.util.Date;    
public class IndianaJones {
    public static void main(final String[] args) throws Exception {
        final Maze maze = new Maze(System.in);
        final Date startAt = new Date();
        final int solution = maze.solve();
        final Date endAt = new Date();
        System.out.printf("Found solution: %s in %d ms.",
                          solution < Integer.MAX_VALUE ? solution : "X",
                          endAt.getTime() - startAt.getTime());
    }
}

दिशा सहायक सहायक:

enum Direction {
    UP(-1, 0), DOWN(1, 0), LEFT(0, -1), RIGHT(0, 1);

    public final int drow;
    public final int dcol;

    private Direction(final int drow, final int dcol) {
        this.drow = drow;
        this.dcol = dcol;
    }

    public final Direction opposite() {
        switch (this) {
        case UP:
            return DOWN;
        case DOWN:
            return UP;
        case LEFT:
            return RIGHT;
        case RIGHT:
            return LEFT;
        }
        return null;
    }
}

"भूलभुलैया" के एक स्थित भाग का प्रतिनिधित्व करने के लिए एक सार वर्ग:

abstract class PointOfInterest {
    public final int row;
    public final int col;

    protected PointOfInterest(final int row, final int col) {
        this.row = row;
        this.col = col;
    }

    public final boolean isAt(final int row, final int col) {
        return this.row == row && this.col == col;
    }

    @Override
    public final String toString() {
        return getClass().getSimpleName() + "(" + row + ", " + col + ")";
    }

    @Override
    public final int hashCode() {
        return row ^ col;
    }

    @Override
    public final boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (!(obj instanceof PointOfInterest))
            return false;
        if (!getClass().equals(obj.getClass()))
            return false;
        final PointOfInterest other = (PointOfInterest) obj;
        return row == other.row && col == other.col;
    }
}

और अंत में, भूलभुलैया ही:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

public class Maze {
    private static final char WALL = '1';
    private static final char INDY = '2';
    private static final char GOAL = '3';
    private static final char ROCK = '4';

    private final Maze parent;
    private final Set<Maze> visited;
    private final boolean[][] map;
    private final int[][] dijkstra;
    private int[][] dijkstraGhost;
    private String stringValue = null;

    private int shortestSolution = Integer.MAX_VALUE;

    private Goal goal = null;
    private Indy indy = null;
    private Set<Rock> rocks = new HashSet<>();

    private Maze(final Maze parent, final Rock rock, final Direction direction) {
        this.parent = parent;
        this.visited = parent.visited;
        map = parent.map;
        dijkstra = new int[map.length][map[rock.row].length];
        for (final int[] part : dijkstra)
            Arrays.fill(part, Integer.MAX_VALUE);
        goal = new Goal(parent.goal.row, parent.goal.col);
        indy = new Indy(rock.row, rock.col);
        for (final Rock r : parent.rocks)
            if (r == rock)
                rocks.add(new Rock(r.row + direction.drow, r.col + direction.dcol));
            else
                rocks.add(new Rock(r.row, r.col));
        updateDijkstra(goal.row, goal.col, 0, true);
    }

    public Maze(final InputStream is) {
        this.parent = null;
        this.visited = new HashSet<>();
        try (final BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
            String line = br.readLine();
            final String[] sizeParts = line.split(" ");
            final int height = Integer.parseInt(sizeParts[0]);
            final int width = Integer.parseInt(sizeParts[1]);
            map = new boolean[height][width];
            dijkstra = new int[height][width];

            int row = 0;
            while ((line = br.readLine()) != null) {
                for (int col = 0; col < line.length(); col++) {
                    final char c = line.charAt(col);
                    map[row][col] = c == WALL;
                    dijkstra[row][col] = Integer.MAX_VALUE;
                    if (c == INDY) {
                        if (indy != null)
                            throw new IllegalStateException("Found a second indy!");
                        indy = new Indy(row, col);
                    } else if (c == GOAL) {
                        if (goal != null)
                            throw new IllegalStateException("Found a second treasure!");
                        goal = new Goal(row, col);
                    } else if (c == ROCK) {
                        rocks.add(new Rock(row, col));
                    }
                }
                row++;
            }

            updateDijkstra(goal.row, goal.col, 0, true);
        } catch (final IOException ioe) {
            throw new RuntimeException("Could not read maze from InputStream", ioe);
        }
    }

    public int getShortestSolution() {
        Maze ptr = this;
        while (ptr.parent != null)
            ptr = ptr.parent;
        return ptr.shortestSolution;
    }

    public void setShortestSolution(int shortestSolution) {
        Maze ptr = this;
        while (ptr.parent != null)
            ptr = ptr.parent;
        ptr.shortestSolution = Math.min(ptr.shortestSolution, shortestSolution);
    }

    private final boolean isRepeat(final Maze maze) {
        return this.visited.contains(maze);
    }

    private final void updateDijkstra(final int row, final int col, final int value, final boolean force) {
        if (row < 0 || col < 0 || row >= dijkstra.length || col >= dijkstra[row].length)
            return;
        if (map[row][col] || isRockPresent(row, col))
            return;
        if (dijkstra[row][col] <= value && !force)
            return;

        dijkstra[row][col] = value;
        updateDijkstra(row - 1, col, value + 1, false);
        updateDijkstra(row + 1, col, value + 1, false);
        updateDijkstra(row, col - 1, value + 1, false);
        updateDijkstra(row, col + 1, value + 1, false);
    }

    private final void updateDijkstraGhost(final int row, final int col, final int value, final boolean force) {
        if (row < 0 || col < 0 || row >= dijkstra.length || col >= dijkstra[row].length)
            return;
        if (map[row][col] || isRockPresent(row, col))
            return;
        if (dijkstraGhost[row][col] <= value && !force)
            return;

        dijkstraGhost[row][col] = value;
        updateDijkstraGhost(row - 1, col, value + 1, false);
        updateDijkstraGhost(row + 1, col, value + 1, false);
        updateDijkstraGhost(row, col - 1, value + 1, false);
        updateDijkstraGhost(row, col + 1, value + 1, false);
    }

    private final int dijkstraScore(final int row, final int col) {
        if (row < 0 || col < 0 || row >= dijkstra.length || col >= dijkstra[row].length)
            return Integer.MAX_VALUE;
        return dijkstra[row][col];
    }

    private final int dijkstraGhostScore(final int row, final int col) {
        if (dijkstraGhost == null) {
            dijkstraGhost = new int[map.length][map[indy.row].length];
            for (final int[] part : dijkstraGhost)
                Arrays.fill(part, Integer.MAX_VALUE);
            updateDijkstraGhost(goal.row, goal.col, 0, true);
        }
        if (row < 0 || col < 0 || row >= dijkstra.length || col >= dijkstra[row].length)
            return Integer.MAX_VALUE;
        return dijkstraGhost[row][col];
    }

    private boolean isRockPresent(final int row, final int col) {
        for (final Rock rock : rocks)
            if (rock.isAt(row, col))
                return true;
        return false;
    }

    public boolean isEmpty(final int row, final int col) {
        if (row < 0 || col < 0 || row >= map.length || col >= map[row].length)
            return false;
        return !map[row][col] && !isRockPresent(row, col) && !goal.isAt(row, col);
    }

    public int solve() {
        return solve(0);
    }

    private int solve(final int currentDepth) {
        System.out.println(toString());
        visited.add(this);
        if (isSolved()) {
            setShortestSolution(currentDepth);
            return 0;
        }
        if (currentDepth >= getShortestSolution()) {
            System.out.println("Aborting at depth " + currentDepth + " because we know better: "
                               + getShortestSolution());
            return Integer.MAX_VALUE;
        }
        final Map<Rock, Set<Direction>> nextTries = indy.getMoveableRocks();
        int shortest = Integer.MAX_VALUE - 1;
        for (final Map.Entry<Rock, Set<Direction>> tries : nextTries.entrySet()) {
            final Rock rock = tries.getKey();
            for (final Direction dir : tries.getValue()) {
                final Maze next = new Maze(this, rock, dir);
                if (!isRepeat(next)) {
                    final int nextSolution = next.solve(currentDepth + 1);
                    if (nextSolution < shortest)
                        shortest = nextSolution;
                }
            }
        }
        return shortest + 1;
    }

    public boolean isSolved() {
        return indy.canReachTreasure();
    }

    @Override
    public String toString() {
        if (stringValue == null) {
            final StringBuilder out = new StringBuilder();
            for (int row = 0; row < map.length; row++) {
                if (row == 0) {
                    out.append('\u250C');
                    for (int col = 0; col < map[row].length; col++)
                        out.append('\u2500');
                    out.append("\u2510\n");
                }
                out.append('\u2502');
                for (int col = 0; col < map[row].length; col++) {
                    if (indy.isAt(row, col))
                        out.append('*');
                    else if (goal.isAt(row, col))
                        out.append("$");
                    else if (isRockPresent(row, col))
                        out.append("@");
                    else if (map[row][col])
                        out.append('\u2588');
                    else
                        out.append(base64(dijkstra[row][col]));
                }
                out.append("\u2502\n");
                if (row == map.length - 1) {
                    out.append('\u2514');
                    for (int col = 0; col < map[row].length; col++)
                        out.append('\u2500');
                    out.append("\u2518\n");
                }
            }
            stringValue = out.toString();
        }
        return stringValue;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (!obj.getClass().equals(getClass()))
            return false;
        final Maze other = (Maze) obj;
        if (other.map.length != map.length)
            return false;
        for (int row = 0; row < map.length; row++) {
            if (other.map[row].length != map[row].length)
                return false;
            for (int col = 0; col < map[row].length; col++)
                if (other.map[row][col] != map[row][col])
                    return false;
        }
        return indy.equals(other.indy) && rocks.equals(other.rocks) && goal.equals(other.goal);
    }

    @Override
    public int hashCode() {
        return getClass().hashCode() ^ indy.hashCode() ^ goal.hashCode() ^ rocks.hashCode();
    }

    private final class Goal extends PointOfInterest {
        public Goal(final int row, final int col) {
            super(row, col);
        }
    }

    private final class Indy extends PointOfInterest {
        public Indy(final int row, final int col) {
            super(row, col);
        }

        public boolean canReachTreasure() {
            return dijkstraScore(row, col) < Integer.MAX_VALUE;
        }

        public SortedMap<Rock, Set<Direction>> getMoveableRocks() {
            final SortedMap<Rock, Set<Direction>> out = new TreeMap<>();
            @SuppressWarnings("unchecked")
            final Set<Direction> checked[][] = new Set[map.length][map[row].length];
            lookForRocks(out, checked, row, col, null);
            return out;
        }

        private final void lookForRocks(final Map<Rock, Set<Direction>> rockStore,
                                        final Set<Direction>[][] checked,
                                        final int row,
                                        final int col,
                                        final Direction comingFrom) {
            if (row < 0 || col < 0 || row >= checked.length || col >= checked[row].length)
                return;
            if (checked[row][col] == null)
                checked[row][col] = EnumSet.noneOf(Direction.class);
            if (checked[row][col].contains(comingFrom))
                return;
            for (final Rock rock : rocks) {
                if (rock.row == row && rock.col == col) {
                    if (rock.canBeMoved(comingFrom) && rock.isWorthMoving(comingFrom)) {
                        if (!rockStore.containsKey(rock))
                            rockStore.put(rock, EnumSet.noneOf(Direction.class));
                        rockStore.get(rock).add(comingFrom);
                    }
                    return;
                }
            }
            if (comingFrom != null)
                checked[row][col].add(comingFrom);
            for (final Direction dir : Direction.values())
                if (comingFrom == null || dir != comingFrom.opposite())
                    if (isEmpty(row + dir.drow, col + dir.dcol) || isRockPresent(row + dir.drow, col + dir.dcol))
                        lookForRocks(rockStore, checked, row + dir.drow, col + dir.dcol, dir);
        }
    }

    private final class Rock extends PointOfInterest implements Comparable<Rock> {
        public Rock(final int row, final int col) {
            super(row, col);
        }

        public boolean canBeMoved(final Direction direction) {
            return isEmpty(row + direction.drow, col + direction.dcol);
        }

        public boolean isWorthMoving(final Direction direction) {
            boolean worthIt = false;
            boolean reachable = false;
            int emptyAround = 0;
            for (final Direction dir : Direction.values()) {
                reachable |= (dijkstraScore(row, col) < Integer.MAX_VALUE);
                emptyAround += (isEmpty(row + dir.drow, col + dir.dcol) ? 1 : 0);
                if (dir != direction && dir != direction.opposite()
                    && dijkstraScore(row + dir.drow, col + dir.dcol) < Integer.MAX_VALUE)
                    worthIt = true;
            }
            return (emptyAround < 4) && (worthIt || !reachable);
        }

        public int proximityIndice() {
            final int ds = min(dijkstraScore(row - 1, col),
                               dijkstraScore(row + 1, col),
                               dijkstraScore(row, col - 1),
                               dijkstraScore(row, col + 1));
            if (ds < Integer.MAX_VALUE)
                return ds;
            else
                return min(dijkstraGhostScore(row - 1, col),
                           dijkstraGhostScore(row + 1, col),
                           dijkstraGhostScore(row, col - 1),
                           dijkstraGhostScore(row, col + 1));
        }

        @Override
        public int compareTo(Rock o) {
            return new Integer(proximityIndice()).compareTo(o.proximityIndice());
        }
    }

    private static final char base64(final int i) {
        if (i >= 0 && i <= 9)
            return (char) ('0' + i);
        else if (i < 36)
            return (char) ('A' + (i - 10));
        else
            return ' ';
    }

    private static final int min(final int i1, final int i2, final int... in) {
        int min = Math.min(i1, i2);
        for (final int i : in)
            min = Math.min(min, i);
        return min;
    }
}

12

रूबी - विशाल और फूली हुई

कुछ हद तक भोले-भाले क्रियान्वयन के माध्यम से इसे बलपूर्वक लागू किया जाता है। यह कुछ (नहीं तो) अजीब मामलों में सुपर फास्ट नहीं है। इसे "केवल खजाने के करीब होने पर, हम पहले जांच करना चाहते हैं" की तुलना में बेहतर अनुमान लगाकर सुधार किया जा सकता है, लेकिन सामान्य विचार हैं।

यह आपको यह भी दिखाएगा कि इंडियाना के खजाने के मामले में इंडियाना ने अपने हाथों को कैसे प्राप्त किया।

EMPTY = '0'
WALL = '1'
INDY = '2'
GOAL = '3'
ROCK = '4'

map=%q|8 8
00001000
00000100
00000010
00000010
03004040
10000010
10000100
10000102|

def deep_dup(arr)
  dupl = arr.dup
  (0..dupl.size-1).to_a.each do |i|
    dupl[i] = dupl[i].dup
  end
  return dupl
end

class Map
  @@visited = []
  attr_reader :mapdata, :indy_r, :indy_c, :prev

  def self.parse(str)
    lines = str.split("\n")
    mapdata = []
    indy_r = -1
    indy_c = -1
    lines[1..-1].each_with_index do |line, idx|
      row = ((mapdata ||= [])[idx] ||= [])
      line.split(//).each_with_index do |c, cidx|
        if c==INDY
          indy_r = idx
          indy_c = cidx
          row[cidx] = EMPTY
        else
          row[cidx] = c
        end
      end
    end
    return Map.new(mapdata, indy_r, indy_c)
  end

  def initialize(mapdata, indy_r, indy_c, prev = nil, pushed = false)
    @mapdata = mapdata
    @mapdata.freeze
    @mapdata.each {|x| x.freeze}
    @indy_r = indy_r
    @indy_c = indy_c
    @prev = prev
    @pushed = pushed
  end

  def visit!
    @@visited << self
  end

  def visited?
    @@visited.include?(self)
  end

  def pushes
    pushes = @pushed ? 1 : 0
    if @prev
      pushes += @prev.pushes
    end
    return pushes
  end

  def history
    return @prev ? 1+@prev.history : 0
  end

  def next_maps
    maps = []
    [[-1, 0], [1, 0], [0, -1], [0, 1]].each do |dr, dc|
      new_i_r = self.indy_r + dr
      new_i_c = self.indy_c + dc
      if new_i_r >= 0 && new_i_r < @mapdata.size && new_i_c >= 0 && new_i_c < @mapdata[0].size
        new_map = nil
        pushed = false
        case @mapdata[new_i_r][new_i_c]
        when EMPTY, GOAL then new_map = @mapdata
        when ROCK then
          if @mapdata[new_i_r+dr] && @mapdata[new_i_r+dr][new_i_c+dc] == EMPTY
            new_map = deep_dup(@mapdata)
            new_map[new_i_r][new_i_c] = EMPTY
            new_map[new_i_r+dr][new_i_c+dc] = ROCK
            pushed = true
          end
        end
        if new_map && !@@visited.include?(new_map = Map.new(new_map, new_i_r, new_i_c, self, pushed))
          maps << new_map
        end
      end
    end
    return maps
  end

  def wins?
    return @mapdata[@indy_r][@indy_c] == GOAL
  end

  def to_s
    str = ''
    @mapdata.each_with_index do |row, r|
      row.each_with_index do |col, c|
        if r == @indy_r and c == @indy_c then
          str += 'I'
        else
          case col
          when EMPTY then str += '_'
          when WALL then str+= '#'
          when ROCK then str += 'O'
          when GOAL then str += '$'
          end
        end
      end
      str += "\n"
    end
    return str
  end

  def ==(other)
    return (self.mapdata == other.mapdata) &&
      (self.indy_r == other.indy_r) &&
      (self.indy_c == other.indy_c)
  end

  def dist_to_treasure
    if @distance.nil?
      @mapdata.each_with_index do |r, ri|
        r.each_with_index do |c, ci|
          if c == GOAL
            @distance = Math.sqrt((ri - @indy_r)**2 + (ci - @indy_c)**2)
            return @distance
          end
        end
      end
    end
    return @distance
  end

  def <=>(other)
    dist_diff = self.dist_to_treasure <=> other.dist_to_treasure
    if dist_diff != 0
      return dist_diff
    else
      return self.pushes <=> other.pushes
    end
  end
end

scored = nil
root = Map.parse(map)
to_visit = [root]
until to_visit.empty?
  state = to_visit.pop
  next if state.visited?
  if state.wins? && (scored.nil? || scored.pushes > state.pushes)
    scored = state
  end
  state.visit!
  to_visit += state.next_maps
  to_visit.reject! {|x| x.visited? || (scored && scored.pushes <= x.pushes) }
  to_visit.sort!
  to_visit.reverse!
end

puts scored ? scored.pushes : 'X'
exit(0) unless scored
steps = [scored]
curr = scored
while curr = curr.prev
  steps << curr
end
puts "\nDetails of the path:"
steps.reverse.each_with_index do |step, idx|
  puts "Step ##{idx} (history: #{step.history}, pushes so far: #{step.pushes})"
  puts step
  puts
end

संपादित करें: हालांकि मैं सरल आंदोलन मूल्यांकन को छोड़ने के द्वारा गैर-स्पष्ट स्थितियों (जहां यह वर्तमान में हरे अंडे चूसता हूं) में संभवतः इसके प्रदर्शन में सुधार करने के तरीकों के कारण (जैसे कि केवल इस बात की परवाह करता है कि कब इंडी रॉक और / या खजाने को धक्का देता है)। मैं शायद बाद में कोड को अपडेट करूंगा, एक बार मुझे लागू करने का समय मिल जाएगा।


10

C ++ 14 में से 16

एल्गोरिथ्म अक्षम और स्मृति भूख है। इसके अतिरिक्त मैं इसे ठीक करने के लिए समय नहीं दे सकता था, लेकिन जब मेरे पास अधिक समय होगा;) एक दिलचस्प बात यह है कि मेरा एल्गोरिथ्म प्रश्नकर्ता के समान ही परीक्षण मानचित्र पर विफल रहता है। मेरी प्राचीन नोटबुक पर यह प्रक्रिया T4 और T6 मानचित्रों के लिए स्वैप करना शुरू कर देती है। मैप 3 में काफी लंबा समय लगता है, लेकिन समय में हल हो जाता है। अन्य सभी लगभग तुरंत हल कर रहे हैं। तो मुझे यह पता लगाना होगा कि टी 4 और टी 6 को कैसे हल किया जाए और मशीन पर एल्गोरिदम को अधिक मेमोरी के साथ आज़माया जाए। आखिरकार मैं वहां T4 और T6 को हल कर सकता हूं। मैं पोस्ट को अपडेट रखूंगा ...

नीचे परिणाम है। (एक्स: गलत, ओ: सही ;: कम से कम 10s, रुका हुआ)

Map#         : 0 1 2 3 4 5 12 15 19 T1 T2 T3 T4 T5 T6 T7
C++  (foobar): O O O O O O  O  O  O  O  O  O  ?  O  ?  O
Ruby (Romain): X O O ? O O  O  X  ?  ?  O  ?  ?  ?  ?  ?
Java (Romain): O O X O X X  O  O  ?  ?  O  O  O  X  O  O

जैसा कि स्रोत कोड काफी लंबा है और वास्तव में पढ़ने के लिए अच्छा नहीं है ... मूल रूप से यह सिर्फ उन सभी चट्टानों के लिए दिखता है जो इंडियाना जोन्स तक पहुंच सकते हैं। जिन चट्टानों तक पहुँचा जा सकता है, उनके लिए यह जानकारी संग्रहीत करता है कि इसे किस दिशा में ले जाया जा सकता है। तो वर्तमान नक्शे के लिए संभावित चालों की एक सूची बनाई गई है। इनमें से प्रत्येक संभव चाल के लिए नक्शे की एक प्रति बनाई जाती है और इस कदम को लागू किया जाता है। नए बनाए गए मानचित्रों के लिए, एल्गोरिथ्म फिर से जांच करेगा कि कौन सी चालें लागू की जा सकती हैं ... यह तब तक किया जाता है जब तक कि आगे कोई चाल संभव न हो या खजाना सीने का एक रास्ता मिल जाए। जैसा कि एल्गोरिथ्म पहले सभी चाल की कोशिश करता है जो केवल एक आंदोलन को छाती तक पहुंचने में ले जाएगा, फिर वह सब जो दो ले जाएगा, और इसी तरह ... पहला तरीका भी स्वचालित रूप से सबसे छोटा है। लूप को रोकने के लिए, एल्गोरिथ्म हर नक्शे के लिए याद रखता है कि क्या चालें लागू की जा सकती हैं। यदि एक और नक्शा बनाया जाता है, तो उन चालों की एक सूची में परिणाम होता है जो पहले ही मिल चुके थे, तो वे चुपचाप गिरा दिए जाते हैं, क्योंकि वे पहले से ही संसाधित हो रहे हैं। दुर्भाग्य से हर कदम को केवल एक बार निष्पादित करना संभव नहीं है, क्योंकि ऐसे नक्शे हो सकते हैं जिनके लिए एक ही क्षेत्र में कई बार एक चट्टान को ले जाने की आवश्यकता होती है। वरना मैं बहुत सारी मेमोरी बचा सकता था। इसके अतिरिक्त, मानचित्र 3 जैसे मानचित्रों को समय में हल करने के लिए, एल्गोरिथ्म उन सभी चट्टानों को अनदेखा करता है, जिन्हें चारों ओर से देखा जा सकता है ... इसलिए मानचित्र 3 पर चट्टान को बीच में कहीं नहीं ले जाया जाएगा, लेकिन केवल तब तक जब तक उसके चारों ओर अधिक दीवारें न हों। कोड को g ++ --std = c ++ 0x के साथ g ++ संस्करण 4.4.3 या नए के साथ संकलित किया जा सकता है। हर चाल को केवल एक बार निष्पादित करना संभव नहीं है, क्योंकि ऐसे नक्शे हो सकते हैं जिनमें एक चट्टान को कई बार एक ही क्षेत्र में ले जाने की आवश्यकता होती है। वरना मैं बहुत सारी मेमोरी बचा सकता था। इसके अतिरिक्त, मानचित्र 3 जैसे मानचित्रों को समय में हल करने के लिए, एल्गोरिथ्म उन सभी चट्टानों को अनदेखा करता है, जिन्हें चारों ओर से देखा जा सकता है ... इसलिए मानचित्र 3 पर चट्टान को बीच में कहीं नहीं ले जाया जाएगा, लेकिन केवल तब तक जब तक उसके चारों ओर अधिक दीवारें न हों। कोड को g ++ --std = c ++ 0x के साथ g ++ संस्करण 4.4.3 या नए के साथ संकलित किया जा सकता है। हर चाल को केवल एक बार निष्पादित करना संभव नहीं है, क्योंकि ऐसे नक्शे हो सकते हैं जिनमें एक चट्टान को कई बार एक ही क्षेत्र में ले जाने की आवश्यकता होती है। वरना मैं बहुत सारी मेमोरी बचा सकता था। इसके अतिरिक्त, मानचित्र 3 जैसे मानचित्रों को समय में हल करने के लिए, एल्गोरिथ्म उन सभी चट्टानों को अनदेखा करता है, जिन्हें चारों ओर से देखा जा सकता है ... इसलिए मानचित्र 3 पर चट्टान को बीच में कहीं नहीं ले जाया जाएगा, लेकिन केवल तब तक जब तक उसके चारों ओर अधिक दीवारें न हों। कोड को g ++ --std = c ++ 0x के साथ g ++ संस्करण 4.4.3 या नए के साथ संकलित किया जा सकता है। लेकिन केवल तब तक जब तक कि इसके चारों ओर दीवारें न हों। कोड को g ++ --std = c ++ 0x के साथ g ++ संस्करण 4.4.3 या नए के साथ संकलित किया जा सकता है। लेकिन केवल तब तक जब तक कि इसके चारों ओर दीवारें न हों। कोड को g ++ --std = c ++ 0x के साथ g ++ संस्करण 4.4.3 या नए के साथ संकलित किया जा सकता है।

#include <vector>
#include <iostream>
#include <iterator>
#include <sstream>
#include <unordered_set>
#include <utility>

enum class dir : char {
    up, down, left, right
};

enum class field : char {
    floor, wall, indiana, treasure, rock, border, visited
};

class pos {
    private:
        int x, y;
        field f_type;


    public:
        pos() : x{-1}, y{-1}, f_type{field::border} {}
        pos(int x, int y, field f_type) : x{x}, y{y}, f_type{f_type} {}

        const field& get() {
            return f_type;
        }

        friend class map;
        friend class move;

        bool operator==(const pos& other) const {
            return x == other.x && y == other.y && f_type == other.f_type;
        }
};

class move {
    private:
        pos position;
        dir direction;

    public:
        move(pos& position, dir&& direction) : position(position), direction(direction) {}

        bool operator==(const move& other) const {
            return position == other.position && direction == other.direction;
        }

        int int_value() const {
            return static_cast<char>(direction) + position.x + position.y + static_cast<char>(position.f_type);
        }

        std::string str() const;

        friend class map;
};

std::string move::str() const {
    std::string direction_str;
    switch(direction) {
        case dir::up: direction_str = "up"; break;
        case dir::down: direction_str = "down"; break;
        case dir::left: direction_str = "left"; break;
        case dir::right: direction_str = "right"; break;
    }
    std::ostringstream oss{};
    oss << "move x" << position.x << " y" << position.y << " " << direction_str;
    return oss.str();
}

std::ostream& operator<<(std::ostream& os, const move& move_object) {
    return os << move_object.str();
}


namespace std {
    template<> struct hash< ::move> {
        size_t operator()(const ::move& o) const {
            return hash<int>()(o.int_value());
        }
    };
}


class constellation {
    private:
        const std::unordered_set<move> moves;

    public:
        constellation(const std::unordered_set<move>& moves) : moves(moves) {}

        bool operator==(const constellation& other) const {
            if (moves.size() != other.moves.size()) return false;
            for (auto i = moves.begin(); i != moves.end(); ++i) {
                if (!other.moves.count(*i)) return false;
            }
            return true;
        }

        int int_value() const {
            int v = 0;
            for (auto i = moves.begin(); i != moves.end(); ++i) {
                v += i->int_value();
            }
            return v;
        }
};

namespace std {
    template<> struct hash< ::constellation> {
        size_t operator()(const ::constellation& o) const {
            return hash<int>()(o.int_value());
        }
    };
}


class map {

    private:
        pos* previous;
        pos start, border;
        std::vector< std::vector<pos> > rep;
        void init(const std::string&);

    public:
        map(std::istream& input) : previous{} {
            init(static_cast<std::stringstream const&>(std::stringstream() << input.rdbuf()).str());
        }

        map& move(const move& m) {
            pos source = m.position;
            pos& target = get(source, m.direction);
            target.f_type = source.f_type;
            source.f_type = field::indiana;
            rep[start.y][start.x].f_type = field::floor;
            start = source;
            rep[start.y][start.x].f_type = field::indiana;
            return *this;
        }

        std::string str() const;

        pos& get() { return start; }

        pos& get(pos& position, const dir& direction) {
            int tx = position.x, ty = position.y;
            switch(direction) {
                case dir::up: --ty; break;
                case dir::down: ++ty; break;
                case dir::left: --tx; break;
                case dir::right: ++tx; break;
            }
            previous = &position;
            if (tx >= 0 && ty >= 0 && static_cast<int>(rep.size()) > ty && static_cast<int>(rep[ty].size()) > tx) {
                pos& tmp = rep[ty][tx];
                return tmp;
            }
            border.x = tx;
            border.y = ty;
            return border;
        }

        pos& prev() {
            return *previous;
        }

        void find_moves(std::unordered_set< ::move>& moves, bool& finished) {
            map copy = *this;
            auto& rep = copy.rep;
            bool changed = true;

            while (changed) {
                changed = false;
                for (auto row = rep.begin(); row != rep.end(); ++row) {
                    for (auto col = row->begin(); col != row->end(); ++col) {
                        // check if the field is of interest
                        if (col->f_type == field::floor || col->f_type == field::treasure || col->f_type == field::rock) {
                            // get neighbours
                            pos& up = copy.get(*col, dir::up);
                            pos& down = copy.get(*col, dir::down);
                            pos& left = copy.get(*col, dir::left);
                            pos& right = copy.get(*col, dir::right);
                            // ignore uninteresting rocks
                            if (col->f_type == field::rock && (up.f_type == field::floor || up.f_type == field::indiana || up.f_type == field::visited) && (down.f_type == field::floor || down.f_type == field::indiana || down.f_type == field::visited) && (left.f_type == field::floor || left.f_type == field::indiana || left.f_type == field::visited) && (right.f_type == field::floor || right.f_type == field::indiana || right.f_type == field::visited)) {
                                pos& upper_left = copy.get(up, dir::left);
                                pos& lower_left = copy.get(down, dir::left);
                                pos& upper_right = copy.get(up, dir::right);
                                pos& lower_right = copy.get(down, dir::right);
                                if ((upper_left.f_type == field::floor || upper_left.f_type == field::indiana || upper_left.f_type == field::visited) && (lower_left.f_type == field::floor || lower_left.f_type == field::indiana || lower_left.f_type == field::visited) && (upper_right.f_type == field::floor || upper_right.f_type == field::indiana || upper_right.f_type == field::visited) && (lower_right.f_type == field::floor || lower_right.f_type == field::indiana || lower_right.f_type == field::visited)) {
                                    continue;
                                }
                            }
                            // check if the field can be reached
                            if (up.f_type == field::visited || up.f_type == field::indiana) {
                                if (col->f_type == field::rock && (down.f_type == field::visited || down.f_type == field::floor || down.f_type == field::indiana)) {
                                    auto insertion = moves.insert( ::move(*col, dir::down));
                                    if (insertion.second) {
                                        changed = true;
                                    }
                                }
                                else if (col->f_type == field::floor) {
                                    changed = true;
                                    col->f_type = field::visited;
                                }
                                else if (col->f_type == field::treasure) {
                                    finished = true;
                                    return;
                                }
                            }
                            if (down.f_type == field::visited || down.f_type == field::indiana) {
                                if (col->f_type == field::rock && (up.f_type == field::visited || up.f_type == field::floor || up.f_type == field::indiana)) {
                                    auto insertion = moves.insert( ::move(*col, dir::up));
                                    if (insertion.second) {
                                        changed = true;
                                    }
                                }
                                else if (col->f_type == field::floor) {
                                    changed = true;
                                    col->f_type = field::visited;
                                }
                                else if (col->f_type == field::treasure) {
                                    finished = true;
                                    return;
                                }
                            }
                            if (left.f_type == field::visited || left.f_type == field::indiana) {
                                if (col->f_type == field::rock && (right.f_type == field::visited || right.f_type == field::floor || right.f_type == field::indiana)) {
                                    auto insertion = moves.insert( ::move(*col, dir::right));
                                    if (insertion.second) {
                                        changed = true;
                                    }
                                }
                                else if (col->f_type == field::floor) {
                                    changed = true;
                                    col->f_type = field::visited;
                                }
                                else if (col->f_type == field::treasure) {
                                    finished = true;
                                    return;
                                }
                            }
                            if (right.f_type == field::visited || right.f_type == field::indiana) {
                                if (col->f_type == field::rock && (left.f_type == field::visited || left.f_type == field::floor || left.f_type == field::indiana)) {
                                    auto insertion = moves.insert( ::move(*col, dir::left));
                                    if (insertion.second) {
                                        changed = true;
                                    }
                                }
                                else if (col->f_type == field::floor) {
                                    changed = true;
                                    col->f_type = field::visited;
                                }
                                else if (col->f_type == field::treasure) {
                                    finished = true;
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }

};

void map::init(const std::string& in) {
    bool first = true;

    for(auto i = in.begin(); i != in.end(); ++i) {
        if (*i == '\n') {
           first = false;
            rep.push_back({});
            continue;
        }
        else if (first) continue;

        field tmp(static_cast<field>(*i - '0'));
        pos current(rep.back().size(), rep.size() - 1, tmp);
        switch(tmp) {
            case field::indiana:
                start = current;
            case field::floor:
            case field::wall:
            case field::treasure:
            case field::rock:
                rep.back().push_back(current);
                break;
            default: std::cerr << "Invalid field value '" << (char) (static_cast<char>(tmp) + 48) << '\'' << std::endl;
        }
    }
}

std::string map::str() const {
    std::string t{};
    for (auto row = rep.begin(); row != rep.end(); ++row) {
        for (auto col = row->begin(); col != row->end(); ++col) {
            t += static_cast<char>(col->f_type) + '0';
        }
        t += '\n';
    }
    return t;
}

std::ostream& operator<<(std::ostream& os, const map& map_object) {
    return os << map_object.str();
}

int solve(map&& data) {
    int moves_taken = -1;
    bool finished = false;
    std::vector<map> current_maps{data}, next_maps;
    std::unordered_set<constellation> known_constellations;

    while (!finished && !current_maps.empty()) {
        for (auto i = current_maps.begin(); i != current_maps.end(); ++i) {
            std::unordered_set<move> moves;
            i->find_moves(moves, finished);
            auto result = known_constellations.insert(constellation(moves));
            if (!result.second) {
                continue; // this map constellation was already seen. prevent loops...
            }

            if (finished) break;
            for (auto m = moves.begin(); m != moves.end(); ++m) {
                map map_copy = *i;
                map_copy.move(*m);
                next_maps.push_back(map_copy);
            }


        }
        ++moves_taken;
        current_maps = std::move(next_maps);
    }
    if (!finished && current_maps.empty()) return -1;
    return moves_taken;
}

int main(int argc, char* argv[]) {
    map data{std::cin};

    int moves_taken = solve(std::move(data));
    if (moves_taken == -1) std::cout << "X" << std::endl;
    else std::cout << moves_taken << std::endl;

    return 0;
}

संपादित करें: कार्यक्रम स्टड से इसका इनपुट लेता है और नक्शे के आकार वाली पहली पंक्ति को अनदेखा करता है। यह जांचता है कि क्या मानचित्र में केवल अनुमत वर्णों का उपयोग किया गया है, लेकिन यह सत्यापित नहीं करता है कि केवल एक इंडियाना जोन्स और एक खजाना चेस्ट है। इसलिए एक से अधिक स्थान रखना संभव है और चेस्ट में से किसी एक पर पहुंचने के लिए आवश्यक कम से कम चालें स्टडआउट के लिए मुद्रित होती हैं। मानचित्र में कोई भी अमान्य वर्ण छोड़ दिया जाता है और कार्यक्रम परिणामी नक्शे के लिए कम से कम चालों की गणना करने का प्रयास करेगा। स्टड बंद होने पर गणना शुरू हो जाएगी (मेरे सिस्टम पर ctrl + d)।


1
अच्छा पुनरुत्थान :)। एक चतुर विधर्मी को देखना हमेशा मजेदार होता है।
प्रोग्रामरडान

मैं अपने उत्थान को लेकर दुखी हूं। इसने आपकी प्रतिष्ठा को एक परिपूर्ण 1000 की तुलना में 10 से अधिक बढ़ा दिया
csga5000
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.