Question

在接受采访时提到了这个问题。

对于给定的整数n＆gt; = 3，返回一个大小为2n的数组，使得从1到n的每个数字k恰好发生两次，每个数字及其重复间隔一个等于该数的距离。

功能签名：

int* buildArray(int n)

例如，对于n = 3：

3, 1, 2, 1, 3, 2

号码2：第一个位置3和第二个位置6，距离6 - 3 - 1 = 2 号码3：位置1的第一个3和第5个的第二个3，距离5 - 1 - 1 = 3。

对于n = 4：

4, 1, 3, 1, 2, 4, 3, 2

Answer 1

这是exact cover problem，您可以使用Algorithm X解决此问题。（它比Sudoku更好，更简单。）你有以下限制：

每个号码必须使用exaclty两次
阵列中的每个插槽只能由一个数字

对于 n = 3的问题，您将获得以下矩阵：

     [0] [1] [2] [3] [4] [5]  1   2   3
     --- --- --- --- --- --- --- --- ---
#0    X       X               X
#1        X       X           X
#2            X       X       X
#3                X       X   X

#4    X           X               X
#5        X           X           X
#6            X           X       X

#7    X               X               X
#8        X               X           X

列[x]表示使用了广告x;普通x表示已放置数字x。＃0到＃3行描述了可能的位置，＃4到＃6两个位置，＃7和＃8两个可能放置三个。这将产生两个（镜像）解决方案：

2 3 1 2 1 3     (#2 + #4 + #8)
3 1 2 1 3 2     (#1 + #6 + #7)

并非所有 n 都会产生解决方案，例如，没有针对5和6的解决方案。

Answer 2

这是兰福德的问题/序列。

有一个关于SO的相同问题的主题已经实现。 Langford sequence implementation Haskell or C

Answer 3

这是NP完全问题。

然而，使用递归和backtracking可以相当容易地编码，使其成为面试的合适解决方案。它类似于N queens puzzle回溯解决方案（这是我的灵感）。

Java中可立即运行的代码：

import java.util.Arrays;    
public class Test {   
    public static void main(String[] args) {
        for (int i = 3; i < 13; i++) {
            int[] answer = buildArray(i);
            if (answer[0] != 0) {
                System.out.println(i + " " + Arrays.toString(answer));
            }
        }
    }

    public static int[] buildArray(int n) {
        int[] answer = new int[2 * n];
        put(answer, n); // start with placing n, later (n - 1), (n - 2), ..., 1
        return answer;
    }

    private static boolean put(int[] answer, int k) {
        for (int i = 0; i + k + 1 < answer.length; i++) { // try every posiiton
            if (answer[i] == 0 && answer[i + k + 1] == 0) { 
                answer[i] = k;
                answer[i + k + 1] = k;
                if (k == 1) {
                    return true; // we found a solution, escape!
                }
                if (put(answer, k - 1)) {
                    return true; // we found a solution, escape!
                }
                answer[i] = 0;   // step back and erase this placement
                answer[i + k + 1] = 0;
            }
        }
        return false; // still not full solution, continue
    }    
}

输出：

3 [3, 1, 2, 1, 3, 2]
4 [4, 1, 3, 1, 2, 4, 3, 2]
7 [7, 3, 6, 2, 5, 3, 2, 4, 7, 6, 5, 1, 4, 1]
8 [8, 3, 7, 2, 6, 3, 2, 4, 5, 8, 7, 6, 4, 1, 5, 1]
11 [11, 6, 10, 2, 9, 3, 2, 8, 6, 3, 7, 5, 11, 10, 9, 4, 8, 5, 7, 1, 4, 1]
12 [12, 10, 11, 6, 4, 5, 9, 7, 8, 4, 6, 5, 10, 12, 11, 7, 9, 8, 3, 1, 2, 1, 3, 2]

编写一个算法来返回一个数组，使得1..n中的每个数字k恰好发生两次，与其副本相距k距离

3 个答案: