주어진 숫자에 가장 가까운 합계를 가진 배열에서 세 개의 요소 찾기

음수와 양수를 포함한 정수 배열 A ₁ , A ₂ , ..., A _n 과 다른 정수 S가 주어지면 이제는 주어진 정수 S에 가장 가까운 세 개의 다른 정수를 찾아야합니다. 솔루션이 둘 이상 존재하면 둘 중 하나라도 괜찮습니다.

모든 정수가 int32_t 범위 내에 있다고 가정하면 합계를 계산할 때 산술 오버플로가 발생하지 않습니다. S는 무작위로 선택된 숫자에 지나지 않습니다.

세 개의 정수를 찾기 위해 무차별 대입 검색 이외의 효율적인 알고리즘이 있습니까?

세 개의 정수를 찾기 위해 무차별 대입 검색 이외의 효율적인 알고리즘이 있습니까?

네; 우리는 이것을 O (n ² ) 시간 안에 해결할 수 있습니다 ! 먼저, P"목표 값"의 필요성을 제거하면서 약간 다른 방식으로 문제를 표현할 수 있다고 생각하십시오 .

원래의 문제 P: 배열을 지정해 A의 n정수와 목표 값 S으로부터 3 튜플이 존재 A하는 그 합계를 S?

수정 된 문제 P': 정수 배열 A이 주어지면 그 합계에서 0 n으로 3 튜플 A이 있습니까?

의 각 요소에서 S / 3를 빼서이 버전의 문제 P'에서 P벗어날 수 A있지만 이제 목표 값이 더 이상 필요하지 않습니다.

분명히 가능한 모든 3 튜플을 간단히 테스트한다면 O (n ³ ) 에서 문제를 해결할 것 입니다. 이것이 무차별 기준입니다. 더 잘할 수 있습니까? 우리가 다소 똑똑한 방식으로 튜플을 선택하면 어떻게 되나요?

먼저 배열을 정렬하는 데 약간의 시간이 걸리므로 초기 페널티는 O (n log n)입니다. 이제이 알고리즘을 실행합니다 :

for (i in 1..n-2) {
  j = i+1  // Start right after i.
  k = n    // Start at the end of the array.

  while (k >= j) {
    // We got a match! All done.
    if (A[i] + A[j] + A[k] == 0) return (A[i], A[j], A[k])

    // We didn't match. Let's try to get a little closer:
    //   If the sum was too big, decrement k.
    //   If the sum was too small, increment j.
    (A[i] + A[j] + A[k] > 0) ? k-- : j++
  }
  // When the while-loop finishes, j and k have passed each other and there's
  // no more useful combinations that we can try with this i.
}

이 알고리즘은 세 가지 포인터 배치하여 작동 i, j및 k배열의 여러 지점에서. i처음부터 시작하여 천천히 끝까지 작동합니다. k가장 마지막 요소를 가리 킵니다. j어디에서 i시작했는지 가리 킵니다 . 우리는 반복적으로 각 지수에서 요소를 합산하려고 시도하며 매번 다음 중 하나가 발생합니다.

• 합은 정확히 맞습니다! 답을 찾았습니다.
• 합계가 너무 작습니다. j다음으로 가장 큰 숫자를 선택하려면 끝까지 더 가까이 이동 하십시오.
• 합계가 너무 큽니다. k다음 가장 작은 숫자를 선택하려면 처음에 더 가까이 이동 하십시오.

각각의 경우 i의 포인터 j와는 k점점 더 가까이 서로 얻을 것이다. 결국 그들은 서로를 통과 할 것이고, 그 시점에서 우리는 다른 i요소를 다른 순서로 합산하기 때문에 다른 것을 시도 할 필요가 없습니다 . 그 후, 우리는 다음을 시도 i하고 반복합니다.

결국 우리는 유용한 가능성을 소진하거나 해결책을 찾을 것입니다. 외부 루프 O (n) 시간을 실행하고 내부 루프 O (n) 시간을 실행하기 때문에 이것이 O (n ² ) 임을 알 수 있습니다 . 각 정수를 비트 벡터로 표현하고 빠른 푸리에 변환을 수행하여 정말 멋진 경우이 점을 차등 적으로 수행 할 수는 있지만이 답변의 범위를 벗어납니다.

참고 : 이것은 인터뷰 질문이기 때문에 여기에서 약간 부정했습니다.이 알고리즘은 동일한 요소를 여러 번 선택할 수 있습니다. 즉, (-1, -1, 2)는 (0, 0, 0)과 마찬가지로 유효한 솔루션입니다. 제목에서 언급했듯이 가장 가까운 답이 아닌 정확한 답만 찾습니다 . 독자들에게 연습으로, 당신은 그것이 독특한 요소들 (매우 간단한 변화 임)과 정확한 답변들 (또한 간단한 변화이기도 함)에서만 작동하게하는 방법을 알아낼 것입니다.

확실히 읽기 쉽고 오류가 적기 때문에 더 나은 솔루션입니다. 유일한 문제는 한 요소를 여러 개 선택하지 않도록 몇 줄의 코드를 추가해야한다는 것입니다.

다른 O (n ^ 2) 솔루션 (해시 셋 사용).

// K is the sum that we are looking for
for i 1..n
    int s1 = K - A[i]
    for j 1..i
        int s2 = s1 - A[j]
        if (set.contains(s2))
            print the numbers
    set.add(A[i])

John Feminella의 솔루션에 버그가 있습니다.

라인에서

if (A[i] + A[j] + A[k] == 0) return (A[i], A[j], A[k])

i, j, k가 모두 다른지 확인해야합니다. 그렇지 않으면 내 대상 요소가 6있고 입력 배열에 포함 된 경우 {3,2,1,7,9,0,-4,6}. 6에 해당하는 튜플을 인쇄하면 0,0,6output으로 얻을 수 있습니다. 이를 피하려면 이런 식으로 조건을 수정해야합니다.

if ((A[i] + A[j] + A[k] == 0) && (i!=j) && (i!=k) && (j!=k)) return (A[i], A[j], A[k])

O (n ^ 2)와 같은 것은 어떻습니까?

for(each ele in the sorted array)
{
    ele = arr[i] - YOUR_NUMBER;
    let front be the pointer to the front of the array;
    let rear be the pointer to the rear element of the array.;

    // till front is not greater than rear.                    
    while(front <= rear)
    {
        if(*front + *rear == ele)
        {
            print "Found triplet "<<*front<<","<<*rear<<","<<ele<<endl;
            break;
        }
        else
        {
            // sum is > ele, so we need to decrease the sum by decrementing rear pointer.
            if((*front + *rear) > ele)
                decrement rear pointer.
            // sum is < ele, so we need to increase the sum by incrementing the front pointer.
            else
                increment front pointer.
        }
    }

3 개의 요소의 합이 정확히 숫자와 같은지 확인합니다. 가장 가까운 곳을 원하면 가장 작은 델타 (현재 삼중 항 수의 차이)를 기억하도록 수정하고 마지막에 가장 작은 델타에 해당하는 삼중 항을 인쇄 할 수 있습니다.

정렬 된 배열이 있습니다. 이 솔루션은 John의 솔루션과 유사하지만 합계를 찾고 동일한 요소를 반복하지 않습니다.

#include <stdio.h>;

int checkForSum (int arr[], int len, int sum) { //arr is sorted
    int i;
    for (i = 0; i < len ; i++) {
        int left = i + 1;
        int right = len - 1;
        while (right > left) {
            printf ("values are %d %d %d\n", arr[i], arr[left], arr[right]);
            if (arr[right] + arr[left] + arr[i] - sum == 0) {
                printf ("final values are %d %d %d\n", arr[i], arr[left], arr[right]);
                return 1;
            }
            if (arr[right] + arr[left] + arr[i] - sum > 0)
                right--;
            else
                left++;
        }
    }
    return -1;
}
int main (int argc, char **argv) {
    int arr[] = {-99, -45, -6, -5, 0, 9, 12, 16, 21, 29};
    int sum = 4;
    printf ("check for sum %d in arr is %d\n", sum, checkForSum(arr, 10, sum));
}

C ++ 코드는 다음과 같습니다.

bool FindSumZero(int a[], int n, int& x, int& y, int& z)
{
    if (n < 3)
        return false;

    sort(a, a+n);

    for (int i = 0; i < n-2; ++i)
    {
        int j = i+1;
        int k = n-1;

        while (k >= j)
        {
            int s = a[i]+a[j]+a[k];

            if (s == 0 && i != j && j != k && k != i)
            {
                x = a[i], y = a[j], z = a[k];
                return true;
            }

            if (s > 0)
                --k;
            else
                ++j;
        }
    }

    return false;
}

매우 간단한 N ^ 2 * logN 솔루션 : 입력 배열을 정렬 한 다음 모든 쌍 A _i , A _j (N ^ 2 시간)를 거치고 각 쌍에 대해 (S-A _i -A _j )가 배열에 있는지 확인하십시오 ( logN 시간).

다른 O (S * N) 솔루션은 클래식 동적 프로그래밍 방식을 사용합니다.

한마디로 :

2 차원 배열 V [4] [S + 1]을 만듭니다. 그런 식으로 채우십시오.

V [0] [0] = 1, V [0] [x] = 0;

모든 i의 경우 V 1 [A _i ] = 1, 다른 모든 x의 경우 V 1 [x] = 0

V [2] [A _i + A _j ] = 1, 임의의 i에 대해, j. 다른 모든 x에 대해 V [2] [x] = 0

V [3] [3 개 원소의 합] = 1

관통 반복, 그것을 입력하고 _난 각 A에서, _I 오른쪽에서 왼쪽으로 배열을 반복.

이것은 다음과 같이 O (n log (n))에서 효율적으로 해결 될 수 있습니다. 세 숫자의 합이 주어진 숫자와 같은지 알려주는 솔루션을 제공하고 있습니다.

import java.util.*;
public class MainClass {
        public static void main(String[] args) {
        int[] a = {-1, 0, 1, 2, 3, 5, -4, 6};
        System.out.println(((Object) isThreeSumEqualsTarget(a, 11)).toString());
}

public static boolean isThreeSumEqualsTarget(int[] array, int targetNumber) {

    //O(n log (n))
    Arrays.sort(array);
    System.out.println(Arrays.toString(array));

    int leftIndex = 0;
    int rightIndex = array.length - 1;

    //O(n)
    while (leftIndex + 1 < rightIndex - 1) {
        //take sum of two corners
        int sum = array[leftIndex] + array[rightIndex];
        //find if the number matches exactly. Or get the closest match.
        //here i am not storing closest matches. You can do it for yourself.
        //O(log (n)) complexity
        int binarySearchClosestIndex = binarySearch(leftIndex + 1, rightIndex - 1, targetNumber - sum, array);
        //if exact match is found, we already got the answer
        if (-1 == binarySearchClosestIndex) {
            System.out.println(("combo is " + array[leftIndex] + ", " + array[rightIndex] + ", " + (targetNumber - sum)));
            return true;
        }
        //if exact match is not found, we have to decide which pointer, left or right to move inwards
        //we are here means , either we are on left end or on right end
        else {

            //we ended up searching towards start of array,i.e. we need a lesser sum , lets move inwards from right
            //we need to have a lower sum, lets decrease right index
            if (binarySearchClosestIndex == leftIndex + 1) {
                rightIndex--;
            } else if (binarySearchClosestIndex == rightIndex - 1) {
                //we need to have a higher sum, lets decrease right index
                leftIndex++;
            }
        }
    }
    return false;
}

public static int binarySearch(int start, int end, int elem, int[] array) {
    int mid = 0;
    while (start <= end) {
        mid = (start + end) >>> 1;
        if (elem < array[mid]) {
            end = mid - 1;
        } else if (elem > array[mid]) {
            start = mid + 1;
        } else {
            //exact match case
            //Suits more for this particular case to return -1
            return -1;
        }
    }
    return mid;
}
}

감소 : @ John Feminella 솔루션 O (n2)가 가장 우아하다고 생각합니다. 튜플을 검색 할 A [n]을 여전히 줄일 수 있습니다. 검색 배열이 크고 SUM이 실제로 작을 때 모든 요소가 A [0]-A [k]에 있도록 A [k]를 관찰합니다.

A [0]은 최소입니다 :-오름차순 정렬 된 배열.

s = 2A [0] + A [k] : s 및 A []가 주어지면 log (n) 시간의 이진 검색을 사용하여 A [k]를 찾을 수 있습니다.

여기에 O (N ^ 2) 인 Java 프로그램이 있습니다.

import java.util.Stack;


public class GetTripletPair {

    /** Set a value for target sum */
    public static final int TARGET_SUM = 32;

    private Stack<Integer> stack = new Stack<Integer>();

    /** Store the sum of current elements stored in stack */
    private int sumInStack = 0;
    private int count =0 ;


    public void populateSubset(int[] data, int fromIndex, int endIndex) {

        /*
        * Check if sum of elements stored in Stack is equal to the expected
        * target sum.
        * 
        * If so, call print method to print the candidate satisfied result.
        */
        if (sumInStack == TARGET_SUM) {
            print(stack);
        }

        for (int currentIndex = fromIndex; currentIndex < endIndex; currentIndex++) {

            if (sumInStack + data[currentIndex] <= TARGET_SUM) {
                ++count;
                stack.push(data[currentIndex]);
                sumInStack += data[currentIndex];

                /*
                * Make the currentIndex +1, and then use recursion to proceed
                * further.
                */
                populateSubset(data, currentIndex + 1, endIndex);
                --count;
                sumInStack -= (Integer) stack.pop();
            }else{
            return;
        }
        }
    }

    /**
    * Print satisfied result. i.e. 15 = 4+6+5
    */

    private void print(Stack<Integer> stack) {
        StringBuilder sb = new StringBuilder();
        sb.append(TARGET_SUM).append(" = ");
        for (Integer i : stack) {
            sb.append(i).append("+");
        }
        System.out.println(sb.deleteCharAt(sb.length() - 1).toString());
    }

    private static final int[] DATA = {4,13,14,15,17};

    public static void main(String[] args) {
        GetAllSubsetByStack get = new GetAllSubsetByStack();
        get.populateSubset(DATA, 0, DATA.length);
    }
}

약간의 수정만으로 2-sum 문제를 확장하여 O (n ^ 2)에서 문제를 해결할 수 있습니다 .A는 요소를 포함하는 벡터이고 B는 필요한 합계입니다.

int 솔루션 :: threeSumClosest (벡터 & A, int B) {

sort(A.begin(),A.end());

int k=0,i,j,closest,val;int diff=INT_MAX;

while(k<A.size()-2)
{
    i=k+1;
    j=A.size()-1;

    while(i<j)
    {
        val=A[i]+A[j]+A[k];
        if(val==B) return B;
        if(abs(B-val)<diff)
        {
            diff=abs(B-val);
            closest=val;
        }
        if(B>val)
        ++i;
        if(B<val) 
        --j;
    }
    ++k;

}
return closest;

다음은 Python3 코드입니다

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        result = set()
        nums.sort()
        L = len(nums)     
        for i in range(L):
            if i > 0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1,L):
                if j > i + 1 and nums[j] == nums[j-1]:
                    continue  
                l = j+1
                r = L -1
                while l <= r:
                    sum = nums[i] + nums[j] + nums[l]
                    result.add(sum)
                    l = l + 1
                    while l<=r and nums[l] == nums[l-1]:
                        l = l + 1
        result = list(result)
        min = result[0]
        for i in range(1,len(result)):
            if abs(target - result[i]) < abs(target - min):
                min = result[i]
        return min

일찍 확인하고 실패하는 또 다른 솔루션 :

public boolean solution(int[] input) {
        int length = input.length;

        if (length < 3) {
            return false;
        }

        // x + y + z = 0  => -z = x + y
        final Set<Integer> z = new HashSet<>(length);
        int zeroCounter = 0, sum; // if they're more than 3 zeros we're done

        for (int element : input) {
            if (element < 0) {
                z.add(element);
            }

            if (element == 0) {
                ++zeroCounter;
                if (zeroCounter >= 3) {
                    return true;
                }
            }
        }

        if (z.isEmpty() || z.size() == length || (z.size() + zeroCounter == length)) {
            return false;
        } else {
            for (int x = 0; x < length; ++x) {
                for (int y = x + 1; y < length; ++y) {
                    sum = input[x] + input[y]; // will use it as inverse addition
                    if (sum < 0) {
                        continue;
                    }
                    if (z.contains(sum * -1)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

GivenArrayReturnTrueIfThreeElementsSumZeroTest 에 몇 가지 단위 테스트를 추가 했습니다 .

세트가 너무 많은 공간을 사용하는 경우 O (n / w) 공간을 사용하는 java.util.BitSet을 쉽게 사용할 수 있습니다 .

이 세 가지 요소를 얻도록 프로그램하십시오. 방금 배열 / 목록을 정렬하고 minCloseness각 삼중 항을 기반으로 업데이트했습니다 .

public int[] threeSumClosest(ArrayList<Integer> A, int B) {
    Collections.sort(A);
    int ansSum = 0;
    int ans[] = new int[3];
    int minCloseness = Integer.MAX_VALUE;
    for (int i = 0; i < A.size()-2; i++){
        int j = i+1;
        int k = A.size()-1;
        while (j < k){
            int sum = A.get(i) + A.get(j) + A.get(k);
            if (sum < B){
                j++;
            }else{
                k--;
            }
            if (minCloseness >  Math.abs(sum - B)){
                minCloseness = Math.abs(sum - B);
                ans[0] = A.get(i); ans[1] = A.get(j); ans[2] = A.get(k);
            }
        }
    }
    return ans;
}

나는 이것을 n ^ 3에서했는데 내 의사 코드는 다음과 같습니다.

// 키를 정수로 사용하고 hashList를 ArrayList로 사용하여 hashMap을 생성합니다. // for 루프를 사용하여리스트를 반복합니다.

for (int i=0; i<=arr.length-1 ; i++){
    for (int j=i+1; j<=arr.length-1;j++){

// arr [i]와 arr [j]의 합이 원하는 합보다 작 으면 세 번째 숫자를 찾을 가능성이 있으므로 다른 for 루프를 수행하십시오.

      if (arr[i]+arr[j] < sum){
        for (int k= j+1; k<=arr.length-1;k++)

//이 경우 우리는 이제 세 번째 가치를 찾고 있습니다. arr [i]와 arr [j]와 arr [k]의 합이 원하는 합이라면 arr [i]를 키로 만든 다음 arr [j]와 arr [k]를 해당 키의 값에있는 ArrayList

          if (arr[i]+arr[j]+arr[k] ==  sum){              
              map.put(arr[i],new ArrayList<Integer>());
              map.get(arr[i]).add(arr[j]);
              map.get(arr[i]).add(arr[k]);}

이 후에는 원하는 합계에 추가되는 세 개의 값을 나타내는 모든 항목이 포함 된 사전이 생겼습니다. HashMap 함수를 사용하여 이러한 모든 항목을 추출하십시오. 이것은 완벽하게 작동했습니다.