Решение 8-головоломка с использованием DFS

Ok, поэтому ваша программа занимает больше времени, чем ожидалось. Сначала мы хотим узнать, застрял ли он в бесконечном цикле или просто медленно. Чтобы сделать это, пусть программа распечатает свой прогресс, добавив в основной цикл следующее:

    int statesVisited = 0;
    while (OPEN.empty() == false && STATE == false) {
        statesVisited++;
        System.out.println(statesVisited);

затем мы видим, что программа посетила пару тысяч государств в секунду. Поскольку наш процессор выполняет несколько миллиардов инструкций в секунду, это означает, что обработка состояния занимает около миллиона инструкций процессора. Этого не должно быть. что высокий, это следует? Так что же могло быть причиной этого?

вообще говоря, теперь мы будем использовать профилировщик, чтобы измерить, в какой части кода все это время тратится, но так как программа настолько коротка, мы можем попробовать угадать сначала. Мое первое предположение, что печать каждого штата, который мы посещаем, может быть довольно дорогой. Чтобы проверить это, давайте напечатаем только каждое 1000-е состояние:

    while (OPEN.empty() == false && STATE == false) {
        statesVisited++;
        if (statesVisited % 1000 == 0) {
            System.out.println(statesVisited);
        }

мы что изменение в месте, мы замечаем что первые 5000 государств посещены внутри под вторым, поэтому печать была действительно значительной. Мы также замечаем кое-что любопытное: в то время как первые 5000 состояний посещаются менее чем за секунду, по какой-то причине программа становится все медленнее и медленнее. При посещении 20000 Штатов требуется около секунды, чтобы посетить 1000 Штатов, и это продолжает ухудшаться. Это неожиданно, так как обработка состояния не должна становиться все более дорогостоящей. Таким образом, мы знаем, что некоторые операции в нашем цикле становятся все более дорогими. Давайте рассмотрим наш код, чтобы определить, какая операция это может быть.

Pushing и popping занимает постоянное время независимо от размера коллекции. Но вы также используете Stack.поиск и LinkedList.содержит. Обе эти операции документированы, чтобы потребовать итерации по всему стеку или списку. Итак, давайте выведем размеры этих коллекций:

        if (statesVisited % 1000 == 0) {
            System.out.println(statesVisited);
            System.out.println(OPEN.size());
            System.out.println(CLOSED.size());
            System.out.println();
        }

подождав немного, мы видим:

40000
25947
39999

таким образом, OPEN содержит 25000 элементов и закрыт почти 40000. Это объясняет, почему обработка состояния продолжает все медленнее и медленнее. Поэтому мы хотим выбрать структуры данных с более эффективной операцией contains, такой как java.util.HashSet или java.util.LinkedHashSet (который является гибридом между хэш-набором и связанным списком, позволяя нам извлекать элементы в порядке их добавления). Делая это, мы получаем:

public static LinkedHashSet<String> OPEN = new LinkedHashSet<String>();
public static HashSet<String> CLOSED = new HashSet<String>();
public static boolean STATE = false;

public static void main(String args[]) {

    int statesVisited = 0;

    String start = "123804765";
    String goal = "281043765";
    String X = "";
    String temp = "";

    OPEN.add(start);

    while (OPEN.isEmpty() == false && STATE == false) {

        X = OPEN.iterator().next();
        OPEN.remove(X);

        int pos = X.indexOf('0'); // get position of ZERO or EMPTY SPACE
        if (X.equals(goal)) {
            System.out.println("SUCCESS");
            STATE = true;
        } else {
            // generate children
            CLOSED.add(X);

            temp = up(X, pos);
            if (!(temp.equals("-1")))
                OPEN.add(temp);
            temp = left(X, pos);
            if (!(temp.equals("-1")))
                OPEN.add(temp);
            temp = down(X, pos);
            if (!(temp.equals("-1")))
                OPEN.add(temp);
            temp = right(X, pos);
            if (!(temp.equals("-1")))
                OPEN.add(temp);
        }
    }

}

/*
 * MOVEMENT UP
 */
public static String up(String s, int p) {
    String str = s;
    if (!(p < 3)) {
        char a = str.charAt(p - 3);
        String newS = str.substring(0, p) + a + str.substring(p + 1);
        str = newS.substring(0, (p - 3)) + '0' + newS.substring(p - 2);
    }
    // Eliminates child of X if its on OPEN or CLOSED
    if (!OPEN.contains(str) && CLOSED.contains(str) == false)
        return str;
    else
        return "-1";
}

/*
 * MOVEMENT DOWN
 */
public static String down(String s, int p) {
    String str = s;
    if (!(p > 5)) {
        char a = str.charAt(p + 3);
        String newS = str.substring(0, p) + a + str.substring(p + 1);
        str = newS.substring(0, (p + 3)) + '0' + newS.substring(p + 4);
    }

    // Eliminates child of X if its on OPEN or CLOSED
    if (!OPEN.contains(str) && CLOSED.contains(str) == false)
        return str;
    else
        return "-1";
}

/*
 * MOVEMENT LEFT
 */
public static String left(String s, int p) {
    String str = s;
    if (p != 0 && p != 3 && p != 7) {
        char a = str.charAt(p - 1);
        String newS = str.substring(0, p) + a + str.substring(p + 1);
        str = newS.substring(0, (p - 1)) + '0' + newS.substring(p);
    }
    // Eliminates child of X if its on OPEN or CLOSED
    if (!OPEN.contains(str) && CLOSED.contains(str) == false)
        return str;
    else
        return "-1";
}

/*
 * MOVEMENT RIGHT
 */
public static String right(String s, int p) {
    String str = s;
    if (p != 2 && p != 5 && p != 8) {
        char a = str.charAt(p + 1);
        String newS = str.substring(0, p) + a + str.substring(p + 1);
        str = newS.substring(0, (p + 1)) + '0' + newS.substring(p + 2);
    }
    // Eliminates child of X if its on OPEN or CLOSED
    if (!OPEN.contains(str) && CLOSED.contains(str) == false)
        return str;
    else
        return "-1";
}

public static void print(String s) {
    System.out.println(s.substring(0, 3));
    System.out.println(s.substring(3, 6));
    System.out.println(s.substring(6, 9));
    System.out.println();
}

, который печатает "успех" почти мгновенно.