Question

任务您会得到一个排序的整数数组arr。它包含几个唯一的整数（负数，正数或零）。

您的任务是找到最大的d，以使a + b + c = d，其中a，b，c和d是arr的不同元素。如果找不到这样的元素d，则返回null。

示例：

对于arr = [2,3,5,7,12]，输出应为12（此数组正确传递了我的函数）

对于arr = [-100，-1,0,7,101]，输出应为0（此不通过）

我可以管理正数检查，但是我的功能由于负数而失败了

function findD(arr) {

    myArr = arr.sort((a, b) => b - a);

    for (var i = 0; i < myArr.length; i++) {

        for (var k = i + 1; k < myArr.length - 2; k++) {

            var j = k + 1,
                d = myArr.length - 1;

            while (j < d) {

                let sum = myArr[k] + myArr[j] + myArr[d];

                if (sum == myArr[i]) {
                    return myArr[i];
                } else if (sum < myArr[i]) {
                    d--;
                } else if (sum > myArr[i]) {
                    j++;
                }
            }
        }
    }
    return null
}

如何处理数组中的负值？

Answer 1

让我们想象一下像[-2, -1, 0, 3]这样的数组。

然后，按照您的算法将其降序排序后，它将为[3, 0, -1, -2]。显然，您假设3必须大于其余d位置的数字，因此您的算法只会选择3。那当然是错的。您不应该假设a，b和c必然小于d。因此，当d占据与a,b,c相关的所有可能位置时，您必须检查其他情况。因此，首先考虑一种具有O(n^4)时间和O(1)空间复杂性的蛮力方法：

...
for (var i = myArr.length; i >= 0 ; i--) {
    for (var k = 0; k < myArr.length; k++) {
        if (k == i) {
            continue
        }
        for (var j = k + 1; j < myArr.length; j++) {
            if (j == i) {
                continue
            }
            for (var d = j + 1; d < myArr.length; d++) {
                if (d == i) {
                    continue
                }
                if (myArr[i] == myArr[k] + myArr[j] + myArr[d]) {
                    return myArr[i]
                }     
            }
        }
    }
}
return null 
...

但是这个问题可以在O(n^2)时间和O(n^2)空间中解决。

首先，我们应该认识到a + b = d - c。

因此，对于给定的数组arr和每对索引i,j: i<j，我们将arr[i] + arr[j]（a + b）存储为键，将i,j对存储为键。 sumsMap中的值项（该值是索引对的列表）。该值必须是一个列表，因为可以有几对索引对应于同一和a + b。

然后，再次遍历每对索引k,l，并检查密钥arr[l] - arr[k]（d - c）或arr[k] - arr[l]（c - d）是否在{ {1}}。如果是，并且索引sumsMap与l,k中的索引不同，则如果最大元素小于sumsMap[s]，则更新最大元素。

arr[l]

Answer 2

我为您将Renaldo建议的功能从https://www.geeksforgeeks.org/find-largest-d-in-array-such-that-a-b-c-d/转换为JavaScript。

function findLargestd(S, n){ 
    var found = false;

    // sort the array in 
    // ascending order 
    S.sort((a, b) => a - b); 

    // iterating from backwards to 
    // find the required largest d 
    for(var i = n - 1; i >= 0; i--){ 
        for(var j = 0; j < n; j++){ 

            // since all four a, b, c,  
            // d should be distinct 
            if(i == j){
                continue;
            } 

            for(var k = j + 1; k < n; k++){ 
                if(i == k){
                    continue;
                }

                for(var l = k + 1; l < n; l++){ 
                    if(i == l){
                        continue;
                    } 

                    // if the current combination   
                    // of j, k, l in the set is  
                    // equal to S[i] return this  
                    // value as this would be the  
                    // largest d since we are   
                    // iterating in descending order  
                    if(S[i] == S[j] + S[k] + S[l]){ 
                        found = true; 
                        return S[i]; 
                    } 
                } 
            } 
        } 
    } 

    //if not found, return 0
    if(found === false){
        return 0; 
    }
}

在数组中找到最大的d，使得a + b + c = d

2 个答案: