Finden von drei Elementen in einem Array, dessen Summe einer bestimmten Zahl am nächsten kommt

Bei einem gegebenen Array von ganzen Zahlen A ₁ , A ₂ , ..., A _n , einschließlich Negativen und Positiven, und einer weiteren ganzen Zahl S. Nun müssen wir drei verschiedene ganze Zahlen im Array finden, deren Summe der gegebenen ganzen Zahl S am nächsten kommt Wenn es mehr als eine Lösung gibt, ist eine davon in Ordnung.

Sie können davon ausgehen, dass alle Ganzzahlen im Bereich int32_t liegen und bei der Berechnung der Summe kein arithmetischer Überlauf auftritt. S ist nichts Besonderes als eine zufällig ausgewählte Zahl.

Gibt es einen anderen effizienten Algorithmus als die Brute-Force-Suche, um die drei ganzen Zahlen zu finden?

Gibt es einen anderen effizienten Algorithmus als die Brute-Force-Suche, um die drei ganzen Zahlen zu finden?

Ja; wir können dies in O (n ² ) Zeit lösen ! Bedenken Sie zunächst, dass Ihr Problem Pauf eine etwas andere Weise äquivalent formuliert werden kann, sodass kein "Zielwert" erforderlich ist:

ursprüngliches Problem P: Gibt es bei einem Array Avon nganzen Zahlen und einem Zielwert Sein 3-Tupel von Adiesen Summen bis S?

modifiziertes Problem P': Gibt es bei einem Array Avon nganzen Zahlen ein 3-Tupel von Adieser Summe bis Null?

Beachten Sie, dass Sie von dieser Version des Problems gehen kann P'von der Pdurch Subtrahieren Ihre S / 3 von jedem Element in A, aber jetzt müssen Sie nicht den Zielwert mehr benötigen.

Wenn wir einfach alle möglichen 3-Tupel testen, lösen wir das Problem in O (n ³ ) - das ist die Brute-Force-Basislinie. Kann man es besser machen? Was ist, wenn wir die Tupel etwas intelligenter auswählen?

Zuerst investieren wir etwas Zeit, um das Array zu sortieren, was uns eine anfängliche Strafe von O (n log n) kostet. Nun führen wir diesen Algorithmus aus:

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.
}

Dieser Algorithmus funktioniert durch drei Zeiger platzieren, i, j, und kan verschiedenen Stellen in der Anordnung. ibeginnt am Anfang und arbeitet sich langsam bis zum Ende vor. kzeigt auf das allerletzte Element. jzeigt darauf, wo ibei begonnen hat. Wir versuchen iterativ, die Elemente an ihren jeweiligen Indizes zu summieren, und jedes Mal passiert eines der folgenden Ereignisse:

• Die Summe ist genau richtig! Wir haben die Antwort gefunden.
• Die Summe war zu klein. Gehen Sie jnäher an das Ende heran, um die nächstgrößere Zahl auszuwählen.
• Die Summe war zu groß. Gehen Sie knäher an den Anfang, um die nächstkleinere Zahl auszuwählen.

Für jeden inähern sich die Zeiger von jund kallmählich an. Irgendwann werden sie sich überholen, und an diesem Punkt müssen wir nichts anderes dafür versuchen i, da wir die gleichen Elemente nur in einer anderen Reihenfolge summieren würden. Nach diesem Punkt versuchen wir den nächsten iund wiederholen.

Schließlich werden wir entweder die nützlichen Möglichkeiten ausschöpfen oder die Lösung finden. Sie können sehen, dass dies O (n ² ) ist, da wir die äußere Schleife O (n) mal ausführen und die innere Schleife O (n) mal ausführen. Es ist möglich, dies subquadratisch zu tun, wenn Sie wirklich Lust haben, indem Sie jede ganze Zahl als Bitvektor darstellen und eine schnelle Fourier-Transformation durchführen, aber das geht über den Rahmen dieser Antwort hinaus.

Hinweis: Da es sich um eine Interviewfrage handelt, habe ich hier ein wenig geschummelt: Dieser Algorithmus ermöglicht die mehrfache Auswahl desselben Elements. Das heißt, (-1, -1, 2) wäre eine gültige Lösung, ebenso wie (0, 0, 0). Es werden auch nur die genauen Antworten gefunden, nicht die nächstgelegene Antwort, wie im Titel erwähnt. Als Übung für den Leser werde ich Sie herausfinden lassen, wie es nur mit bestimmten Elementen (aber es ist eine sehr einfache Änderung) und genauen Antworten (was auch eine einfache Änderung ist) funktioniert.

Dies ist sicherlich eine bessere Lösung, da es leichter zu lesen und daher weniger fehleranfällig ist. Das einzige Problem ist, dass wir einige Codezeilen hinzufügen müssen, um die Mehrfachauswahl eines Elements zu vermeiden.

Eine weitere O (n ^ 2) -Lösung (unter Verwendung eines Hash-Sets).

// 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 Feminellas Lösung hat einen Fehler.

An der Linie

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

Wir müssen prüfen, ob i, j, k alle verschieden sind. Andernfalls, wenn mein Zielelement ist 6und wenn mein Eingabearray enthält {3,2,1,7,9,0,-4,6}. Wenn ich die Tupel ausdrucke, die sich zu 6 summieren, würde ich auch 0,0,6als Ausgabe erhalten. Um dies zu vermeiden, müssen wir die Bedingung auf diese Weise ändern.

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

Wie wäre es mit so etwas, das O (n ^ 2) ist?

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.
        }
    }

Dies stellt fest, ob die Summe von 3 Elementen genau Ihrer Zahl entspricht. Wenn Sie am nächsten kommen möchten, können Sie es so ändern, dass es sich an das kleinste Delta erinnert (Differenz zwischen der Anzahl der aktuellen Tripletts) und am Ende das Triplett druckt, das dem kleinsten Delta entspricht.

Beachten Sie, dass wir ein sortiertes Array haben. Diese Lösung ähnelt Johns Lösung nur darin, dass sie nach der Summe sucht und nicht dasselbe Element wiederholt.

#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));
}

Hier ist der C ++ - Code:

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;
}

Sehr einfache N ^ 2 * logN-Lösung: Sortieren Sie das Eingabearray, gehen Sie dann alle Paare A _i , A _j (N ^ 2-mal) durch und prüfen Sie für jedes Paar, ob (S - A _i - A _j ) im Array ist ( logN Zeit).

Eine andere O (S * N) -Lösung verwendet den klassischen Ansatz der dynamischen Programmierung .

Zusamenfassend:

Erstellen Sie ein 2D-Array V [4] [S + 1]. Füllen Sie es so aus, dass:

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

V 1 [A _i ] = 1 für jedes i, V 1 [x] = 0 für alle anderen x

V [2] [A _i + A _j ] = 1 für jedes i, j. V [2] [x] = 0 für alle anderen x

V [3] [Summe von 3 beliebigen Elementen] = 1.

Um es zu füllen, durchlaufen Sie A _i , für jedes A _i durchlaufen Sie das Array von rechts nach links.

Dies kann in O (n log (n)) wie folgt effizient gelöst werden. Ich gebe eine Lösung, die sagt, ob die Summe von drei Zahlen einer gegebenen Zahl entspricht.

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;
}
}

Reduktion: Ich finde die @ John Feminella-Lösung O (n2) am elegantesten. Wir können immer noch das A [n] reduzieren, in dem nach Tupel gesucht werden soll. Indem Sie A [k] so beobachten, dass alle Elemente in A [0] - A [k] sind, wenn unser Sucharray groß und die Summe (n) wirklich klein ist.

Ein [0] ist Minimum: - Aufsteigendes sortiertes Array.

s = 2A [0] + A [k]: Mit s und A [] können wir A [k] mithilfe der binären Suche in log (n) -Zeit finden.

Hier ist das Programm in Java, das O (N ^ 2) ist.

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);
    }
}

Das Problem kann in O (n ^ 2) gelöst werden, indem das 2-Summen-Problem mit geringfügigen Modifikationen erweitert wird. A ist der Vektor, der Elemente enthält, und B ist die erforderliche Summe.

int Solution :: threeSumClosest (Vektor & 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;

Hier ist der Python3-Code

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

Eine weitere Lösung, die frühzeitig überprüft und fehlschlägt:

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;
    }

Ich habe hier einige Komponententests hinzugefügt: GivenArrayReturnTrueIfThreeElementsSumZeroTest .

Wenn das Set zu viel Speicherplatz belegt, kann ich problemlos ein java.util.BitSet verwenden, das O (n / w) Speicherplatz verwendet .

Programm, um diese drei Elemente zu erhalten. Ich habe gerade zuerst das Array / die Liste sortiert und sie minClosenessbasierend auf jedem Triplett aktualisiert .

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;
}

Ich habe das in n ^ 3 gemacht, mein Pseudocode ist unten;

// Eine HashMap mit dem Schlüssel als Ganzzahl und dem Wert als ArrayList erstellen. // Die Liste mit einer for-Schleife durchlaufen, wobei jeder Wert in der Liste ab dem nächsten Wert erneut iteriert wird.

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

// Wenn die Summe von arr [i] und arr [j] kleiner als die gewünschte Summe ist, besteht die Möglichkeit, eine dritte Ziffer zu finden, also machen Sie eine andere for-Schleife

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

// In diesem Fall suchen wir jetzt nach dem dritten Wert. Wenn die Summe von arr [i] und arr [j] und arr [k] die gewünschte Summe ist, fügen Sie diese zur HashMap hinzu, indem Sie arr [i] zum Schlüssel machen und dann arr [j] und arr [k] hinzufügen die ArrayList im Wert dieses Schlüssels

          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]);}

Danach haben Sie jetzt ein Wörterbuch, in dem alle Einträge die drei Werte darstellen, die zur gewünschten Summe addiert werden. Extrahieren Sie alle diese Einträge mit HashMap-Funktionen. Das hat perfekt funktioniert.