Cắt que bằng nhau từ các que khác nhau

Bạn có gậy có độ dài tùy ý, không nhất thiết phải tích phân.$n$

Bằng cách cắt một số que (một vết cắt cắt một que, nhưng chúng ta có thể cắt thường xuyên như chúng ta muốn), bạn muốn có được gậy như vậy:$k<n$

• Tất cả các que này có cùng chiều dài;$k$
• Tất cả các gậy ít nhất là dài như tất cả các gậy khác.$k$

Lưu ý rằng chúng tôi thu được sau khi thực hiện cắt$n + C$$C$

Thuật toán nào bạn sẽ sử dụng sao cho số lần cắt cần thiết là tối thiểu? Và con số đó là gì?

Ví dụ: lấy và bất kỳ . Thuật toán sau có thể được sử dụng:n ≥ $k=2$$n\geq 2$

• Sắp xếp các que theo thứ tự độ dài giảm dần sao cho .$L_1\geq L_2 \geq \ldots \geq L_n$
• Nếu thì cắt thanh số 1 thành hai mảnh bằng nhau. Hiện tại có hai thanh có chiều dài , ít nhất bằng với các thanh còn lại .L 1 / 2 2 ... $L_1\geq 2 L_2$$L_1 / 2$$2 \ldots n$
• khác ( ), cắt thanh số 1 thành hai mảnh có kích thước không bằng nhau và . Hiện tại có hai gậy có chiều dài , dài hơn và các gậy khác .L 2 L 1 - L 2 L 2 L 1 - L 2 3 ... $L_1 < 2 L_2$$L_2$$L_1-L_2$$L_2$$L_1-L_2$$3 \ldots n$

Trong cả hai trường hợp, một vết cắt duy nhất là đủ.

Tôi đã cố gắng khái quát hóa điều này để lớn hơn , nhưng dường như có rất nhiều trường hợp để xem xét. Bạn có thể tìm thấy một giải pháp thanh lịch?$k$

Quan sát cốt lõi đầu tiên để giải quyết vấn đề này là tính khả thi của chiều dài cắt ,$l$

$\qquad\displaystyle \operatorname{Feasible}(l) = \biggl[\, \sum_{i=1}^n \Bigl\lfloor\frac{L_i}{l} \Bigr\rfloor \geq k \,\biggr]$ ,

là piecewise-hằng, trái liên tục và không tăng trong . Vì số lần cắt cần thiết hoạt động tương tự nhau, việc tìm độ dài tối ưu chỉ là$l$

$\qquad\displaystyle l^{\star} = \max \{ l \mid \operatorname{Feasible}(l) \}$ .

Hơn nữa, như các câu trả lời khác đã đề xuất, tất cả các trường hợp không liên tục nhảy có dạng . Điều này khiến chúng ta gặp phải một vấn đề tìm kiếm một chiều, rời rạc, phù hợp với tìm kiếm nhị phân (sau khi sắp xếp một tập hợp các ứng cử viên hữu hạn).$L_i/j$

Ngoài ra, xin lưu ý rằng chúng ta chỉ cần xem xét ngắn hơn -lestest, vì điều đó luôn khả thi.$L_i$$k$

Sau đó, các giới hạn khác nhau trên dẫn đến các thuật toán có hiệu quả khác nhau.$j$

• $1 \leq j \leq k$ dẫn đến một không gian tìm kiếm có kích thước bậc hai (tính bằng ),$k$
• $1 \leq j \leq \lceil k/i \rceil$ theo dạng tuyến tính (giả sử được sắp xếp theo kích thước giảm dần) và$L_i$
• giới hạn hơn một chút trong một tuyến tính.

Sử dụng điều này, chúng ta có thể giải quyết vấn đề được đề xuất trong thời gian và dấu cách .$\Theta(n + k \log k)$$\Theta(n + k)$

Một quan sát nữa là tổng trong phát triển trong bởi cho mỗi ứng viên "thông qua", đếm các bản sao. Sử dụng điều này, chúng ta có thể sử dụng lựa chọn thứ hạng thay vì tìm kiếm binar và có được thuật toán chạy theo thời gian và không gian , là tối ưu.$\mathrm{Feasible}$$l$$1$$L_i/j$$\Theta(n)$

Tìm các chi tiết trong bài viết của chúng tôi Thuật toán hiệu quả cho bộ phận cây gậy không ghen tị với những vết cắt ít nhất (bởi Reitzig và Wild, 2015).

Như @randomA đã đề xuất, chúng tôi sẽ tiến hành theo hai giai đoạn: Trước tiên, chúng tôi tìm thấy bộ gậy sẽ được cắt và sau đó giảm thiểu số lần cắt.

Như trong trường hợp đặc biệt trong câu hỏi, chúng tôi sắp xếp / đặt tên cho các que sao cho . Điều này mất thời gian .$L_1 \ge L_2 \ge \dots \ge L_n$$O(n\log n)$

Như @ user1990169 đã chỉ ra, chúng tôi không bao giờ phải cắt một mảnh .$i\ge k$

Trong giai đoạn đầu tiên, chúng tôi sử dụng tìm kiếm nhị phân để tìm số , , sao cho các que có thể được cắt thành ít nhất phần có kích thước (cộng với một số phần nhỏ hơn) , nhưng các que không thể được cắt thành mảnh có kích thước . Điều này sẽ mất thời gian .$s$$1\le s \le k$$1, \dotsc, s$$k$$L_s$$1, \dotsc, s-1$$k$$L_{s-1}$$O(k\log k)$

Nếu , giá trị này là kích thước tối ưu và chúng ta có thể bỏ qua giai đoạn hai.$L_{s-1} = L_s$

Mặt khác, chúng ta biết rằng kích thước tối ưu thỏa mãn và nếu thì kết quả từ việc cắt ít nhất một trong các que thành các miếng có kích thước bằng nhau. Giai đoạn hai sẽ xác định :$o$$L_{s-1} > o \ge L_s$$o > L_s$$o$$o$

Đối với mỗi thanh , , hãy xác định một tập hợp các kích thước ứng viên như sau: Nếu cắt thành các mảnh có kích thước sẽ biến thanh thành các mảnh (bao gồm cả ngắn hơn, nếu có), thì các ứng cử viên cho điều này thanh là tất cả các giá trị , trong đó và . (Xem câu trả lời của @ user1990169 để biết lý do tại sao đây là các kích thước ứng cử viên duy nhất.)$i$$1\le i \le s$$L_s$$r_i$$\frac{L_i}j$$j\le r_i$$\frac{L_i}j<L_{s-1}$

Duy trì cho từng kích thước ứng viên, tần suất xảy ra. Sử dụng cây tìm kiếm cân bằng, điều này có thể được thực hiện trong , vì tổng số kích thước ứng cử viên bị ràng buộc bởi .$O(k\log k)$$\sum_i r_i \le 2k$

Bây giờ kích thước ứng viên xảy ra thường xuyên nhất và dẫn đến cắt giảm hợp lệ là một trong đó cung cấp cho chúng tôi giải pháp tối ưu. Hơn nữa, nếu bất kỳ kích thước ứng cử viên nào dẫn đến việc cắt hợp lệ, thì bất kỳ kích thước nhỏ hơn nào cũng sẽ dẫn đến việc cắt hợp lệ.

Vì vậy, một lần nữa chúng ta có thể sử dụng tìm kiếm nhị phân để tìm độ dài ứng cử viên lớn nhất dẫn đến việc cắt hợp lệ trong . Sau đó, chúng tôi lặp lại tập hợp các độ dài ứng cử viên cho đến ngưỡng này và tìm ra nhóm có số lượng lớn nhất trong số họ trong .$O(k\log k)$$O(k)$

Tổng cộng chúng ta có một thời gian chạy trong hoặc , nếu chúng ta bỏ qua (hoặc không phải làm) sắp xếp ban đầu.$O(n\log n)$$O(k\log k)$

Sau khi bạn đã sắp xếp các que theo thứ tự giảm dần theo chiều dài của chúng, thì một thanh sẽ chỉ bị cắt nếu tất cả các gậy đã bị cắt.$L_i$$L_1, L_2, ... L_{i-1}$

Bây giờ vì , chúng tôi sẽ không thực hiện bất kỳ vết cắt nào trên gậy trở đi, vì chúng tôi luôn có thể có gậy có chiều dài .$k < n$$L_{k}$$k$$L_{k}$

Vì vậy, bây giờ thay vì , chúng ta chỉ xử lý các thanh (có thể thêm toàn bộ thanh thứ ) và số lần cắt tối đa sẽ được yêu cầu trong trường hợp xấu nhất .$n$$k-1$$k$$= k-1$

Ngoài ra, nếu số lần cắt tối ưu là , thì sẽ có ít nhất một bộ gậy trong số các gậy đó sẽ được lấy toàn bộ từ 1 thanh gốc$< k-1$$k-1$ (trong các phần hoặc trong 1 phần) , nghĩa là, không có phần nào của thanh gốc đó sẽ bị bỏ lại 'chưa được đánh dấu'. Điều này là do, theo nguyên tắc lỗ chim bồ câu , sẽ có ít nhất 1 vết cắt phải tạo ra nhiều hơn 1 cây gậy hợp lệ.

Sau đó, bạn có thể tiến hành hai vòng lặp lồng nhau (cả hai cho đến ). Vòng lặp bên ngoài sẽ biểu thị số thanh có tất cả các phần phải được thực hiện và vòng lặp bên trong sẽ biểu thị số phần được làm từ thanh đó. Đối với mỗi kích thước hãy kiểm tra xem bạn có thể lấy được gậy k khả thi hay không bằng cách cắt gậy trở đi liên tục và nếu có thể, thì hãy cập nhật các mức cắt tối thiểu cần thiết cho đến nay nếu số lượng yêu cầu hiện tại ít hơn.$k$$i$$j$
$\frac{L_i}{j}$$L_1$

Tổng độ phức tạp của thuật toán trên là$O(nlog(n) + k^3)$

Ý tưởng cấp cao sẽ là tìm kiếm nhị phân.

Kích thước của mỗi gậy k được yêu cầu sẽ ít nhất là que nhỏ nhất và nhiều nhất là que lớn nhất. Vì điều này, chúng tôi tiến hành bằng cách sử dụng tìm kiếm nhị phân trên kích thước của thanh giữa, xem số chúng tôi có thể nhận được, nếu này nhiều hơn cho trước thì chúng tôi biết rằng chúng tôi cần chọn kích thước ứng viên tham chiếu mới. Vì vậy, chúng tôi di chuyển đến lớn hơn hoặc nhỏ hơn bằng cách sử dụng thanh tham chiếu mới. Chúng ta dừng lại khi nhỏ hơnk ′$k'$$k'$$k$$k'$$k$

Khi chúng tôi đã tìm thấy thanh tham chiếu thích hợp, có một trường hợp góc mà chúng tôi sẽ cần phải tinh chỉnh kích thước hơn nữa. Chúng ta có thể sắp xếp tất cả các que cắt theo số lượng vết cắt trên chúng và kích thước của thanh. Chọn cái có số lần cắt ít nhất và kích thước nhỏ nhất. Giảm số lần cắt trên thanh này xuống 1 và làm cho tất cả các thanh phụ có kích thước bằng nhau. Đây sẽ là kích thước tham chiếu mới, kiểm tra xem kích thước mới này có thể dẫn đến chấp nhận được không . Tôi thừa nhận, tôi không biết làm thế nào để ràng buộc thời gian chạy trong trường hợp này.$k'$

Hy vọng, tôi có thể thấy một cái gì đó hữu ích từ các câu trả lời khác.