İki dizinin elemanlarını değiştirin, böylece elemanların toplamı farkı az olur.

Question

Röportaj soru:

Verilen olmayan iki sıralı tam sayı dizileri a ve b, onların büyüklüğü n tüm numaraları rastgele seçilir değildir: böyle unsurların toplamı o a ve b unsurlarını, değiştirin a eksi b öğelerinin toplamı minimumdur. örneğe göre

:

a = [ 5 1 3 ] 
b = [ 2 4 9 ] 

sonuç (1 + 2 + 3) '- (4 + 5 + 9) = -12.

Algoritmam: Onları bir arada sıralayın ve ardından en küçük n inçlerini a'a koyun ve b'da bırakın. O (n lg n) zaman ve O (n) uzaydadır. O zaman içinde O (n) ve uzayda O (1) ile bir algoritmaya nasıl geliştirileceğini bilmiyorum. O (1), 1. ve 2. sıralar haricinde daha fazla alana ihtiyaç duymadığımız anlamına gelir.

Herhangi bir fikrin var mı?

Alternatif bir soru şudur: Farklılıkların mutlak değerini en aza indirmeye ihtiyacımız varsa (|sum(a) - sum(b)|'u en aza indirirsek)?

Bir python veya C++ düşüncesi tercih edilir.

Answer 1

Düzeltme çözeltisi:

1. birleştirme listeleri, x = birleştirme hem (a, b). x

2. hesaplama medyan a ve b arasında bu orta değiştirilebilir elemanlar kullanılarak

3. (karmaşıklık O (n) http://en.wikipedia.org/wiki/Selection_algorithm bakınız). O (n)

   en aza indirilmesi mutlak fark NP tamamlanmıştır: bu

   Nihai karmaşıklığı

, orta değerinden daha az olan bir bir öğeyi bulmak daha medyan b aktiviteleri ve takas olduğu Sırt çantası problemine denk olduğu için. Aklıma gelen ne

Answer 2

takip ediyor algoritma anahat:

1. C son # toplamını çıkart C
2. bir hacim B
3. Partitially sıralama #A (A sayısı) Element = C
ilk #A elementler toplamından C B elemanları

sen tüm öğeleri sıralamak gerekmez olduğunu fark etmelidir, th bulmak için yeterlidir En küçük bir elemanın sayısı.İşletme örnek verilmektedir:

1. C = {5, 1, 3, 2, 4, 9}
2. C = {1, 2, 3, 5, 4, 9}
3. (1 + 2 + 3) - (5 + 4 + 9) =

-12 C++ çözeltisi:

#include <iostream> 
#include <vector> 
#include <algorithm> 

int main() 
{ 
    // Initialize 'a' and 'b' 
    int ai[] = { 5, 1, 3 }; 
    int bi[] = { 2, 4, 9 }; 
    std::vector<int> a(ai, ai + 3); 
    std::vector<int> b(bi, bi + 3); 

    // 'c' = 'a' merged with 'b' 
    std::vector<int> c; 
    c.insert(c.end(), a.begin(), a.end()); 
    c.insert(c.end(), b.begin(), b.end()); 

    // partitially sort #a elements of 'c' 
    std::partial_sort(c.begin(), c.begin() + a.size(), c.end()); 

    // build the difference 
    int result = 0; 
    for (auto cit = c.begin(); cit != c.end(); ++cit) 
     result += (cit < c.begin() + a.size()) ? (*cit) : -(*cit); 

    // print result (and it's -12) 
    std::cout << result << std::endl; 
}