Bir dizide toplamı belirli bir sayıya en yakın olan üç öğeyi bulma

Negatifler ve pozitifler ve başka bir tamsayı dahil olmak üzere bir tamsayı dizisi, A ₁ , A ₂ , ..., A _n ve başka bir tamsayı S verildi. Şimdi dizide toplamı verilen tamsayı S'ye en yakın olan üç farklı tamsayı bulmamız gerekiyor. Birden fazla çözüm varsa, bunlardan herhangi biri sorun değildir.

Tüm tam sayıların int32_t aralığında olduğunu ve toplamı hesaplarken aritmetik taşma gerçekleşmeyeceğini varsayabilirsiniz. S rastgele seçilmiş bir sayıdan başka özel bir şey değildir.

Üç tamsayıyı bulmak için kaba kuvvet arama dışında verimli bir algoritma var mı?

Üç tamsayıyı bulmak için kaba kuvvet arama dışında verimli bir algoritma var mı?

Evet; Bunu O (n ² ) zamanda çözebiliriz ! İlk olarak, sorununuzun P"hedef değer" ihtiyacını ortadan kaldıran, biraz farklı bir şekilde eşdeğer olarak ifade edilebileceğini düşünün :

Özgün sorun P: bir dizi Verilen Aait ntamsayılar ve bir hedef değer S, yürüyerek 3 tuple orada var yok Ao özetliyor S?

tadil edilmiş bir sorun P': bir dizi göz önüne alındığında Aarasında nbir 3-tuple orada halen mevcut, tam sayılar Asıfır olduğu toplamlarının?

Sorunun bu sürümden gidebilirsiniz Bildirimi P'gelen Pher elemanın adresinin S / 3 çıkarılarak A, ama şimdi artık hedef değeri gerekmez.

Açıkçası, tüm olası 3 tüpleri test edersek, sorunu O (n ³ ) 'te çözerdik - bu kaba kuvvet temelidir. Daha iyisini yapmak mümkün mü? Tupleleri biraz daha akıllıca seçersek ne olur?

İlk olarak, diziyi sıralamak için biraz zaman harcıyoruz, bu da bize O (n log n) 'nin ilk cezasına mal oluyor. Şimdi bu algoritmayı yürütüyoruz:

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

Bu algoritma, üç işaretçiler, yerleştirir ve i, jve kdizi içinde çeşitli noktalarda. ibaşlangıçta başlar ve yavaş yavaş sonuna kadar gider. kson öğeye işaret eder. jnereden ibaşladığını gösterir. Öğeleri tekrar tekrar kendi endekslerinde toplamaya çalışıyoruz ve her seferinde aşağıdakilerden biri gerçekleşiyor:

• Toplam kesinlikle doğru! Cevabı bulduk.
• Toplam çok küçüktü. Taşı jsonraki en büyük sayı seçmek daha yakın ucuna.
• Toplam çok büyüktü. Taşı ksonraki en küçük numarayı seçmek daha yakın başlangıcına.

Her biri için i, bir işaretçi jve kyavaş yavaş daha yakın birbirine alacak. Sonunda birbirlerini geçecekler ve bu noktada bunun için başka bir şey denememiz gerekmiyor i, çünkü aynı unsurları sadece farklı bir düzende toplayacağız. Bu noktadan sonra bir sonrakini dener ive tekrarlarız.

Sonunda, ya yararlı olanakları tüketeceğiz ya da çözümü bulacağız. Dış döngü O (n) kez yürüttüğümüz ve iç döngü O (n) kez yürüttüğümüz için bunun O (n ² ) olduğunu görebilirsiniz . Gerçekten süslü olursanız, her bir tamsayıyı bir bit vektörü olarak temsil ederek ve hızlı bir Fourier dönüşümü gerçekleştirerek bunu alt karesel olarak yapmak mümkündür, ancak bu, bu cevabın kapsamı dışındadır.

Not: Bu bir röportaj sorusu olduğundan, burada biraz hile yaptım: bu algoritma aynı öğenin birden çok kez seçilmesine izin veriyor. Yani, (-1, -1, 2) (0, 0, 0) gibi geçerli bir çözüm olacaktır. Ayrıca başlıktan da bahsedildiği gibi en yakın cevabı değil, sadece kesin cevapları bulur . Okuyucu için bir alıştırma olarak, onu sadece farklı öğelerle (ancak çok basit bir değişiklik) ve kesin cevapları (aynı zamanda basit bir değişikliktir) nasıl çalıştıracağınızı anlamanıza izin vereceğim.

kesinlikle bu daha iyi bir çözümdür çünkü okunması daha kolaydır ve bu nedenle hatalara daha az eğilimlidir. Tek sorun, bir öğenin birden fazla seçimini önlemek için birkaç satır kod eklememiz gerekiyor.

Başka bir O (n ^ 2) çözeltisi (bir hashset kullanarak).

// 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'nın çözümünün bir hatası var.

Hatta

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

İ, j, k'nin farklı olup olmadığını kontrol etmeliyiz. Aksi takdirde, hedef öğem 6varsa ve girdi dizim içeriyorsa {3,2,1,7,9,0,-4,6}. 6'ya ulaşan tüpleri yazdırırsam 0,0,6, çıktı olarak da alırım . Bundan kaçınmak için, durumu bu şekilde değiştirmemiz gerekir.

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

Böyle bir şeye ne dersin, 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.
        }
    }

Bu, 3 öğenin toplamının tam olarak numaranıza eşit olup olmadığını bulur. En yakınını istiyorsanız, en küçük deltayı (geçerli üçlü sayınız arasındaki fark) hatırlamak ve sonunda en küçük deltaya karşılık gelen üçlüyü yazdırmak için değiştirebilirsiniz.

Sıralı bir dizimiz olduğunu unutmayın. Bu çözüm, yalnızca toplamı aradığı ve aynı öğeyi tekrarlamadığı için John'un çözümüne benzer.

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

İşte C ++ kodu:

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

Çok basit N ^ 2 * logN çözümü: giriş dizisini sıralayın, ardından A _i , A _j (N ^ 2 kez) tüm çiftlerini gözden geçirin ve her bir çift için (S - A _i - A _j ) dizisinde ( logN zamanı).

Başka bir O (S * N) çözümü klasik dinamik programlama yaklaşımını kullanır .

Kısacası:

2 boyutlu bir dizi V [4] [S + 1] oluşturun. Öyle bir şekilde doldurun, ki:

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

V 1 [A _i ] = 1 herhangi bir i için, V 1 [x] = 0 diğer tüm x için

V [2] [A _i + A _j ] = 1, herhangi bir i, j için. V [2] [x] = diğer tüm x için 0

V [3] [herhangi bir 3 öğenin toplamı] = 1.

A aracılığıyla, iterate doldurmak için _ben her A için, _ben sağdan sola doğru dizi üzerinden yinelerler.

Bu, O (n log (n)) içinde aşağıdaki gibi verimli bir şekilde çözülebilir. Üç sayının toplamının belirli bir sayıya eşit olup olmadığını söyleyen bir çözüm veriyorum.

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

Azaltma: Sanırım @John Feminella çözeltisi O (n2) en zarif. Hala tuple aramak için A [n] değerini azaltabiliriz. A [k] 'yı gözlemleyerek, arama dizimiz çok büyük ve SUM (s) gerçekten küçük olduğunda tüm elemanlar A [0] - A [k]' da olur.

A [0] minimumdur: - Artan sıralanmış dizi.

s = 2A [0] + A [k]: s ve A [] verildiğinde log (n) zamanında ikili aramayı kullanarak A [k] bulabiliriz.

Java'da O (N ^ 2) olan program

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

Problem 2-toplam problemi küçük değişikliklerle genişleterek O (n ^ 2) 'de çözülebilir. A vektör içeren elementler ve B gerekli toplamdır.

int Çözüm :: threeSumClosest (vektör & 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;

İşte Python3 kodu

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

Erken kontrol ve başarısız olan başka bir çözüm:

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

Buraya bazı birim testleri ekledim: GivenArrayReturnTrueIfThreeElementsSumZeroTest .

Küme çok fazla alan kullanıyorsa, O (n / w) alanı kullanacak bir java.util.BitSet'i kolayca kullanabilirim .

Bu üç unsuru almak için program. Ben sadece dizi / liste ilk sıraladık ve onları minClosenessher üçlüye göre güncelledi .

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

Bunu n ^ 3'te yaptım, sahte kodum aşağıda;

// Tamsayı anahtarı ve değeri ArrayList olarak içeren bir hashMap oluşturun // for döngüsü kullanarak listede yineleme yapın, listedeki her değer bir sonraki değerden başlayarak tekrar yinelenir;

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

// arr [i] ve arr [j] toplamı istenen toplamdan azsa, üçüncü bir rakam bulma potansiyeli vardır, bu yüzden döngü için başka bir tane yapın

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

// bu durumda şimdi üçüncü değeri arıyoruz; arr [i] ve arr [j] ve arr [k] toplamı istenen toplam ise, arr [i] anahtarını yapıp daha sonra arr [j] ve arr [k] ekleyerek bunları HashMap'e ekleyin bu anahtarın değerindeki 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]);}

bundan sonra, istenen toplamı toplayan üç değeri temsil eden tüm girişleri içeren bir sözlüğe sahipsiniz. Tüm bu girdileri HashMap işlevlerini kullanarak ayıklayın. Bu mükemmel çalıştı.