Tính trung vị của một tỷ số

Nếu bạn có một tỷ số và một trăm máy tính, cách tốt nhất để xác định trung vị của các số này là gì?

Một giải pháp mà tôi có là:

• Chia bộ bằng nhau giữa các máy tính.
• Sắp xếp chúng.
• Tìm trung vị cho mỗi bộ.
• Sắp xếp các bộ trên trung vị.
• Hợp nhất hai bộ tại một thời điểm từ trung bình thấp nhất đến trung bình cao nhất.

Nếu m1 < m2 < m3 ...trước tiên chúng ta đã hợp nhất Set1và Set2trong tập kết quả, chúng ta có thể loại bỏ tất cả các số thấp hơn trung vị của Set12(đã hợp nhất). Vì vậy, tại bất kỳ thời điểm nào chúng ta có bộ kích thước bằng nhau. Bằng cách này, điều này không thể được thực hiện theo cách song song. Có ý kiến ​​gì không?

Ah, bộ não của tôi vừa mới khởi động, tôi có một gợi ý hợp lý bây giờ. Có lẽ đã quá muộn nếu đây là một cuộc phỏng vấn, nhưng đừng bận tâm:

Máy 1 sẽ được gọi là "máy điều khiển" và để tranh luận, nó sẽ bắt đầu với tất cả dữ liệu và gửi nó bằng bưu kiện cho 99 máy khác, hoặc nếu không thì dữ liệu bắt đầu phân bổ đều giữa các máy và nó gửi 1/99 dữ liệu của nó cho từng người khác. Các phân vùng không phải bằng nhau, chỉ cần đóng.

Mỗi máy khác sắp xếp dữ liệu của nó và thực hiện theo cách ưu tiên tìm các giá trị thấp hơn trước. Vì vậy, ví dụ quicksort, luôn sắp xếp phần dưới của phân vùng trước [*]. Nó ghi dữ liệu của nó trở lại máy điều khiển theo thứ tự tăng ngay khi có thể (sử dụng IO không đồng bộ để tiếp tục sắp xếp và có thể với Nagle trên: thử nghiệm một chút).

Máy điều khiển thực hiện hợp nhất 99 chiều trên dữ liệu khi nó đến, nhưng loại bỏ dữ liệu đã hợp nhất, chỉ giữ số lượng giá trị mà nó đã thấy. Nó tính toán trung vị là giá trị trung bình của 1/2 tỷ và 1/2 tỷ cộng với các giá trị oneth.

Điều này bị vấn đề "chậm nhất trong đàn". Thuật toán không thể hoàn thành cho đến khi mọi giá trị nhỏ hơn giá trị trung bình được gửi bởi một máy phân loại. Có một cơ hội hợp lý rằng một giá trị như vậy sẽ khá cao trong phạm vi dữ liệu của nó. Vì vậy, khi phân vùng dữ liệu ban đầu hoàn tất, thời gian chạy ước tính là sự kết hợp thời gian để sắp xếp 1/99 dữ liệu và gửi lại cho máy tính điều khiển và thời gian để điều khiển đọc 1/2 dữ liệu . "Sự kết hợp" nằm ở đâu đó giữa mức tối đa và tổng của những khoảng thời gian đó, có thể gần với mức tối đa.

Bản năng của tôi là để gửi dữ liệu qua mạng nhanh hơn so với việc sắp xếp nó (chứ đừng nói là chọn trung vị), nó cần phải là một mạng nhanh khá chết tiệt. Có thể là một triển vọng tốt hơn nếu mạng có thể được coi là tức thời, ví dụ nếu bạn có 100 lõi với quyền truy cập tương đương vào RAM chứa dữ liệu.

Vì I / O mạng có khả năng bị ràng buộc, nên có thể có một số thủ thuật bạn có thể chơi, ít nhất là đối với dữ liệu quay trở lại máy điều khiển. Ví dụ: thay vì gửi "1,2,3, .. 100", có lẽ một máy sắp xếp có thể gửi một thông điệp có nghĩa là "100 giá trị nhỏ hơn 101". Sau đó, máy điều khiển có thể thực hiện hợp nhất đã sửa đổi, trong đó nó tìm thấy ít nhất trong tất cả các giá trị hàng đầu đó, sau đó cho tất cả các máy phân loại biết nó là gì, để chúng có thể (a) cho máy biết điều khiển như thế nào nhiều giá trị để "đếm" bên dưới giá trị đó và (b) tiếp tục gửi dữ liệu đã sắp xếp của chúng từ thời điểm đó.

Tổng quát hơn, có lẽ có một trò chơi đoán phản ứng thử thách thông minh mà máy điều khiển có thể chơi với 99 máy phân loại.

Điều này liên quan đến các chuyến đi khứ hồi giữa các máy, tuy nhiên, phiên bản đầu tiên đơn giản hơn của tôi tránh được. Tôi thực sự không biết làm thế nào để ước tính hiệu suất tương đối của họ và vì sự đánh đổi rất phức tạp, tôi tưởng tượng có nhiều giải pháp tốt hơn ngoài đó so với bất cứ điều gì tôi nghĩ về bản thân mình, cho rằng đây là vấn đề thực sự.

