Là trường hợp đặc biệt của một vấn đề lập kế hoạch có thể giải quyết trong thời gian tuyến tính?

Alice, một sinh viên, có rất nhiều bài tập về nhà trong những tuần tới. Mỗi mục bài tập về nhà mất cô đúng một ngày. Mỗi mục cũng có thời hạn và tác động tiêu cực đến điểm số của cô ấy (giả sử một số thực, điểm thưởng chỉ cho giả định so sánh), nếu cô ấy bỏ lỡ thời hạn.

Viết một hàm đưa ra một danh sách (thời hạn, tác động của lớp) chỉ ra một lịch trình để làm bài tập về nhà vào ngày nào để giảm thiểu tổng tác động xấu đến điểm của cô ấy.

Tất cả các bài tập về nhà cuối cùng phải được thực hiện, nhưng nếu cô ấy bỏ lỡ thời hạn cho một món đồ, thì việc cô ấy chuyển nó vào lúc nào không quan trọng.

Trong một công thức thay thế:

ACME corp muốn cung cấp nước cho khách hàng. Họ đều sống dọc theo một con đường khó khăn. ACME có một số giếng phân phối dọc theo đường phố. Mỗi giếng chịu đủ nước cho một khách hàng. Khách hàng trả giá các khoản tiền khác nhau sẽ được cung cấp. Nước chỉ chảy xuống dốc. Tối đa hóa doanh thu bằng cách chọn khách hàng nào để cung cấp.

Chúng tôi có thể sắp xếp thời hạn bằng cách sử dụng sắp xếp xô (hoặc giả sử chúng tôi đã sắp xếp theo thời hạn).

Chúng ta có thể giải quyết vấn đề một cách dễ dàng bằng một thuật toán tham lam, nếu chúng ta sắp xếp theo tác động giảm dần trước tiên. Giải pháp đó sẽ không tốt hơn O (n log n).

Lấy cảm hứng từ Median of Median và các thuật toán cây kéo dài tuyến tính tối thiểu ngẫu nhiên , tôi nghi ngờ rằng chúng ta có thể giải quyết vấn đề lập lịch / dòng chảy đơn giản của mình trong thời gian tuyến tính (ngẫu nhiên?).

Tôi đang tìm kiếm:

• một thuật toán thời gian tuyến tính (có khả năng ngẫu nhiên)
• hoặc cách khác là một lập luận rằng thời gian tuyến tính là không thể

Như một bước đệm:

• Tôi đã chứng minh rằng chỉ cần biết những mục nào có thể được thực hiện trước thời hạn, là đủ để xây dựng lại lịch trình hoàn chỉnh trong thời gian tuyến tính. (Cái nhìn sâu sắc đó nằm dưới công thức thứ hai mà tôi chỉ hỏi về chứng chỉ.)
• Một chương trình tuyến tính đơn giản (tích phân!) Có thể mô hình hóa vấn đề này.
• Sử dụng tính hai mặt của chương trình này, người ta có thể kiểm tra một giải pháp được đề xuất cho ứng viên trong thời gian tuyến tính về tính tối ưu, nếu một người cũng được đưa ra giải pháp cho chương trình kép. (Cả hai giải pháp có thể được biểu diễn trong một số bit tuyến tính.)

Lý tưởng nhất, tôi muốn giải quyết vấn đề này trong một mô hình chỉ sử dụng so sánh giữa các tác động của lớp và không giả định các con số ở đó.

Tôi có hai cách tiếp cận vấn đề này --- một dựa trên các treap sử dụng thời hạn và tác động, QuickSelect khác giống như dựa trên việc chọn các yếu tố trục ngẫu nhiên và phân vùng các mục theo tác động. Cả hai đều có trường hợp xấu nhất buộc hiệu suất O (n log n) hoặc kém hơn, nhưng tôi không thể tạo ra một trường hợp đặc biệt đơn giản làm giảm hiệu suất của cả hai.

Một vài điều tôi phát hiện ra cho đến nay.

Chúng ta có thể giảm bớt chính mình để giải quyết vấn đề liên quan sau đây:

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

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

Tức là cung cấp dữ liệu đầu vào đã được sắp xếp theo thời hạn, nhưng cho phép số lượng tác vụ không âm tùy ý được thực hiện mỗi ngày. Đưa ra đầu ra bằng cách chỉ đánh dấu các yếu tố về việc chúng có thể được lên lịch kịp thời hay không.

Hàm sau có thể kiểm tra xem lịch biểu được cung cấp ở định dạng này có khả thi hay không, tức là liệu tất cả các mục vẫn còn trong lịch biểu có thể được lên lịch trước thời hạn hay không:

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

Nếu chúng tôi có một giải pháp ứng cử viên được đề xuất và tất cả các mục còn lại, chúng tôi có thể kiểm tra thời gian tuyến tính xem ứng viên đó có tối ưu hay không, liệu có bất kỳ mục nào trong tập hợp bên trái sẽ cải thiện giải pháp hay không. Chúng tôi gọi những vật phẩm nhẹ này , tương tự như thuật ngữ trong thuật toán Cây kéo dài tối thiểu

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 không chỉ kiểm tra lịch trình đề xuất cho sự tối ưu, nó còn cung cấp cho bạn một danh sách các mục có thể cải thiện một lịch trình không tối ưu.

$O(n^2)$$O(n\log n)$