Bu özel bir programlama problemi doğrusal zamanda çözülebilir mi?

Alice, öğrenci, gelecek haftalarda çok ödev yapıyor. Ödevlerin her biri tam olarak bir gün sürer. Her öğenin ayrıca bir son tarih ve notları üzerinde olumsuz bir etkisi vardır (gerçek sayıyı varsayar, sadece karşılaştırılabilirliği varsaymak için bonus puanlar), son tarihi kaçırırsa.

(Son teslim tarihi, not etkisi) listesi veren bir fonksiyon yazın, hangi ödevin hangi günde notları üzerindeki kötü etki toplamını en aza indirecek bir program hazırlar.

Tüm ödevlerin sonunda yapılması gerekir, ancak bir öğe için son tarihi kaçırırsa, ne kadar geç teslim ettiği önemli değildir.

Alternatif bir formülasyonda:

ACME corp müşterilere su sağlamak istiyor. Hepsi bir yokuş yukarı sokakta yaşıyor. ACME'nin cadde boyunca dağılmış birkaç kuyusu vardır. Her kuyu bir müşteri için yeterli su taşır. Müşteriler tedarik edilecek farklı miktarlarda para teklif ederler. Su sadece yokuş aşağı akıyor. Hangi müşterilere tedarik sağlanacağını seçerek geliri en üst düzeye çıkarın.

Son tarihleri ​​kova sıralamasını kullanarak sıralayabiliriz (veya son tarihe göre sıraladığımızı varsayabiliriz).

İlk önce not etkisini azaltarak sıralarsak, açgözlü bir algoritma ile sorunu kolayca çözebiliriz. Bu çözüm O (n log n) 'den daha iyi olmayacaktır.

Medyan Medyan'dan ve randomize doğrusal minimum yayılan ağaç algoritmalarından esinlenerek , basit zamanlama / akış problemimi (randomize?) Lineer zamanda da çözebileceğimizden şüpheleniyorum.

Bakıyorum:

• a (potansiyel olarak rastgele) doğrusal zaman algoritması
• veya alternatif olarak, doğrusal zamanın mümkün olmadığı iddiası

Basamak taşı olarak:

• Son tarihlerden önce hangi öğelerin yapılabileceğini bilmenin, tüm programı doğrusal zamanda yeniden oluşturmak için yeterli olduğunu zaten kanıtladım. (Bu anlayış, yalnızca sertifika hakkında sorduğum ikinci formülasyonun altında.)
• Basit (integral!) Doğrusal bir program bu sorunu modelleyebilir.
• Bu programın ikiliğini kullanarak, eğer ikili programa çözüm verilirse, adayın önerdiği çözüm doğrusallık açısından doğrusal zamanda kontrol edilebilir. (Her iki çözüm de doğrusal sayıda bit ile temsil edilebilir.)

İdeal olarak, bu sorunu sadece sınıf etkileri arasındaki karşılaştırmayı kullanan ve orada sayı kabul etmeyen bir modelde çözmek istiyorum.

Bu soruna iki yaklaşımım var - biri son teslim tarihini ve etkiyi kullanan muamelelere, diğer QuickSelect benzeri rastgele pivot öğelerini seçmeye ve öğeleri çarpmalara göre bölümlemeye dayalı. Her ikisinin de O (n log n) veya daha kötü performansı zorlayan en kötü durumları var, ancak her ikisinin performansını bozan basit bir özel durum oluşturamadım.

Şimdiye kadar öğrendiğim birkaç şey.

Aşağıdaki ilgili sorunu çözmek için kendimizi azaltabiliriz:

newtype Slot = Slot Int
newtype Schedule a = Schedule [(Slot, [a])]

findSchedule :: Ord a => Schedule a -> Schedule (a, Bool)

Giriş verilerini zaten son tarihe göre sıralanmış olarak veriyoruz, ancak her gün rastgele negatif olmayan sayıda görevin yapılmasına izin veriyoruz. Öğeleri sadece zamanlanıp zamanlanamayacaklarını işaretleyerek verin.

Aşağıdaki işlev, bu biçimde verilen bir çizelgenin uygulanabilir olup olmadığını, yani çizelgede bulunan tüm öğelerin son tarihlerinden önce planlanıp programlanamayacağını kontrol edebilir:

leftOverItems :: Schedule a -> [Int]
leftOverItems (Schedule sch) = scanr op 0 sch where
  op (Slot s, items) itemsCarried = max 0 (length items - s + itemsCarried)

feasible schedule = head (leftOverItems schedule) == 0

Önerilen bir aday çözümümüz varsa ve dışarıda bırakılan tüm öğeler varsa, adayın optimal olup olmadığını veya sol sette çözümü geliştirecek herhangi bir öğenin olup olmadığını kontrol edebiliriz. Bu hafif öğeleri Minimum Yayılan Ağaç algoritmasındaki terminolojiye benzer şekilde adlandırıyoruz

carry1 :: Ord a => Schedule a -> [Bound a]
carry1 (Schedule sch) = map (maybe Top Val . listToMaybe) . scanr op [] $ sch where
  op (Slot s, items) acc = remNonMinN s (foldr insertMin acc items)

-- We only care about the number of items, and the minimum item.
-- insertMin inserts an item into a list, keeping the smallest item at the front.
insertMin :: Ord a => a -> [a] -> [a]
insertMin a [] = [a]
insertMin a (b:bs) = min a b : max a b : bs

-- remNonMin removes an item from the list,
-- only picking the minimum at the front, if it's the only element.
remNonMin :: [a] -> [a]
remNonMin [] = []
remNonMin [x] = []
remNonMin (x:y:xs) = x : xs

remNonMinN :: Int -> [a] -> [a]
remNonMinN n l = iterate remNonMin l !! n

data Bound a = Bot | Val a | Top
  deriving (Eq, Ord, Show, Functor)

-- The curve of minimum reward needed for each deadline to make the cut:
curve :: Ord a => Schedule a -> [Bound a]
curve = zipWith min <$> runMin <*> carry1

-- Same curve extended to infinity (in case the Schedules have a different length)
curve' :: Ord a => Schedule a -> [Bound a]
curve' = ((++) <*> repeat . last) . curve

-- running minimum of items on left:
runMin :: Ord a => Schedule a -> [Bound a]
runMin = scanl1 min . map minWithBound . items . fmap Val

minWithBound :: Ord a => [Bound a] -> Bound a
minWithBound = minimum . (Top:)

-- The pay-off for our efforts, this function uses
-- the candidate solution to classify the left-out items
-- into whether they are definitely _not_ in
-- the optimal schedule (heavy items), or might be in it (light items).
heavyLight :: Ord a => Schedule a -> Schedule a -> ([[a]],[[a]])
heavyLight candidate leftOut =
    unzip . zipWith light1 (curve' candidate) . items $ leftOut
  where
    light1 pivot = partition (\item -> pivot < Val item)

heavyLight sadece önerilen zaman çizelgelerini kontrol etmekle kalmaz, aynı zamanda optimal olmayan bir zaman planını iyileştirebilecek öğelerin bir listesini de verir.

Hayır. Bu, doğrusal zamanda çözülebilen bir akış probleminin özel bir durumu değildir. Karmaşıklık tarafından verildiğinden ve kendini sıralarken karmaşıklık ve diğer tüm n süreçleri yürütmek için karmaşıklık kesinlikle doğrusal kalmaz.O ( n log n $O(n^2)$$O(n\log n)$