[*] Cho phép ngăn xếp có sẵn - sự lựa chọn của bạn về phần nào sẽ làm trước tiên bị hạn chế nếu bạn không có thêm không gian O (N). Nhưng nếu bạn có đủ không gian, bạn có thể chọn và nếu bạn không có đủ không gian, ít nhất bạn có thể sử dụng những gì bạn phải cắt một số góc, bằng cách thực hiện phần nhỏ trước cho một vài phân vùng đầu tiên.

sort -g numbers | head -n 500000001 | tail -n 2 | dc -e "1 k ? ? + 2 / p"

Tôi ghét phải là người thay thế ở đây, nhưng tôi không tin việc sắp xếp là bắt buộc và tôi nghĩ rằng bất kỳ thuật toán nào liên quan đến việc sắp xếp một tỷ / 100 số sẽ bị chậm. Hãy xem xét một thuật toán trên một máy tính.

1) Chọn ngẫu nhiên 1000 giá trị từ tỷ và sử dụng chúng để có ý tưởng phân phối các số, đặc biệt là một phạm vi.

2) Thay vì sắp xếp các giá trị, hãy phân bổ chúng vào các thùng dựa trên phân phối bạn vừa tính. Số lượng xô được chọn để máy tính có thể xử lý chúng một cách hiệu quả, nhưng nếu không thì càng lớn càng thuận tiện. Phạm vi nhóm phải sao cho số lượng giá trị bằng nhau trong mỗi nhóm (điều này không quan trọng đối với thuật toán, nhưng nó giúp hiệu quả. 100.000 thùng có thể phù hợp). Lưu ý số lượng giá trị trong mỗi thùng. Đây là một quá trình O (n).

3) Tìm ra cái xô nào nằm trong khoảng giữa. Điều này có thể được thực hiện bằng cách kiểm tra tổng số trong mỗi nhóm.

4) Tìm trung vị thực tế bằng cách kiểm tra các giá trị trong nhóm đó. Bạn có thể sử dụng sắp xếp ở đây nếu bạn thích, vì bạn chỉ sắp xếp có thể 10.000 số. Nếu số lượng giá trị trong nhóm đó lớn thì bạn có thể sử dụng lại thuật toán này cho đến khi bạn có một số lượng đủ nhỏ để sắp xếp.

Cách tiếp cận này song song hóa tầm thường bằng cách chia các giá trị giữa các máy tính. Mỗi máy tính báo cáo tổng số trong mỗi nhóm cho máy tính 'điều khiển' ở bước 3. Đối với bước 4, mỗi máy tính sẽ gửi các giá trị (được sắp xếp) trong nhóm có liên quan đến máy tính điều khiển (bạn cũng có thể thực hiện song song cả hai thuật toán đó, nhưng nó có lẽ không đáng

Toàn bộ quá trình là O (n), vì cả hai bước 3 và 4 đều không đáng kể, với điều kiện số lượng thùng đủ lớn.

Một tỷ thực sự là một nhiệm vụ khá nhàm chán đối với một máy tính hiện đại. Chúng ta đang nói về số nguyên 4 byte trị giá 4 GB ở đây ... 4 GB ... đó là RAM của một số điện thoại thông minh.

public class Median {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();

        int[] numbers = new int[1_000_000_000];

        System.out.println("created array after " +  (System.currentTimeMillis() - start) + " ms");

        Random rand = new Random();
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = rand.nextInt();
        }

        System.out.println("initialized array after " + (System.currentTimeMillis() - start) + " ms");

        Arrays.sort(numbers);

        System.out.println("sorted array after " + (System.currentTimeMillis() - start) + " ms");

        if (numbers.length % 2 == 1) {
            System.out.println("median = " + numbers[numbers.length / 2 - 1]);
        } else {
            int m1 = numbers[numbers.length / 2 - 1];
            int m2 = numbers[numbers.length / 2];
            double m = ((long) m1 + m2) / 2.0;
            System.out.println("median = " + new DecimalFormat("#.#").format(m));
        }
}

Đầu ra trên máy của tôi:

created array after 518 ms
initialized array after 10177 ms
sorted array after 102936 ms
median = 19196

Vì vậy, điều này hoàn thành trên máy của tôi trong vòng chưa đầy hai phút (1:43 trong đó 0h10 để tạo số ngẫu nhiên) bằng cách sử dụng một lõi duy nhất và thậm chí nó còn thực hiện một cách đầy đủ. Không có gì lạ mắt thực sự.

Đây chắc chắn là một nhiệm vụ thú vị cho các bộ số lớn hơn. Tôi chỉ muốn đưa ra một quan điểm ở đây: một tỷ là đậu phộng. Vì vậy, hãy suy nghĩ hai lần trước khi bạn bắt đầu ném các giải pháp phức tạp vào các nhiệm vụ đơn giản đáng ngạc nhiên;)

Các ước lượng số liệu thống kê theo thứ tự như phần trăm trung bình và 99 có thể được phân phối một cách hiệu quả với các thuật toán như t-tiêu hóa hoặc Q-tiêu hóa .

Sử dụng một trong hai thuật toán, mỗi nút tạo ra một thông báo, đại diện cho phân phối của các giá trị được lưu trữ cục bộ. Các bản tóm tắt được thu thập tại một nút, được hợp nhất (tổng hợp hiệu quả các phân phối) và trung bình hoặc bất kỳ phần trăm nào khác có thể được tra cứu.

Cách tiếp cận này được sử dụng bởi elaticsearch và, có lẽ là BigQuery (đi theo mô tả của hàm QUANTILES).

Trung vị cho bộ số này

2, 3, 5, 7, 11, 13, 67, 71, 73, 79, 83, 89, 97

là 67.

Trung vị cho bộ số này

2, 3, 5, 7, 11, 13, 67, 71, 73, 79, 83, 89

là 40

Giả sử câu hỏi là khoảng 1.000.000.000 số nguyên (x) trong đó 0> = x <= 2.147.483.647 và OP đang tìm kiếm (phần tử (499.999.999) + phần tử (500.000.000)) / 2 (nếu các số được sắp xếp). Cũng giả sử rằng tất cả 100 máy tính đều như nhau.

sử dụng máy tính xách tay của tôi và GigE ...

Những gì tôi tìm thấy là máy tính xách tay của tôi có thể sắp xếp 10.000.000 Int32 trong 1,3 giây. Vì vậy, một ước tính sơ bộ sẽ là một tỷ số sắp xếp sẽ mất 100 x 1,3 giây (2 phút 10 giây);).

Ước tính truyền tệp một chiều của tệp 40 MB trên Ethernet gigabit là 0,32 giây. Điều này có nghĩa là các kết quả được sắp xếp từ tất cả các máy tính sẽ được trả về trong khoảng 32 giây (máy tính 99 không nhận được tệp của anh ấy cho đến 30 giây sau khi bắt đầu). Từ đó, không mất nhiều thời gian để loại bỏ các số thấp nhất 499.999.998, thêm 2 số tiếp theo và chia cho 2.

Điều này có thể làm mọi người ngạc nhiên, nhưng nếu các số đó đủ nhỏ để vừa trong 32-bit (hoặc nhỏ hơn) - Chỉ cần thực hiện sắp xếp xô! Chỉ cần 16GB ram cho bất kỳ số lượng int 32 bit nào và chạy trong O (n), sẽ vượt trội hơn bất kỳ hệ thống phân tán nào cho n hợp lý, ví dụ: một tỷ.

Một khi bạn có danh sách được sắp xếp, thật tầm thường để chọn ra trung vị. Trong thực tế, bạn không cần phải xây dựng danh sách đã sắp xếp mà chỉ cần nhìn vào các thùng sẽ làm điều đó.

Một thực hiện đơn giản được hiển thị dưới đây. Chỉ hoạt động đối với số nguyên 16 bit, nhưng việc mở rộng thành 32 bit nên dễ dàng.

#include <stdio.h>
#include <string.h>

int main()
{
    unsigned short buckets[65536];
    int input, n=0, count=0, i;

    // calculate buckets
    memset(buckets, 0, sizeof(buckets));
    while (scanf("%d", &input) != EOF)
    {
        buckets[input & 0xffff]++;
        n++;
    }

    // find median 
    while (count <= n/2)
    {
        count += buckets[i++];
    }

    printf("median: %d\n", i-1);

    return 0;
}

Sử dụng tệp văn bản có một tỷ (10 ⁹ ) số và chạy timenhư vậy

time ./median < billion

mang lại thời gian chạy trên máy của tôi 1m49.293s. Hầu hết thời gian chạy có lẽ là đĩa IO.

Thật kỳ lạ, tôi nghĩ rằng nếu bạn có đủ máy tính, bạn nên sắp xếp tốt hơn là sử dụng O(n)các thuật toán tìm trung bình. (Trừ khi các lõi của bạn rất, rất chậm, tuy nhiên, tôi chỉ sử dụng một và sử dụng O(n)thuật toán tìm trung bình cho các số 1e9; tuy nhiên, nếu bạn có 1e12, thì điều đó có thể ít thực tế hơn.)

Dù sao đi nữa, giả sử chúng ta có nhiều hơn các lõi đăng nhập để giải quyết vấn đề này và chúng ta không quan tâm đến việc tiêu thụ năng lượng, chỉ cần nhận được câu trả lời nhanh chóng. Chúng ta hãy giả sử rằng đây là một máy SMP với tất cả dữ liệu đã được tải trong bộ nhớ. (Chẳng hạn, máy 32 lõi của Sun thuộc loại này.)

Một luồng cắt danh sách một cách mù quáng thành các mảnh có kích thước bằng nhau và báo cho các luồng M khác sắp xếp chúng. Những chủ đề cần mẫn làm như vậy, trong (n/M) log (n/M)thời gian. Sau đó, họ trả lại không chỉ trung vị của họ, mà, giả sử, phần trăm thứ 25 và 75 của họ cũng vậy (trường hợp xấu nhất là tốt hơn nếu bạn chọn các số hơi khác nhau). Bây giờ bạn có 4M phạm vi dữ liệu. Sau đó, bạn sắp xếp các phạm vi này và làm việc lên trên danh sách cho đến khi bạn tìm thấy một số sao cho, nếu bạn ném ra mọi phạm vi nhỏ hơn hoặc chứa số đó, bạn sẽ bỏ ra một nửa dữ liệu của mình. Đó là giới hạn dưới của bạn cho trung vị. Làm tương tự cho giới hạn trên. Điều này cần một cái gì đó giống như M log Mthời gian và tất cả các lõi phải chờ nó, vì vậy nó thực sự lãng phíM^2 log Mthời gian tiềm năng. Bây giờ bạn có một chủ đề duy nhất của bạn nói với những người khác ném tất cả dữ liệu ra ngoài phạm vi (bạn nên ném ra khoảng một nửa trên mỗi lượt đi) và lặp lại - đây là một thao tác nhanh chóng vì dữ liệu đã được sắp xếp. Bạn không cần phải lặp lại điều này nhiều log(n/M)lần trước khi lấy dữ liệu còn lại nhanh hơn và sử dụng O(n)công cụ tìm trung bình tiêu chuẩn trên đó.

Vì vậy, tổng số phức tạp là một cái gì đó như O((n/M) log (n/M) + M^2 log M log (n/M)). Do đó, điều này nhanh hơn O(n)sắp xếp trung bình trên một lõi nếu M >> log(n/M)và M^3 log M < n, điều này đúng với kịch bản bạn đã mô tả.

Tôi nghĩ rằng đây là một ý tưởng thực sự tồi tệ được đưa ra như thế nào là không hiệu quả, nhưng nó nhanh hơn.

Điều này có thể được thực hiện nhanh hơn thuật toán đã bình chọn (n log n)

- Thuật toán lựa chọn phân phối thống kê đơn hàng - O (n)
Đơn giản hóa vấn đề cho vấn đề ban đầu là tìm số thứ k trong một mảng chưa được sắp xếp.
- Đếm biểu đồ sắp xếp O (n)
Bạn phải giả sử một số thuộc tính về phạm vi của các số - phạm vi có thể vừa trong bộ nhớ không? - Sắp xếp hợp nhất bên ngoài - O (n log n) - được mô tả ở trên
Về cơ bản, bạn sắp xếp các số trên đường chuyền đầu tiên, sau đó tìm trung vị trên đường thứ hai.
- Nếu có bất cứ điều gì được biết về phân phối số thì các thuật toán khác có thể được tạo ra.

Để biết thêm chi tiết và triển khai, hãy xem:
http://www.fusu.us/2013/07/median-in-large-set-across-1000-servers.html

Một máy tính là quá đủ để giải quyết vấn đề.

Nhưng hãy giả sử rằng có 100 máy tính. Điều phức tạp duy nhất bạn nên làm là sắp xếp danh sách. Chia nó thành 100 phần, gửi một phần cho mỗi máy tính, để chúng được sắp xếp ở đó và hợp nhất các phần sau đó.

Sau đó lấy số từ giữa danh sách được sắp xếp (nghĩa là với chỉ số 5 000 000 000).

Nó phụ thuộc vào dữ liệu của bạn. Trường hợp xấu nhất là số lượng phân phối đồng đều.

Trong trường hợp này, bạn có thể tìm thấy trung vị trong thời gian O (N) như trong ví dụ này:

Giả sử số của bạn là 2,7,5,10,1,6,4,4,6,10,4,7,1,8,4,9,9,3,4,3,3 (phạm vi là 1-10) .

Chúng tôi tạo ra 3 thùng: 1-3, 4-7, 8-10. Lưu ý rằng trên và dưới có kích thước bằng nhau.

Chúng tôi điền vào các thùng với các số, đếm số lần rơi trong mỗi số, tối đa và tối thiểu

• thấp (5): 2,1,1,3,3, tối thiểu 1, tối đa 3
• giữa (10): 7,5,6,4,4,6,4,4,4,4, tối thiểu 4, tối đa 7
• cao (5): 10, 10, 8, 9, 9, phút 8, tối đa 10

Giá trị trung bình rơi vào thùng giữa, chúng tôi bỏ qua phần còn lại

Chúng tôi tạo ra 3 nhóm: 4, 5-6, 7. Thấp sẽ bắt đầu với số lượng 5 và tối đa là 3 và cao với tối thiểu 8 và số lượng là 5.

Đối với mỗi số, chúng tôi đếm số lần rơi trong nhóm thấp và cao, tối đa và tối thiểu và giữ cho nhóm ở giữa.

• cũ thấp (5)
• thấp (5): 4, 4, 4, 4, 4, tối đa 4
• giữa (3): 5,6,6
• cao (2): 7, 7, tối thiểu 7
• cũ cao (5)

Bây giờ chúng ta có thể tính toán trung vị trực tiếp: chúng ta có một tình huống như thế này

old low    low          middle  high  old high
x x x x x  4 4 4 4 4 4   5 6 6  7 7   x x x x x

vì vậy trung vị là 4,5.

Giả sử bạn biết một chút về phân phối, bạn có thể tinh chỉnh cách xác định phạm vi để tối ưu hóa tốc độ. Trong mọi trường hợp, hiệu suất nên đi với O (N), vì 1 + 1/3 + 1/9 ... = 1.5

Bạn cần tối thiểu và tối đa vì các trường hợp cạnh (ví dụ: nếu trung vị là trung bình giữa mức tối đa cũ thấp và phần tử tiếp theo).

Tất cả các hoạt động này có thể được song song, bạn có thể cung cấp 1/100 dữ liệu cho mỗi máy tính và tính toán 3 nhóm trong mỗi nút, sau đó phân phối nhóm bạn giữ. Điều này một lần nữa khiến bạn sử dụng mạng hiệu quả vì mỗi số được truyền trung bình 1,5 lần (vì vậy O (N)). Bạn thậm chí có thể đánh bại rằng nếu bạn chỉ chuyển các số tối thiểu giữa các nút (ví dụ: nếu nút 1 có 100 số và nút 2 có 150 số, thì nút 2 có thể cung cấp 25 số cho nút 1).

Trừ khi bạn biết nhiều hơn về phân phối, tôi nghi ngờ bạn có thể làm tốt hơn O (N) ở đây, bởi vì bạn thực sự cần phải đếm các yếu tố ít nhất một lần.

Một phương pháp dễ dàng hơn là có số có trọng số.

• Chia tập hợp lớn giữa các máy tính
• Sắp xếp từng bộ
• Lặp lại thông qua tập nhỏ và tính trọng số cho các phần tử lặp lại
• hợp nhất mỗi bộ 2 thành 1 (mỗi bộ đã được sắp xếp) cập nhật trọng số
• tiếp tục hợp nhất các bộ cho đến khi bạn chỉ nhận được một bộ
• Lặp lại thông qua trọng số tích lũy này cho đến khi bạn đạt được OneBillion / 2

Chia 10 ^ 9 số, 10 ^ 7 cho mỗi máy tính ~ 80 MB cho mỗi máy tính. Mỗi máy tính sắp xếp số của nó. Sau đó, máy tính 1 hợp nhất sắp xếp các số riêng của nó với các số từ máy tính 2, máy tính 3 và 4, v.v ... Sau đó, máy tính 1 ghi một nửa số đó thành 2, 3 đến 4, v.v. Sau đó, 1 hợp nhất sắp xếp các số từ máy tính 1,2,3,4, viết lại chúng. Và như thế. Tùy thuộc vào kích thước RAM trên các máy tính mà bạn có thể thoát khỏi việc không ghi lại tất cả các số cho từng máy tính, bạn có thể tích lũy các số trên máy tính 1 trong vài bước, nhưng bạn có thể làm toán.

Ồ, cuối cùng cũng nhận được giá trị trung bình của các giá trị 500000000 và 500000001 (nhưng kiểm tra xem có đủ 00 trong đó không, tôi không biết).

EDIT: @Roman - tốt nếu bạn không thể tin nó ngay cả khi đó là sự thật thì không có lý do gì để tôi tiết lộ sự thật hay sự giả dối của đề xuất. Điều tôi muốn nói là lực lượng vũ phu đôi khi đánh bại thông minh trong một cuộc đua. Tôi mất khoảng 15 giây để đưa ra một thuật toán mà tôi tin tưởng rằng tôi có thể thực hiện được, nó sẽ hoạt động và có thể thích ứng với nhiều kích cỡ đầu vào và số lượng máy tính, và có thể điều chỉnh theo các đặc điểm của máy tính và sắp xếp mạng. Nếu bạn hoặc bất kỳ ai khác phải mất 15 phút để nghĩ ra thuật toán phức tạp hơn, tôi có lợi thế 14m45 để mã hóa giải pháp của mình và bắt đầu chạy.

Nhưng tôi thoải mái thừa nhận đây là tất cả sự khẳng định, tôi chưa đo lường được gì.

Điều này có thể được thực hiện trên các nút sử dụng dữ liệu không được sắp xếp trên các nút (nói từ các tệp nhật ký) theo cách sau.

Có 1 nút cha và 99 nút con. Các nút con có hai cuộc gọi api:

• stats (): trả về min, max và đếm
• so sánh (median_guess): trả về giá trị khớp với số đếm, đếm nhỏ hơn giá trị và đếm lớn hơn giá trị

Nút cha gọi số liệu thống kê () trên tất cả các nút con, lưu ý mức tối thiểu và tối đa của tất cả các nút.

Một tìm kiếm nhị phân bây giờ có thể được tiến hành theo cách sau:

1. Bỏ qua việc làm tròn tối thiểu và tối đa - đây là 'dự đoán' trung bình
2. Nếu số lớn hơn số đếm lớn hơn số đếm nhỏ hơn, hãy đặt mức tối thiểu thành đoán
3. Nếu số lớn hơn số đếm nhỏ hơn số đếm nhỏ hơn, hãy đặt mức tối đa thành đoán
4. Nếu số là kết thúc lẻ khi tối thiểu và tối đa bằng nhau
5. Nếu số lượng thậm chí kết thúc khi tối đa <= tối thiểu + đoán.match_count Điều này có thể được thực hiện trên các nút sử dụng dữ liệu chưa được sắp xếp (nói từ tệp nhật ký) theo cách sau.

Có 1 nút cha và 99 nút con. Các nút con có hai cuộc gọi api:

• stats (): trả về min, max và đếm
• so sánh (median_guess): trả về giá trị khớp với số đếm, đếm nhỏ hơn giá trị và đếm lớn hơn giá trị

Nút cha gọi số liệu thống kê () trên tất cả các nút con, lưu ý mức tối thiểu và tối đa của tất cả các nút.

Một tìm kiếm nhị phân bây giờ có thể được tiến hành theo cách sau:

1. Bỏ qua việc làm tròn tối thiểu và tối đa - đây là 'dự đoán' trung bình
2. Nếu số lớn hơn số đếm lớn hơn số đếm nhỏ hơn, hãy đặt mức tối thiểu thành đoán
3. Nếu số lớn hơn số đếm nhỏ hơn số đếm nhỏ hơn, hãy đặt mức tối đa thành đoán
4. Nếu số là kết thúc lẻ khi tối thiểu và tối đa bằng nhau
5. Nếu số lượng thậm chí kết thúc khi tối đa <= tối thiểu + đoán.match_count

