이 특별한 스케줄링 문제의 경우 선형 시간으로 해결할 수 있습니까?

학생 인 Alice는 다음 주 동안 많은 숙제를합니다. 숙제의 각 항목은 정확히 하루가 걸립니다. 각 항목에는 마감일이 있으며 마감일을 놓치면 성적에 부정적인 영향을 미칩니다 (실수, 비교할 경우 보너스 포인트 가정).

(마감일, 성적 영향) 목록을 제공하는 기능을 작성하여 숙제가 성적에 미치는 악영향의 합계를 최소화하기 위해 어떤 요일에 수행해야하는 일정을 파악하십시오.

모든 숙제는 결국에는 이루어져야하지만, 아이템에 대한 마감일을 놓친 경우 얼마나 늦게 제출했는지는 중요하지 않습니다.

대안의 제형에서 :

ACME는 고객에게 물을 공급하려고합니다. 그들은 모두 오르막길을 따라 산다. ACME에는 길을 따라 여러 개의 우물이 분포되어 있습니다. 각 우물에는 한 고객에게 충분한 물이 담겨 있습니다. 고객은 다른 금액의 돈을 공급받습니다. 물은 내리막 길만 흐릅니다. 공급할 고객을 선택하여 수익을 극대화하십시오.

버킷 정렬을 사용하여 마감일을 정렬 할 수 있습니다 (또는 마감일을 기준으로 이미 정렬했다고 가정).

성적 영향을 내림차순으로 정렬하면 욕심 많은 알고리즘으로 문제를 쉽게 해결할 수 있습니다. 이 솔루션은 O (n log n)보다 낫지 않습니다.

Median of Medians 와 무작위 선형 최소 스패닝 트리 알고리즘에서 영감을 받아 (랜덤 화?) 선형 시간에 간단한 일정 / 흐름 문제를 해결할 수 있다고 생각합니다.

내가 찾고 있어요:

• (잠재적으로 무작위 화 된) 선형 시간 알고리즘
• 또는 대안 적으로 선형 시간이 불가능하다는 주장

디딤돌로 :

• 마감일 이전에 수행 할 수있는 항목을 아는 것만으로도 전체 일정을 선형 시간으로 재구성하기에 충분하다는 것을 이미 입증했습니다. (이 통찰력은 인증서에 대해서만 묻는 두 번째 공식의 기본입니다.)
• 간단한 (통합!) 선형 프로그램이이 문제를 모델링 할 수 있습니다.
• 이 프로그램의 이중성을 사용하면, 이중 프로그램에 대한 솔루션이 제공되는 경우, 후보 제안 솔루션을 최적의 선형 시간으로 확인할 수 있습니다. (두 솔루션 모두 선형 비트 수로 표현할 수 있습니다.)

이상적으로는 등급 영향 간의 비교 만 사용하고 숫자를 가정하지 않는 모델 에서이 문제를 해결하고 싶습니다.

이 문제에 대한 두 가지 접근 방식이 있습니다. 하나는 마감 시간과 영향을 사용하는 가파른 방식을 기반으로하고 다른 하나는 임의의 피벗 요소를 선택하고 영향을 기준으로 항목을 분할하는 방식을 기반으로하는 QuickSelect입니다. 둘 다 최악의 경우 O (n log n) 또는 성능 저하를 유발하지만, 두 가지 성능을 저하시키는 간단한 특수 사례를 만들 수 없었습니다.

내가 지금까지 알아 낸 몇 가지.

우리는 다음과 같은 관련 문제를 해결할 수 있습니다.

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

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

즉, 입력 데이터를 마감 기한별로 이미 정렬했지만 음수가 아닌 임의의 수의 작업을 매일 수행 할 수 있습니다. 요소를 제 시간에 예약 할 수 있는지 여부를 표시하여 출력을 제공하십시오.

다음 기능은이 형식으로 지정된 일정이 실행 가능한지 여부, 즉 일정에 아직 남아있는 모든 항목을 마감일 전에 예약 할 수 있는지 여부를 확인할 수 있습니다.

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

제안 된 후보 솔루션이 있고 모든 항목이 누락 된 경우, 후보가 최적인지 또는 왼쪽 세트에 솔루션을 개선 할 수있는 항목이 있는지 선형 시간으로 확인할 수 있습니다. 최소 스패닝 트리 알고리즘 의 용어 와 유사하게 이러한 라이트 항목을 호출 합니다.

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 제안 된 일정을 통해 최적의 상태를 확인할뿐만 아니라 최적이 아닌 일정을 개선 할 수있는 항목 목록도 제공합니다.

아닙니다. 이것은 선형 시간으로 해결할 수있는 흐름 문제의 특별한 경우가 아닙니다. 복잡성은 의해 주어지고 자체 정렬하는 동안 우리는 복잡성을 로 얻고 다른 모든 n 프로세스를 실행하기 위해서는 복잡성이 선형으로 유지되지 않습니다.O ( N 로그 N $O(n^2)$$O(n\log n)$