java 8皇后回溯（n更改）

Question

问题是，当我的程序回溯时，它会以某种方式将n变为n-1 你能告诉我这是在我的代码的哪一行发生的吗。 例如：

1. 22步骤02 4 1 3 6 0 0 n在布尔->；布尔值为5 n->；5 i=7 n->；五,
2. 23步骤02 4 1 3 7 0 0 n在布尔->；布尔值为5 n->；布尔值为5 n->；5 i=4 n->；四,
3. 24步骤0 2 4 1 4 7 0 0 n在布尔->；4 i=5 n->；四,

---

正如我们可以看到的，在第22步，我得到了n=5，在第23步，我得到了n=4； 问题：我的代码中的n如何变成n-1

源代码（代码没有任何错误）：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Arrays;

public class Queens {

    public static FileOutputStream Output;
    public static PrintStream file;
    public static int z = 1;
    public static String[] LentosRaides = {"a", "b", "c", "d", "e", "f", "g", "h"};
    public static String[] LentosSkaiciai = {"8", "7", "6", "5", "4", "3", "2", "1"};

    /***********************************************************************
     * Grazinam true jei kitu valdoviu padietis q[n] nesikonfliktuoja su kitomis
     * valdovemis q[0] iki q[n-1]
     ***********************************************************************/
    public static boolean arNuoseklus(int[] q, int n) {
        for (int i = 0; i < n; i++) {
            System.out.println("n in bool -> " + n);
//            System.out.println("i = " +i+ "n = " +n);
//            System.out.println("q[i] = "+q[i]+" q[n] = "+q[n]);
//            System.out.print("q[i] - q[n] = ");
//            System.out.println(q[i] - q[n]);
//            System.out.print(" q[n] - q[i] = ");
//            System.out.println(q[n] - q[i]);
//            System.out.println();


            if (q[i] == q[n]) {
                return false;   // tapati skiltis(kolona)
            }
            if ((q[i] - q[n]) == (n - i)) {
                return false;   // ta pati pagrindine diagonale major

            }
            if ((q[n] - q[i]) == (n - i)) {
                return false;   // ta pati mazesnine diagonale minor
            }

        }
        return true;
    }

    /***********************************************************************
     * Spausdinimas i tekstini faila: Rezultatai.txt ir i output'a
     ***********************************************************************/
    public static void printQueens(int[] q) {
        int N = q.length;
        String Temp[] = new String[N];
        System.out.println(z);
        for (int y = 0; y < N; y++) {
            Temp[y] = (LentosRaides[q[y]] + LentosSkaiciai[y]);
        }

        Arrays.sort(Temp);
        System.out.println(Arrays.asList(Temp));
        file.print(z);
        file.println(Arrays.asList(Temp));
        z++;

        for (int j = 0; j < N; j++) {
            System.out.print(q[j] + " ");
        }

//        System.out.println(" ");
//        System.out.print(" ");
//
//        for (int u = 0; u < N; u++) {
//            System.out.print(" " + LentosRaides[u]);
//        }
//
//        System.out.println();
//
//        for (int i = 0; i < N; i++) {
//            System.out.print(LentosSkaiciai[i] + " ");
//            for (int j = 0; j < N; j++) {
//
//                if (q[i] == j) {
//                    System.out.print("V ");
//                } else {
//                    System.out.print("* ");
//                }
//            }
//
//            System.out.println();
//        }


        System.out.println();
    }

    /***********************************************************************
     *  Visu kombinaciju bandimas naudojant "backtracking'a"
     *  numeravimas -> bandimas pastatyti Valdove nuo 0 iki 7 pozicijos
     *  naudojant patikrinima arNuoseklus
     ***********************************************************************/
    public static void numeravimas2(int N) {
        int[] a = new int[N];
        numeravimas(a, 0);

    }

    public static void numeravimas(int[] q, int n) {
        System.out.println("n -> " + n);
        int N = q.length;

        if (n == N) {
            printQueens(q);
          //  System.out.println("o/ ");

        } else {
            for (int i = 0; i < N; i++) {
                q[n] = i;
                System.out.println(" i =  " + i);
                System.out.println("n -> " + n);
                printQueens(q);
                if (arNuoseklus(q, n)) {
                    numeravimas(q, n + 1);
                }
            }
        }
    }

    public static void main(String[] args) {
        int N = 8;

        try {
            Output = new FileOutputStream("Rezultatai.txt");
            file = new PrintStream(Output);
        } catch (Exception e) {
            System.out.println("Neimanoma pasiekti failo");
        }

        numeravimas2(N);

    }
}

Answer 1

这并不是真的在减少。它在：

public static void numeravimas(int[] q, int n) {
   ...
        for (int i = 0; i < N; i++) {
            ...
            System.out.println("n -> " + n);
             ...
                numeravimas(q, n + 1);
        }
}

所以当n = 5时，它将打印n -> 5{}次。然而，在之间的N打印输出中，调用numeravimas(q, 6)，它本身调用numeravimas(q, 7)。。。因此，您将从i上的for循环和numeravimas的递归调用的组合中得到n的各种值的交织