Question

我遇到了一个面试问题，尽管事实上我一直试图自己解决这个问题，但我认为我需要一些帮助。

我有一个表示空间点的整数数组（正数和负数），两点之间的距离定义为abs（A [i] -A [j]），我需要检查那个距离可以被给定的整数M整除。

情况就是这样：

数组：[ - 3 1 1 0 8 7 1]

M = 3

abs（A [1] -A [2]）= 3（例如，它可以被整数整除）

复杂度应为O（N + M）和空间O（M）

现在这些是问题

1）我知道有一种方法可以考虑夫妻而不使用两个“for循环”的明显解决方案，因为复杂性将是N ^ 2，这是不可取的，但我无法弄清楚如何做到这一点

2）复杂性O（N + M）意味着我需要使用两个for循环而不是另一个循环吗？（我的意思是两个单独的for循环），我想在这里理解的是，如果给出的复杂性可以指导我朝着我应该使用的最佳算法。

3）当规范说整数名称为M且复杂度为O（N + M）时，这是否意味着与整数M和复杂性存在关系，或者只是名称为一样吗？

4）怎么做？

Answer 1

当且仅当它们是mod M的整数倍时，两个点具有相同的M。因此，对于每个此类整数A，请创建一个大小为mod M的整数数组N，并循环遍历N[i]整数，从而影响A[N[i] % M]++。

最后，如果任何条目为>1，那么至少有一对整数是M的倍数。

要实际提取解决方案（即，获取k*M分开的值而不是简单地知道某些值），您可以将A的entires初始化为MAXINT，并分配第一次看到特定A时mod M的值。第二次你有一对有用的值。

Answer 2

这很有效。它在O（M + N）和O（M）额外空间中运行。

    modulus = (num,n)=>{
    if(num<0){
        do{
            num += n;
        }while(num<0);
    }
    return num%n;
}
var arr=[-5,-2,4,7,10,0,8],m=3,mod=[];
for(var index=0;index<m;index++){
    mod[index]=0;
}
for(index=0;index<arr.length;index++){
    mod[modulus(arr[index],m)]++;
}
mod.sort(function(a,b){
    return a-b;
});
if(mod[m-1] > 1){
    console.log(mod[m-1]);
}

我最近在一次采访中遇到了这个问题。所以，我认为你的问题是我被问到的同一个问题的一部分。

Answer 3

在 kotlin 中实现，请检查以下内容：

fun largestSubSetDivisible(array: Array<Int>, m: Int):Int {
    val result = Array(1) { 1 }
    largestSubSetDivisible(array, m = m, result = result)
    return result[0]
}

fun largestSubSetDivisible(
    array: Array<Int>,
    arr: IntArray = IntArray(array.size) { 0 },
    i: Int = 0,
    m: Int,
    result: Array<Int> = Array(1) { 1 }
) {
    fun checkDivisionPair(array: List<Int>, m: Int): Boolean {
        for (j in 0 until array.size - 1) {
            if ((array[j] - array[j + 1]) % m != 0)
                return false
        }
        return true
    }
    if (i == array.size) {
        val count = arr.count { it == 1 }
        if (result[0] < count) {
            val ar = array.filterIndexed { index, _ -> arr[index] == 1 }
            if (checkDivisionPair(ar, m))
                result[0] = count
        }
        return
    }
    arr[i] = 0
    largestSubSetDivisible(array, arr, i + 1, m, result)
    arr[i] = 1
    largestSubSetDivisible(array, arr, i + 1, m, result)
}

Answer 4

您能否分享一下您提供的解决方案的代码。或者通过这条线来澄清你的意思对于每个这样的整数N [i]，影响A [N [i]％M] ++。

对于ex - int [] nArr = new int [] {-3，-2,1,0,8,7,1}; 然后它抛出ArrayIndexOutOfBoundException，因为有些数字是负数

具有可被整数整除的距离的点对

4 个答案: