Question

在下图中需要编号1到8，使得相邻小区中没有两个数字彼此连续模式：

     *
    ***
    ***
     *

其中每个*包含1到8之间的数字，并且没有两个邻居*是可执行号码。

Answer 1

如果您尝试所有可能的选项，您必须尝试8！选项，但是如果你想一段时间你会注意到有两个单元格有七个邻居（你需要以任何顺序填充1和8）。这些单元格不能填充2到7之间的任何数字，因为每个数字k有两个邻居k + 1和k-1但我们只剩下一个单元格来填充邻居。

Answer 2

假设邻居水平和垂直（不是对角线），贪婪的解决方案是重新洗牌，直到你找到解决方案。您的数组足够小，因此平均需要重试超过24次才能找到匹配项。

import java.util.Random;

public class EightPattern {
    private static Random rnd = new Random();

    /*
     * -0-
     * 123
     * 456
     * -7-
     */
    private static boolean isOK(int[] array) {
        if (       Math.abs(array[0] - array[2]) == 1
                || Math.abs(array[1] - array[2]) == 1
                || Math.abs(array[2] - array[3]) == 1
                || Math.abs(array[1] - array[4]) == 1
                || Math.abs(array[2] - array[5]) == 1
                || Math.abs(array[3] - array[6]) == 1
                || Math.abs(array[4] - array[5]) == 1
                || Math.abs(array[5] - array[6]) == 1
                || Math.abs(array[5] - array[7]) == 1) {
            return false;
        }
        return true;
    }

    //shuffle until you find an isOK solution
    public static void patternShuffle(int[] array) {
        do {
            shuffleArray(array);
        }while(!isOK(array));
    }


    //Fisher–Yates shuffle
    static void shuffleArray(int[] ar) {
        for (int i = ar.length - 1; i > 0; i--) {
            int index = rnd.nextInt(i + 1);
            int a = ar[index];
            ar[index] = ar[i];
            ar[i] = a;
        }
    }

    private static void printPattern(int[] array) {
        System.out.println(" " + array[0]);
        System.out.println("" + array[1] + array[2] + array[3]);
        System.out.println("" + array[4] + array[5] + array[6]);
        System.out.println(" " + array[7]);
    }

    public static void main(String args[]) {
        int[] a = new int[]{1,2,3,4,5,6,7,8};
        patternShuffle(a);
        printPattern(a);
    }   
}

在矩阵中排列八个连续数字，使得没有两个数字相邻

2 个答案: