Memotong batang yang sama dari batang yang berbeda

Anda memiliki tongkat panjang yang sewenang-wenang, tidak harus integral.$n$

Dengan memotong beberapa batang (satu potong memotong satu batang, tetapi kita dapat memotong sesering yang kita inginkan), Anda ingin mendapatkan batang sedemikian rupa sehingga:$k<n$

• Semua tongkat ini memiliki panjang yang sama;$k$
• Semua tongkat setidaknya sepanjang tongkat lainnya.$k$

Perhatikan bahwa kita mendapatkan stick setelah melakukan pemotongan$n + C$$C$

Algoritma apa yang akan Anda gunakan sehingga jumlah pemotongan yang diperlukan minimal? Dan berapa angka itu?

Sebagai contoh, ambil dan . Algoritme berikut dapat digunakan:$k=2$$n\geq 2$

• Pesan tongkat dengan urutan panjang sedemikian rupa sehingga .$L_1\geq L_2 \geq \ldots \geq L_n$
• Jika maka potong stick # 1 menjadi dua bagian yang sama. Sekarang ada dua batang dengan panjang , yang setidaknya sepanjang tongkat yang tersisa .$L_1\geq 2 L_2$$L_1 / 2$$2 \ldots n$
• Kalau tidak ( ), potong stick # 1 menjadi dua potongan ukuran yang tidak sama dan . Sekarang ada dua batang dengan panjang , yang lebih panjang dari dan batang lainnya .$L_1 < 2 L_2$$L_2$$L_1-L_2$$L_2$$L_1-L_2$$3 \ldots n$

Dalam kedua kasus, satu potongan sudah cukup.

Saya mencoba untuk menggeneralisasi ini ke lebih besar , tetapi tampaknya ada banyak kasus untuk dipertimbangkan. Bisakah Anda menemukan solusi yang elegan?$k$

Pengamatan inti pertama untuk memecahkan masalah ini adalah kelayakan panjang pemotongan ,$l$

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

adalah piecewise-konstan, kiri-kontinu dan tidak-meningkat di . Karena jumlah potongan yang diperlukan berperilaku sama, menemukan panjang optimal adalah adil$l$

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

Lebih jauh, seperti jawaban lain yang telah diajukan, semua lompatan diskontinuitas memiliki bentuk . Ini membuat kita dengan masalah, pencarian satu dimensi diskrit setuju untuk pencarian biner (setelah mengurutkan satu set kandidat yang terbatas).$L_i/j$

Perhatikan lebih lanjut bahwa kita hanya perlu mempertimbangkan yang lebih pendek dari k- terbesar, karena yang satu selalu layak.$L_i$$k$

Kemudian, batas yang berbeda pada mengarah pada algoritma dengan efisiensi yang berbeda.$j$

• menghasilkan ruang pencarian ukuran kuadrat (dalam k ),$1 \leq j \leq k$$k$
• dalam linearitmik (dengan asumsi L i diurutkan berdasarkan ukuran yang menurun), dan$1 \leq j \leq \lceil k/i \rceil$$L_i$
• batas sedikit lebih terlibat dalam linier.

Dengan menggunakan ini, kita dapat menyelesaikan masalah yang diajukan dalam waktu dan spasi Θ ( n + k ) .$\Theta(n + k \log k)$$\Theta(n + k)$

Salah satu pengamatan lebih lanjut adalah bahwa jumlah di tumbuh di l oleh 1 untuk setiap calon L i / j "lulus", penghitungan duplikat. Dengan menggunakan ini, kita dapat menggunakan pemilihan peringkat daripada pencarian binar dan mendapatkan algoritma yang berjalan dalam ruang dan waktu Θ ( n ) , yang optimal.$\mathrm{Feasible}$$l$$1$$L_i/j$$\Theta(n)$

Temukan detailnya di artikel kami Algoritma Efisien untuk Divisi Tongkat Bebas-Iri dengan Pemotongan Paling Sedikit (oleh Reitzig dan Wild, 2015).

Seperti yang disarankan @randomA, kami akan melanjutkan dalam dua tahap: Pertama-tama kami menemukan set tongkat yang akan dipotong dan kemudian meminimalkan jumlah potongan.

Seperti dalam kasus khusus dalam pertanyaan, kami mengurutkan / memberi nama tongkat sehingga . Ini membutuhkan waktu O ( n log n ) .$L_1 \ge L_2 \ge \dots \ge L_n$$O(n\log n)$

Seperti yang ditunjukkan oleh @ user1990169, kita tidak perlu memotong sepotong .$i\ge k$

Pada fase pertama kami menggunakan pencarian biner untuk menemukan angka , 1 ≤ s ≤ k , sehingga tongkat 1 , ... , s dapat dipotong menjadi setidaknya k keping ukuran L s (ditambah beberapa keping yang lebih kecil), tetapi tongkat 1 , … , s - 1 tidak dapat dipotong menjadi k potong berukuran L s - 1 . Ini akan membutuhkan waktu O ( k log k ) .$s$$1\le s \le k$$1, \dotsc, s$$k$$L_s$$1, \dotsc, s-1$$k$$L_{s-1}$$O(k\log k)$

Jika , nilai ini adalah ukuran optimal dan kita dapat melewati fase dua.$L_{s-1} = L_s$

Jika tidak kita tahu bahwa ukuran optimal memenuhi L s - 1 > o ≥ L s dan jika o > L s kemudian o hasil dari pemotongan setidaknya satu dari tongkat-potong berukuran sama. Fase dua akan menentukan o :$o$$L_{s-1} > o \ge L_s$$o > L_s$$o$$o$

Untuk setiap tongkat , 1 ≤ i ≤ s , menentukan satu set ukuran kandidat sebagai berikut: Jika memotong menjadi potongan-potongan ukuran L s bergantian tongkat ke dalam r i buah (termasuk yang lebih pendek, jika ada), maka calon ini tongkat adalah semua nilai L $i$$1\le i \le s$$L_s$$r_i$ , di manaj≤ridanL$\frac{L_i}j$$j\le r_i$. (Lihatjawaban @ user1990169untuk alasan mengapa ini adalah satu-satunya ukuran kandidat.)$\frac{L_i}j<L_{s-1}$

Pertahankan untuk setiap ukuran kandidat, seberapa sering hal itu terjadi. Menggunakan pohon pencarian yang seimbang, ini dapat dilakukan di , karena jumlah total ukuran calon terikat oleh Σ i r i ≤ 2 k .$O(k\log k)$$\sum_i r_i \le 2k$

Sekarang ukuran kandidat yang paling sering terjadi dan mengarah ke pemotongan yang valid adalah yang memberikan kita solusi optimal. Selain itu, jika ada ukuran kandidat yang mengarah ke pemotongan yang valid, ukuran yang lebih kecil akan mengarah ke pemotongan yang valid juga.

Jadi kita dapat lagi menggunakan pencarian biner untuk menemukan panjang kandidat terbesar yang mengarah ke pemotongan valid . Kemudian kita beralih pada kumpulan panjang kandidat hingga ambang ini dan menemukan satu dengan banyak terbesar di antara mereka di O ( k ) .$O(k\log k)$$O(k)$

Secara total kita mendapatkan runtime di , atau O ( k log k ) , jika kita mengabaikan (atau tidak harus melakukan) jenis awal.$O(n\log n)$$O(k\log k)$

Setelah Anda telah memerintahkan tongkat dalam urutan panjang mereka, maka tongkat harus dipotong hanya jika semua tongkat L 1 , L 2 , . . . L i - 1 telah terpotong.$L_i$$L_1, L_2, ... L_{i-1}$

Sekarang karena , kita tidak akan membuat potongan pada tongkat L k dan seterusnya, karena kita selalu dapat memiliki tongkat k dengan panjang L k .$k < n$$L_{k}$$k$$L_{k}$

Jadi sekarang alih-alih , kita hanya berurusan dengan tongkat k - 1 (mungkin menambahkan tongkat k -th secara keseluruhan), dan jumlah pemotongan maksimum yang diperlukan dalam kasus terburuk = k - 1 .$n$$k-1$$k$$= k-1$

Juga, jika jumlah pemotongan optimal adalah , maka harus ada setidaknya satu set stik di antara stik k - 1 yang akan diambil secara keseluruhan dari 1 stik asli$< k-1$$k-1$ (baik dalam bagian atau dalam 1 potong) , yaitu, tidak ada bagian dari tongkat asli yang akan dibiarkan 'tidak terambil'. Ini karena, berdasarkan prinsip lubang-merpati , harus ada setidaknya 1 potongan yang harus menghasilkan lebih dari 1 batang yang valid.

Anda kemudian dapat melakukan dua bersarang untuk loop (keduanya hingga ). Loop luar akan menunjukkan jumlah tongkat saya yang semua bagian harus diambil dan loop batin akan menunjukkan jumlah bagian j terbuat dari tongkat itu. Untuk setiap ukuran L $k$$i$$j$
memeriksa apakah Anda bisa mendapatkan tongkat k yang layak dengan memotong tongkatL1dan seterusnya secara berurutan, dan jika Anda bisa, maka perbarui pemotongan minimum yang diperlukan sejauh ini jika jumlah yang dibutuhkan saat ini kurang.$\frac{L_i}{j}$$L_1$

Total kompleksitas algoritma di atas adalah $O(nlog(n) + k^3)$

Ide tingkat tinggi adalah pencarian biner.

Ukuran masing-masing tongkat k yang diminta akan menjadi setidaknya tongkat terkecil dan paling besar yang terbesar. Karena itu, kami melanjutkan dengan menggunakan pencarian biner pada ukuran tongkat tengah, lihat nomor dapat kita peroleh, jika k ′ ini lebih dari yang diberikan k maka kita tahu bahwa kita perlu memilih ukuran kandidat referensi baru. Jadi kami pindah ke tongkat referensi baru yang lebih besar atau lebih kecil. Kita berhenti ketika k ′ kurang dari $k'$$k'$$k$$k'$$k$

Setelah kami menemukan tongkat referensi yang sesuai, ada tempat sudut di mana kami perlu memperbaiki ukuran lebih lanjut. Kita dapat mengurutkan semua potongan tongkat dengan jumlah potongan pada mereka dan ukuran tongkat. Pilih satu dengan jumlah pemotongan paling sedikit dan ukuran paling sedikit. Kurangi jumlah potongan pada stick ini sebanyak 1 dan buat semua sub-stick dengan ukuran yang sama. Ini akan menjadi ukuran referensi baru, periksa untuk melihat apakah ukuran baru ini dapat menyebabkan dapat diterima . Saya akui, saya tidak tahu bagaimana cara mengikat waktu berjalan dalam kasus ini.$k'$

Semoga saya bisa melihat sesuatu yang bermanfaat dari jawaban lain.