Nếu các số liệu thống kê () và so sánh () có thể được tính toán trước với sắp xếp O (N / Mlogn / M), thì phép tính trước O (N / M) với độ phức tạp bộ nhớ là O (N) cho trước phép tính. Sau đó, bạn có thể so sánh () trong thời gian không đổi, vì vậy toàn bộ (bao gồm cả tính toán trước) sẽ chạy trong O (N / MlogN / M) + O (logN)

Hãy cho tôi biết nếu tôi đã phạm sai lầm!

Làm thế nào về điều này: - mỗi nút có thể mất 1Billion / 100 số. Tại mỗi nút, các phần tử có thể được sắp xếp và có thể tìm thấy trung vị. Tìm trung vị của trung vị. chúng ta có thể, bằng cách tổng hợp số lượng các số nhỏ hơn trung vị trên tất cả các nút tìm ra x%: y% chia mà trung bình tạo ra. Bây giờ yêu cầu tất cả các nút xóa các phần tử nhỏ hơn trung vị trung vị (lấy ví dụ về tỷ lệ chia 30%: 70%) .30% số bị xóa. 70% của 1Billion là 700 triệu. Bây giờ tất cả các nút đã xóa ít hơn 3 triệu nút có thể gửi các nút bổ sung đó trở lại máy tính chính. Máy tính chính phân phối lại theo cách mà bây giờ tất cả các nút sẽ có số lượng nút gần như bằng nhau (7 triệu). Bây giờ vấn đề đã giảm xuống còn 700 triệu số .... tiếp tục cho đến khi chúng ta có một tập nhỏ hơn có thể được tính trên một comp.

Trước tiên chúng ta hãy tìm cách tìm một trung bình gồm n số trên một máy duy nhất: về cơ bản tôi đang sử dụng chiến lược phân vùng.

Bài toán: lựa chọn (n, n / 2): Tìm số thứ n / 2 từ số nhỏ nhất.

Bạn chọn nói phần tử trung bình k và dữ liệu phân vùng thành 2 mảng phụ. phần 1 chứa tất cả các phần tử <k và thứ 2 chứa tất cả các phần tử> = k.

if sizeof (mảng con thứ 1)> = n / 2, bạn biết rằng mảng con này chứa trung vị. Sau đó, bạn có thể loại bỏ mảng con thứ 2. Giải quyết lựa chọn vấn đề này (sizeof mảng con thứ 1, n / 2) .

Trong trường hợp khác, loại bỏ phân đoạn thứ 1 này và giải quyết lựa chọn (phân đoạn thứ hai, n / 2 - sizeof (phân đoạn thứ nhất))

Làm điều đó đệ quy.

độ phức tạp thời gian là O (n) thời gian dự kiến.

Bây giờ nếu chúng ta có nhiều máy, trong mỗi lần lặp, chúng ta phải xử lý một mảng để phân tách, chúng ta phân phối mảng thành các máy khác. Mỗi máy xử lý khối mảng của chúng và gửi lại bản tóm tắt cho máy điều khiển trung tâm tức là kích thước của phân đoạn thứ nhất và kích thước của phân đoạn thứ hai. Các máy trung tâm cộng các bản tóm tắt và quyết định phân đoạn nào (thứ 1 hoặc thứ 2) để xử lý thêm và tham số thứ 2 của lựa chọn và gửi lại cho mỗi máy. và như thế.

Thuật toán này có thể được thực hiện rất gọn gàng bằng cách sử dụng bản đồ giảm?

Trông nó như thế nào?

Tôi nghĩ câu trả lời của Steve Jessop sẽ là nhanh nhất.

Nếu kích thước truyền dữ liệu mạng là nút cổ chai, thì đây là một cách tiếp cận khác.

Divide the numbers into 100 computers (10 MB each). 
Loop until we have one element in each list     
    Find the meadian in each of them with quickselect which is O(N) and we are processing in parallel. The lists will be partitioned at the end wrt median.
    Send the medians to a central computer and find the median of medians. Then send the median back to each computer. 
    For each computer, if the overall median that we just computed is smaller than its median, continue in the lower part of the list (it is already partitioned), and if larger in the upper part.
When we have one number in each list, send them to the central computer and find and return the median.

Tôi sẽ làm như thế này:

trong đầu tất cả 100 công việc để tìm số cao nhất và thấp nhất; mỗi máy tính có một phần cơ sở dữ liệu / tệp mà nó truy vấn;

khi tìm thấy số cao nhất và thấp nhất, một máy tính sẽ đọc dữ liệu và phân phối từng số một cách đồng đều cho phần còn lại của 99; các số được phân phối theo các khoảng bằng nhau; (người ta có thể mất từ ​​-100 triệu đến 0, người khác - từ 0 đến 100 triệu, v.v.);

Trong khi nhận số, mỗi trong số 99 máy tính đã sắp xếp chúng;

Sau đó, thật dễ dàng để tìm trung vị ... Xem mỗi máy tính có bao nhiêu số, thêm tất cả chúng (tổng của có bao nhiêu số, không phải chính các số đó), chia cho 2; tính toán trong đó máy tính là số, và tại chỉ số nào;

:) voilla

PS Có vẻ có rất nhiều nhầm lẫn ở đây; MEDIAN - là SỐ TRONG TRUNG TÂM DANH SÁCH SỐ LƯỢNG CÓ HẠN!

Bạn có thể sử dụng phương pháp cây giải đấu để tìm trung vị. Chúng ta có thể tạo một cây với 1000 nút rời sao cho mỗi nút lá là một mảng. Sau đó, chúng tôi tiến hành n / 2 giải đấu giữa các mảng khác nhau. Giá trị ở gốc sau khi giải đấu n / 2 là kết quả.

http://www.geekforgeek.org/touriga-tree-and-binary-heap/

Nếu các số không khác biệt và chỉ thuộc về một phạm vi nhất định, nghĩa là chúng được lặp lại, thì một giải pháp đơn giản xuất hiện trong đầu tôi là phân phối các số trong 99 máy bằng nhau và giữ một máy làm chủ. Bây giờ mọi máy đều lặp lại các số đã cho và lưu số đếm của từng số trong một bộ băm. Mỗi lần số được lặp lại trong tập hợp số được phân bổ cho máy tính cụ thể đó, nó sẽ cập nhật số của nó trong tập băm.

Tất cả các máy sau đó trả lại bộ băm của chúng cho máy chủ. Máy chủ kết hợp các bộ băm, tổng hợp số lượng của cùng một khóa được tìm thấy trong một bộ băm. Ví dụ, bộ băm của máy số 1 có một mục nhập ("1", 7) và bộ băm của máy số 2 có một mục nhập ("1", 9), do đó, máy chủ khi kết hợp các bộ băm tạo ra một mục nhập của ("1", 16), v.v.

Khi các bộ băm đã được hợp nhất, sau đó chỉ cần sắp xếp các khóa và bây giờ bạn có thể dễ dàng tìm thấy mục (n / 2) và mục (n + 2/2), từ bộ băm được sắp xếp.

Phương pháp này sẽ không có lợi nếu số tỷ là khác biệt.

Chà, giả sử bạn biết rằng số lượng số nguyên khác nhau là (4 tỷ), sau đó bạn có thể xô chúng vào các thùng 64k và nhận được số lượng phân phối cho mỗi nhóm từ mỗi máy trong cụm (100 máy tính). Kết hợp tất cả các tính này. Bây giờ, hãy tìm cái xô có trung vị và lần này chỉ yêu cầu các thùng cho các phần tử 64k sẽ nằm trong thùng mục tiêu của bạn. Điều này yêu cầu O (1) (cụ thể là 2) truy vấn trên "cụm" của bạn. : D

Giá trị đồng xu của tôi, sau tất cả những gì đã được đưa lên bởi những người khác:

Tìm trung vị trên một máy duy nhất là O (N): https://en.wikipedia.org/wiki/Selection_alacticm .

Gửi số N đến 100 máy cũng là O (N). Vì vậy, để làm cho việc sử dụng 100 máy trở nên thú vị, giao tiếp phải tương đối nhanh hoặc N lớn đến mức một máy không thể xử lý được trong khi N / 100 có thể thực hiện được hoặc chúng tôi chỉ muốn xem xét vấn đề toán học mà không bận tâm về dữ liệu cộng đồng.

Do đó, để cắt ngắn mọi thứ tôi sẽ cho rằng, trong giới hạn hợp lý, chúng tôi có thể gửi / phân phối số mà không ảnh hưởng đến phân tích hiệu quả.

Hãy xem xét cách tiếp cận sau đây, trong đó một máy được chỉ định là "chính" cho một số xử lý chung. Điều này sẽ tương đối nhanh, do đó, "bậc thầy" cũng tham gia vào các tác vụ chung mà mỗi máy thực hiện.

1. Mỗi máy nhận được N / 100 số, tính toán trung vị của chính nó và gửi thông tin đó cho chủ.
2. Bậc thầy tổng hợp một danh sách được sắp xếp của tất cả các trung vị riêng biệt và gửi lại cho mỗi máy, xác định một chuỗi các xô theo thứ tự (trên mỗi máy giống nhau), một cho mỗi giá trị trung bình (một thùng giá trị đơn) và một cho mỗi khoảng giữa dải phân cách liền kề. Tất nhiên, cũng có các nhóm cấp thấp hơn và cấp cao hơn cho các giá trị dưới mức trung bình thấp nhất và trên mức cao nhất.
3. Mỗi máy tính có bao nhiêu số rơi vào mỗi nhóm và truyền thông tin đó trở lại cho chủ.
4. Bậc thầy xác định thùng nào chứa trung vị, có bao nhiêu giá trị thấp hơn (tổng cộng) giảm xuống dưới thùng đó và bao nhiêu giá trị ở trên.
5. Nếu nhóm được chọn là nhóm giá trị đơn (một trong các giá trị trung bình), hoặc nhóm đã chọn chỉ chứa 1 (N lẻ) hoặc 2 (N chẵn) chúng ta đã hoàn thành. Mặt khác, chúng tôi lặp lại các bước trên với các sửa đổi (rõ ràng) sau:
6. Chỉ các số từ nhóm được chọn mới được (phân phối lại) từ máy chính đến 100 máy và hơn thế nữa
7. Chúng tôi sẽ không tính toán (trên mỗi máy) trung vị, nhưng giá trị thứ k, trong đó chúng tôi tính đến có bao nhiêu số cao hơn đã bị loại bỏ khỏi tổng số và bao nhiêu số thấp hơn. Về mặt khái niệm, mỗi máy cũng có phần của các số thấp / cao bị loại bỏ và tính đến điều đó khi tính toán trung vị mới trong tập hợp (về mặt khái niệm) bao gồm (phần của nó) các số bị loại bỏ.

Độ phức tạp thời gian:

1. Một chút suy nghĩ sẽ thuyết phục bạn rằng ở mỗi bước, tổng số giá trị cần phân tích giảm đi ít nhất hai nhân tố (2 sẽ là một trường hợp khá bệnh; bạn có thể mong đợi giảm tốt hơn đáng kể). Từ đây, chúng tôi nhận được:
2. Giả sử rằng việc tìm giá trị trung bình (hoặc giá trị k-th), là O (N), sẽ mất thời gian c * N trong đó tiền tố c không thay đổi quá lớn với N để chúng ta có thể lấy nó làm hằng số trong thời điểm này, chúng ta sẽ nhận được kết quả cuối cùng của chúng tôi trong tối đa 2 * c * N / 100 lần. Do đó, sử dụng 100 máy mang lại cho chúng tôi hệ số tăng tốc 100/2 (ít nhất là).
3. Như đã nhận xét ban đầu: thời gian liên quan đến việc giao tiếp các con số giữa các máy có thể khiến nó trở nên hấp dẫn hơn khi chỉ cần làm mọi thứ trên một máy. Tuy nhiên, NẾU chúng ta sử dụng phương pháp phân tán, tổng số lượng số được truyền đạt trong tất cả các bước cùng nhau sẽ không vượt quá 2 * N (N lần đầu tiên, <= N / 2 lần thứ hai, <= một nửa số đó thứ ba, v.v.)

1. Chia 1 tỷ số thành 100 máy. Mỗi máy sẽ có 10 ^ 7 số.

2. Đối với mỗi số đến máy, lưu số trong bản đồ tần số, số -> đếm. Cũng lưu trữ số lượng tối thiểu trong mỗi máy.

3. Tìm trung vị trong mỗi máy: bắt đầu từ số min trong mỗi máy, tính tổng cho đến khi đạt được chỉ số trung vị. Trung vị trong mỗi máy, sẽ là khoảng. nhỏ hơn và lớn hơn 5 * 10 ^ 6 số.

4. Tìm trung vị của tất cả các trung vị, sẽ nhỏ hơn và lớn hơn khoảng. 50 * 10 ^ 7 số, là trung vị của 1 tỷ số.

Bây giờ một số tối ưu hóa của bước thứ 2: Thay vì lưu trữ trong bản đồ tần số, hãy lưu trữ số đếm trong một mảng bit thay đổi. Ví dụ: Hãy nói bắt đầu từ số min trong một máy, đây là các tần số:

[min number] - 8 count
[min+1 number] - 7 count
[min+2 number] - 5 count

Ở trên có thể được lưu trữ trong mảng bit như:

[min number] - 10000000
[min+1 number] - 1000000
[min+2 number] - 10000

Lưu ý rằng hoàn toàn sẽ có giá khoảng 10 ^ 7 bit cho mỗi máy, vì mỗi máy chỉ xử lý 10 ^ 7 số. 10 ^ 7 bit = 1,25 * 10 ^ 6 byte, là 1,25 MB

Vì vậy, với cách tiếp cận trên, mỗi máy sẽ cần 1,25 MB dung lượng để tính toán trung vị cục bộ. Và trung vị của trung vị có thể được tính từ 100 trung vị địa phương đó, dẫn đến trung bình là 1 tỷ số.

Tôi đề nghị một phương pháp để tính toán trung bình. :) Nếu một tỷ số này theo thứ tự ngẫu nhiên, tôi nghĩ rằng tôi có thể chọn ngẫu nhiên 1/100 hoặc 1/10 của một tỷ số, sắp xếp chúng với 100 máy, sau đó chọn trung vị của chúng. Hoặc hãy chia hàng tỷ số thành 100 phần, hãy để mỗi máy chọn 1/10 mỗi phần một cách ngẫu nhiên, tính trung bình của chúng. Sau đó, chúng ta có 100 số và chúng ta có thể tính trung bình của số 100 dễ dàng hơn. Chỉ là một gợi ý, tôi không chắc nó có đúng về mặt toán học không. Nhưng tôi nghĩ bạn có thể hiển thị kết quả cho một người quản lý không giỏi về toán học.

Câu trả lời của Steve Jessop là sai:

xem xét bốn nhóm sau:

{2, 4, 6, 8, 10}

{21, 21, 24, 26, 28}

{12, 14, 30, 32, 34}

{16, 18, 36, 38, 40}

Trung vị là 21, được chứa trong nhóm thứ hai.

Trung vị của bốn nhóm là 6, 24, 30, 36, Tổng trung vị là 27.

Vì vậy, sau vòng lặp đầu tiên, bốn nhóm sẽ trở thành:

{6, 8, 10}

{24, 26, 28}

{12, 14, 30}

{16, 18, 36}

21 đã bị loại bỏ sai.

Thuật toán này chỉ hỗ trợ trường hợp khi có hai nhóm.