Điểm truy cập trên một dòng số trong khi giảm thiểu chi phí không liên quan đến khoảng cách

Tôi cần một số trợ giúp về vấn đề ACPC ICPC này. Ý tưởng hiện tại của tôi là mô hình hóa điều này như một vấn đề đường đi ngắn nhất, được mô tả theo tuyên bố vấn đề.

Vấn đề

Có N = 1000các thùng chứa chất thải hạt nhân nằm dọc theo một dãy số 1-D tại các vị trí khác nhau-500,000 to 500,000 , ngoại trừ x=0. Một người có nhiệm vụ thu thập tất cả các thùng rác. Mỗi giây mà một thùng chứa chất thải không được thu gom, nó sẽ phát ra 1 đơn vị bức xạ. Người bắt đầu tại x = 0và có thể di chuyển 1đơn vị mỗi giây và việc thu gom chất thải mất một lượng thời gian không đáng kể. Chúng tôi muốn tìm lượng phóng xạ tối thiểu được giải phóng trong khi thu thập tất cả các thùng chứa.

Đầu vào mẫu:

4Container nằm ở [-12, -2, 3, 7].

Thứ tự tốt nhất để thu thập các container này là [-2, 3, 7, -12], cho các 50đơn vị phát ra tối thiểu . Giải thích: người đó đi -2trong 2 giây và trong thời gian đó 2 unitsbức xạ được phát ra. Sau đó, anh ta đi đến 3(khoảng cách 5:) để thùng đã giải phóng 2 + 5 = 7các đơn vị phóng xạ. Anh ta mất 4nhiều giây hơn để đến x = 7nơi cái thùng đó đã phát ra 2 + 5 + 4 = 11các đơn vị. Anh ta mất 19vài giây để đến x = -12nơi cái thùng đó đã phát ra 2 + 5 + 4 + 19 = 30các đơn vị. 2 + 7 + 11 + 30 = 50, đó là câu trả lời.

Ghi chú

Có một O(N!)giải pháp rõ ràng . Tuy nhiên, tôi đã khám phá các phương pháp tham lam như di chuyển đến phương pháp gần nhất hoặc di chuyển đến cụm gần nhất nhưng chúng không hoạt động.

Tôi đã suy nghĩ về vấn đề này khá lâu và đã mô hình hóa nó như một vấn đề tìm kiếm đồ thị:

1. Chúng tôi chèn 0vào như một vị trí cơ sở (Đây sẽ là trạng thái ban đầu)
2. Sau đó, chúng tôi sắp xếp các vị trí từ ít nhất đến lớn nhất.
3. Sau đó chúng tôi thực hiện BFS / PFS, trong đó statebao gồm
   • Hai số nguyên lvà rđại diện cho một phạm vi liền kề trong mảng vị trí được sắp xếp mà chúng tôi đã truy cập
   • Một số nguyên loccho chúng ta biết chúng ta ở điểm cuối bên trái hay bên phải của phạm vi
   • Một số nguyên timecho chúng ta biết thời gian đã trôi qua
   • Một số nguyên 'chi phí' cho chúng ta biết tổng chi phí cho đến nay (dựa trên các nút chúng tôi đã truy cập)
4. Từ mỗi trạng thái, chúng ta có thể di chuyển đến [l - 1, r] và [l, r + 1], điều chỉnh 3 số nguyên khác cho phù hợp
5. Trạng thái cuối cùng là [0, N], kiểm tra cả hai vị trí kết thúc.

Tuy nhiên, dường như [L, R, loc]không xác định duy nhất một trạng thái và chúng tôi phải lưu trữ L, R, loc, and time, trong khi giảm thiểu costở mỗi trạng thái này. Điều này dẫn đến một thuật toán theo cấp số nhân, vẫn còn quá chậm đối với bất kỳ hàng hóa nào.

Bất cứ ai có thể giúp tôi mở rộng ý tưởng của tôi hoặc đẩy tôi đi đúng hướng?

Chỉnh sửa: Có lẽ điều này có thể được mô hình hóa như một vấn đề tối ưu hóa lập trình động? Nghĩ về nó, nó có cùng một vấn đề với giải pháp tìm kiếm đồ thị - chỉ vì dòng điện costthấp không có nghĩa đó là câu trả lời tối ưu cho vấn đề phụ đó, vì nó timecũng ảnh hưởng rất lớn đến câu trả lời.

Tham lam không hoạt động: Tôi có một thuật toán lựa chọn tham lam ước tính chi phí di chuyển đến một nơi nhất định (ví dụ: nếu chúng ta di chuyển sang phải, chúng ta sẽ nhân đôi khoảng cách đến các thùng bên trái và như vậy).

Bạn có thể thực hiện tìm kiếm ưu tiên đầu tiên, với một heuristic? Các heuristic có thể kết hợp chi phí của chuyến đi hiện tại với thời gian trôi qua.

Tôi nghĩ bạn có thể cải thiện điều này bằng cách xem xét vấn đề dưới dạng biểu đồ hướng của các cặp vị trí.

Trong ví dụ này, tôi sẽ sử dụng dòng có các giá trị -9, -6, -1, 3 và 5.

Vì quá khó để vẽ biểu đồ chỉ bằng văn bản, tôi sẽ biểu diễn các cặp dưới dạng bảng. Chúng ta có thể nghĩ về các ô như thể hiện trạng thái nơi tất cả các thùng chứa giữa hai vị trí đó đã được thu thập. Mỗi ô có hai giá trị, một giá trị biểu thị chi phí ở bên trái, giá trị còn lại biểu thị chi phí ở bên phải (sang bộ chứa tiếp theo).

Các giá trị có thể được tính đơn giản là khoảng cách giữa hai điểm nhân với số thùng ngoài hai điểm đó + 1 . Các ô trong đó cả hai số có cùng dấu đại diện cho các trường hợp khi tất cả các thùng của dấu ngược lại đã được thu thập. Chúng được tính toán chỉ sử dụng số lượng thùng theo hướng từ 0.

Trong các giá trị bảng của X có nghĩa là bạn không thể đi theo hướng đó (tất cả các thùng theo hướng đó đã được thực hiện). Các hàng đại diện cho vị trí hiện tại của bộ thu và các cột biểu thị vị trí của thùng đối diện tiếp theo.

    +------+------+------+------+------+
    |  -9  |  -6  |  -1  |   3  |   5  |
+---+------+------+------+------+------+
|-9 |      |      |      | X, 24| X, 14|
+---+------+------+------+------+------+
|-6 | 3, X |      |      | 9, 27| 6, 22|
+---+------+------+------+------+------+
|-1 |      |10, X |      |20, 8 |15, 18|
+---+------+------+------+------+------+
| 3 |24, 4 |27, 6 |16, 8 |      | X, 2 |
+---+------+------+------+------+------+
| 5 |14, X |22, X |18, X |      |      |
+---+------+------+------+------+------+

Các quy tắc để di chuyển giữa các hình vuông có thể hơi khó hiểu.

Đối với các cột được đánh số âm, các quy tắc như sau:

• Đi bên phải di chuyển xuống một tế bào.
• Đi bên trái di chuyển xuống một ô và sau đó gương qua đường chéo.
• Nếu giá trị bên phải là X, đi sang trái sẽ di chuyển lên đường chéo (trong đó cột và hàng bằng nhau) và trái một.

Đối với các cột được đánh số dương, các quy tắc như sau:

• Đi bên trái di chuyển lên một ô.
• Đi bên phải di chuyển lên một ô và sau đó gương qua đường chéo.
• Nếu giá trị bên trái là X, đi bên phải sẽ di chuyển xuống theo đường chéo và bên phải theo một.

Bây giờ chúng ta có thể chạy thuật toán của Dijkstra để tính toán đường đi tốt nhất, sử dụng các quy tắc chuyển động này để đi qua biểu đồ. Vị trí bắt đầu của chúng tôi là (-1, 3) và (3, -1) với chi phí ban đầu lần lượt là 5 và 15. Khi chúng tôi đã tính các giá trị cho hai vị trí cuối (bên trái của (-9, -9) và bên phải của (5, 5)), nhỏ hơn trong hai vị trí là câu trả lời của chúng tôi.

Thời gian chạy cho mỗi bước là:

• O (N log N) để sắp xếp ban đầu các giá trị đầu vào dọc theo dòng
• O (N ^ 2) để tính bảng / biểu đồ
• O (N ^ 2 log N) để chạy Dijkstra trên biểu đồ (Lưu ý: có nhiều nhất hai cạnh cho bất kỳ đỉnh đã cho nào).

Hai bước đầu tiên bị chi phối bởi bước cuối cùng, vì vậy thời gian chạy tổng thể của bạn là O (N ^ 2 log N), đây sẽ là thời gian chạy đủ tốt cho thử thách.

Khoảng cách ngắn nhất

Tôi đã viết một ứng dụng Java ngày hôm qua để giải quyết vấn đề. Vấn đề về cơ bản là một vấn đề khoảng cách ngắn nhất, như SRJ đã nói trong bình luận của mình. Bức xạ chỉ cho thấy rằng bạn có thể tích lũy một giá trị cùng với khoảng cách ngắn nhất.

Về cơ bản, đây là những gì tôi đã làm.

• Đặt số lượng container trong Danh sách <Integer>
• Trong khi Danh sách chứa các thành phần;
  • Tìm phần tử gần nhất
  • Nếu có một yếu tố, hãy đi bộ đến đó và loại bỏ yếu tố đó.
  • Nếu có hai yếu tố, sao chép đường dẫn và đi đến cả hai yếu tố
• Tìm đường đi có giá trị bức xạ nhỏ nhất.

Đây là một số đầu ra từ ứng dụng

10 containers are located at [-90, -75, -47, -9, 9, 26, 48, 50, 64, 79].

You walk to position -9 and pick up the container.  The total radiation emitted is 90 units.
You walk to position 9 and pick up the container.  The total radiation emitted is 252 units.
You walk to position 26 and pick up the container.  The total radiation emitted is 388 units.
You walk to position 48 and pick up the container.  The total radiation emitted is 542 units.
You walk to position 50 and pick up the container.  The total radiation emitted is 554 units.
You walk to position 64 and pick up the container.  The total radiation emitted is 624 units.
You walk to position 79 and pick up the container.  The total radiation emitted is 684 units.
You walk to position -47 and pick up the container.  The total radiation emitted is 1,062 units.
You walk to position -75 and pick up the container.  The total radiation emitted is 1,118 units.
You walk to position -90 and pick up the container.  The total radiation emitted is 1,133 units.

Tôi đã không tối ưu hóa thuật toán theo bất kỳ cách nào. Tôi thậm chí không nhận thấy rằng danh sách đầu vào của các số đã được sắp xếp. (Tôi là một kẻ ngốc nghếch.)

Khi tôi chạy mã của mình với các giá trị tối đa, 1.000 container và phạm vi từ -500.000 đến 500.000, mã của tôi mất 3 giây để thực thi. Hầu hết thời gian đó là viết 1.000 dòng in lên bàn điều khiển.

Tôi không phải là người O lớn, nhưng tôi nghĩ rằng lực lượng vũ phu của tôi đi theo thuật toán đường đi ngắn nhất là O (N bình phương), không phải O (N!).

Nếu tôi lợi dụng thực tế là các số đầu vào được sắp xếp, do đó tôi chỉ phải kiểm tra hai số ở hai bên của nơi tôi hiện đang ở, tôi có thể đưa ứng dụng xuống gần O (N). Tôi chỉ phải kiểm tra 2 số vì tôi đang xóa các thành phần khỏi Danh sách khi tôi nhận được chúng.

Bạn đã sử dụng các thuật toán khác nhau, như thuật toán tham lam, để tìm một giải pháp gần đúng.

Nếu chương trình của tôi mất 3 giờ để chạy thay vì 3 giây, thì bạn có thể lựa chọn.

Là giải pháp đủ tốt đủ tốt?

Nói cách khác, tôi có sẵn sàng đánh đổi tốc độ xử lý để có câu trả lời đủ tốt không?

Nếu một câu trả lời đủ tốt là đủ tốt, thì bạn sử dụng các thuật toán gần đúng.

Nếu bạn muốn câu trả lời hoàn hảo, bạn phải đi bộ trên tất cả các con đường ngắn nhất. Không có phím tắt.

Nếu bất cứ ai muốn tôi gửi mã của tôi, tôi sẽ. Tôi chắc chắn vẫn còn lỗi, vì tôi muốn xem liệu tôi có thể thực hiện thuật toán đi bộ ngắn nhất hay không.

Tôi có một giải pháp sẽ giải quyết vấn đề này 2^Nkịp thời, rất kém, nhưng tôi nghĩ đó là một cách hữu ích để đóng khung vấn đề, vì vậy tôi nghĩ rằng tôi sẽ đăng.

Thay vì mô hình hóa vấn đề dưới dạng biểu đồ, tôi sẽ mô hình nó là một cây quyết định nhị phân (giả sử T). Ở mỗi cấp độ, bạn phải chọn giữa đi phải hoặc trái. Khá dễ dàng để tính toán 'chi phí' của mỗi cạnh. Đặt h(K)chiều cao của nút hiện tại K, sau đó chi phí của cạnh sẽ đến left_child(K) = h(K) x dist(K, left_child(K)). Một tính toán tương tự đủ cho chi phí của cạnh phải cho con. Bạn xây dựng cây này và theo dõi chi phí giảm dần của các cạnh xuống và báo cáo đường dẫn đến nút lá với tổng chi phí nhỏ nhất.

Lưu ý rằng tính toán chi phí hoạt động vì độ dài của mỗi cạnh dist(K, left_child(K))biểu thị thời gian để đi đến trang tiếp theo, trong khi chiều cao của cây con là số lượng trang web còn lại (ví dụ: vẫn phát ra bức xạ).

Bây giờ mẹo trong khung này là xác định xem có một số phương pháp phỏng đoán mà bạn có thể sử dụng để 'chứng minh' rằng bạn có thể bỏ qua việc mở rộng tìm kiếm dọc theo một số chi nhánh. Trực giác của tôi là đối với bất kỳ heuristic như vậy, có một sự sắp xếp của các trang web sẽ đánh bại nó, nhưng có lẽ ai đó có thể đưa ra một cái gì đó.

Một số đã đề xuất áp dụng các giải pháp đường đi ngắn nhất cho đồ thị, tôi có một số nghi ngờ về việc liệu một giải pháp như vậy có thể làm việc hay không. Hàng xóm của bạn trong 'biểu đồ' trong vấn đề sẽ thay đổi tùy thuộc vào con đường bạn đi theo. Ví dụ: trong bài viết gốc của bạn với [-12, -2, 3, 7]nếu bạn đi đến -2đó -12và 3trở thành 'hàng xóm' và nếu bạn đi đến 3đó -2và 7là hàng xóm. Mọi 'cặp' giá trị dương và âm có thể có khả năng là neigbhours trong biểu đồ cuối cùng. Tôi không biết bất kỳ thuật toán đường đi ngắn nhất nào có thể chứng minh chính xác trong biểu đồ động.

Tôi nghĩ sẽ hợp lý nhất khi nghĩ về mọi giai đoạn chỉ đơn giản là sự lựa chọn nhị phân giữa việc đi đúng sang thùng gần nhất và sang trái sang thùng gần nhất. Đơn giản chỉ cần có một hàm chi phí chi tiết tổng số đơn vị bức xạ sẽ phát sinh bằng cách thực hiện bất kỳ chuyển động nào và chọn một đơn vị có chi phí thấp nhất.

KHÔNG chỉ đơn giản là xem xét thùng gần nhất, nhưng thay vào đó, giả sử rằng bằng cách di chuyển ra khỏi thùng, bạn đang tăng gấp đôi lượng phóng xạ một cách hiệu quả bởi vì khi di chuyển ra xa, bạn cũng phải chịu chi phí phải quay lại hướng đó sau đó.

Trong ví dụ của bạn về [-12, -2,3,7], di chuyển sang trái sẽ phải chịu tổng cộng 14 (2 + 2 + 10) ở bên trái và 18 (2 + 2 + 5 + 9) ở bên phải, với tổng số 22. Di chuyển sang phải sẽ phát sinh 10 (3 + 3 + 4) ở bên phải và 26 (3 + 3 + 5 + 15) ở bên phải. Rõ ràng bên trái là giải pháp đúng lúc đầu. Một tính toán tương tự có thể được thực hiện cho mọi chuyển động liên tiếp.

Sau đó, vấn đề cơ bản giảm xuống một tìm kiếm, vì vậy độ phức tạp phải là O (nlog (n)), tốt hơn nhiều so với O (n!). Tôi tin rằng đây thực sự là độ phức tạp thấp nhất có thể tồn tại cho vấn đề này vì về cơ bản nó là thuật toán tìm kiếm dựa trên so sánh mà không thể làm tốt hơn O (nlog (n))

Rõ ràng tôi không đủ rõ ràng với mô tả này, vì vậy tôi đã quyết định làm cho nó lập trình hơn một chút: 1. Tính toán chi phí phát sinh khi đi bên trái và chi phí phát sinh bằng cách đi bên phải dựa trên vị trí hiện tại 2. Chuyển đến hướng ít tốn kém nhất 3. Loại bỏ thùng đạt được khỏi xem xét trong việc tính toán chi phí di chuyển theo hướng

Tính chi phí: 1. Xác định thùng gần nhất theo hướng đã cho. Giả sử $ dist là khoảng cách từ vị trí hiện tại đến thùng gần nhất theo hướng đã cho. 2. Chi phí được khởi tạo là N * $ dist trong đó N chỉ xem xét các thùng vẫn hoạt động. 3. Để làm điều này, hãy thêm khoảng cách mà vị trí mới được biểu thị bằng $ dist sẽ là từ mỗi thùng còn lại.

Giải pháp một phần - Tôi sẽ quay lại với nó sau.

Giả sử chiến lược "mặc định" được chạy theo mọi cách trái hoặc phải, tùy theo giá nào rẻ hơn. Bây giờ hãy hỏi, có đáng để một chuyến đi phụ nhỏ theo cách khác để lấy một thùng. Nó khá dễ dàng để tính toán câu trả lời.

Đối với bạn mẫu đầu vào, chạy tất cả các cách bên phải rẻ hơn so với tất cả các cách bên trái. Là đi đến -2 giá trị một chuyến đi phụ? Nó giảm chi phí cho việc chạy đúng cách và sau đó giảm xuống 0 bằng 14 (vì bạn đã "trả" 4 đơn vị bức xạ cho mỗi lần di chuyển từ 0 đến 3 trên chiến lược mặc định, bây giờ giảm xuống còn 3, bạn đã trả 3 từ 3 đến 7, bây giờ là 2, v.v.), cộng với giảm một lần cho mỗi lần di chuyển, chi phí của bạn chuyển từ 0 sang -2, do đó tiết kiệm thêm 2 lần cho tổng số 16.

Tuy nhiên, nó thêm chi phí chuyển sang -2 sau đó trở về 0 trên 14 (4 đơn vị mỗi lần di chuyển thành -2, 3 mỗi lần di chuyển về 0), với mức tăng ròng là (16-14) = 2. Lưu ý rằng để tính toán điều này, bạn không phải đánh giá chi phí chính xác để giải quyết toàn bộ vấn đề cho mỗi quyết định - bạn có đủ thông tin để quyết định chỉ bằng cách biết nếu chạy tất cả các cách còn lại rẻ hơn so với chạy đúng cách, cộng với cách nhiều thùng chứa chất thải ở mỗi bên của bạn và khoảng cách đến gần nhất 2. Vì vậy, đó là O (N ^ 2).

Ngoại trừ một vấn đề quan trọng - Tôi đã giả định rằng bạn sẽ chạy từ đầu đến cuối và chúng tôi biết bạn có thể tăng gấp đôi. Để làm sạch nó, chúng ta cần cập nhật tính toán của tôi. Đối với đầu vào mẫu, tôi đã giả định rằng bạn sẽ tiết kiệm 14 bằng cách phát ra ít hơn 1 bức xạ trên mỗi đơn vị mỗi giây trong khi chạy từ 0 đến 7 và trở lại. Nhưng, nếu bạn tăng gấp đôi trở lại trước khi chạy lên 7, số tiền tiết kiệm sẽ giảm.

Điều đó khá tệ, bởi vì, tôi không biết cách tính hai lần tiếp theo mà không thử tất cả các khả năng, điều này đưa chúng ta trở lại O (2 ^ N).

Ngoại trừ - đó là 2 ^ N với việc cắt tỉa. Tôi đã tính toán rằng "chuyến đi phụ" lên -2 chi phí 14, nhưng đã tăng 16, nếu tôi không có nhiều chuyến đi phụ hơn trước khi tôi thực hiện đến số cao nhất. Nếu số ngoài cùng bên phải là 5, tôi sẽ biết ngay chuyến đi phụ đến -2 không thể trả hết. (Chi phí vẫn là 14, lợi ích tối đa 12). Tôi cũng không phải cân nhắc đến -2 sau đó thực hiện chuyến đi phụ trước khi đạt 6, vì điều đó luôn thua kém khi chỉ đi thẳng đến điểm đó ngay từ đầu.

Tôi nghĩ bạn có thể giải quyết nó bằng cách tìm kiếm theo chiều rộng đầu tiên, duy trì không quá 2 * N ^ 2 tuples (boolean, int, int, int, chuỗi) trong đó các chuỗi dài như đường dẫn phức tạp.

Các bộ dữ liệu là (tối thiểu hoặc tối đa boolean, vị trí tối thiểu đã đi, vị trí tối đa đã đi, tổng lượng bức xạ phát ra, lịch sử đường dẫn).

Tôi thấy thuật toán sẽ như thế này:

1. Khởi tạo nhóm bộ dữ liệu thành một mục duy nhất, (min, 0, 0, 0, "")
2. Tìm một yếu tố trong hồ bơi có bức xạ tối thiểu phát ra. Nếu min và max tương ứng với min và max của tất cả các thùng, thì lịch sử đường dẫn là giải pháp tối ưu. Nếu không thì xóa nó khỏi pool.
3. Tính toán 2 hậu duệ của bộ này, mỗi con tương ứng với việc đi bên trái hoặc bên phải đến thùng chưa được xử lý tiếp theo.
4. Chèn con cháu vào hồ bơi. Nếu đã có một phần tử trong nhóm có cùng boolean, min và max như một hậu duệ mới, thì loại bỏ phần tử có số lượng bức xạ cao hơn.
5. goto 2.

Tìm kiếm và loại bỏ các bộ dữ liệu thống trị sẽ cải thiện đáng kể hiệu suất. Có thể đáng để thêm một cờ 'đã nhân giống "vào mỗi bộ dữ liệu và để lại các bộ dữ liệu được nhân giống trong hồ bơi.

Ngoài ra còn có một số quyết định quan trọng được đưa ra trong việc quyết định làm thế nào để lưu trữ các bộ dữ liệu, và tìm kiếm chúng cho sự thống trị và các yếu tố mới để nhân giống.