क्या यह एक समयबद्धन समस्या का विशेष मामला रैखिक समय में हल करने योग्य है?

Question

एक छात्र, एलिस ने अगले हफ्तों में बहुत सारे होमवर्क किए हैं। होमवर्क का प्रत्येक सामान उसे एक दिन में ले जाता है। प्रत्येक आइटम की एक समय सीमा भी होती है, और उसके ग्रेड पर एक नकारात्मक प्रभाव पड़ता है (एक वास्तविक संख्या मान लें, केवल तुलनीयता मानने के लिए बोनस अंक), अगर वह समय सीमा याद आती है।

एक फ़ंक्शन लिखें, जिसमें (समय सीमा, ग्रेड प्रभाव) की एक सूची दी गई है, जिसमें उस समय के लिए होमवर्क करना है जो उस दिन उसके ग्रेड पर बुरे प्रभाव के योग को कम करता है।

अंत में सभी होमवर्क करना पड़ता है, लेकिन अगर वह किसी आइटम के लिए समय सीमा याद करता है, तो इससे कोई फर्क नहीं पड़ता कि वह कितनी देर में बदल जाता है।

एक वैकल्पिक सूत्रीकरण में:

ACME कॉर्प ग्राहकों को पानी की आपूर्ति करना चाहता है। वे सभी एक ही ढलान वाली सड़क पर रहते हैं। ACME के ​​पास सड़क के किनारे कई कुएं हैं। प्रत्येक कुएं में एक ग्राहक के लिए पर्याप्त पानी होता है। आपूर्ति किए जाने के लिए ग्राहक विभिन्न राशियों की बोली लगाते हैं। पानी केवल नीचे की ओर बहता है। जो ग्राहक आपूर्ति करने के लिए चुनकर राजस्व को अधिकतम करें।

हम बाल्टी प्रकार का उपयोग करके समय सीमा को सॉर्ट कर सकते हैं (या बस मान लें कि हम पहले ही समय सीमा के अनुसार हल कर चुके हैं)।

यदि हम पहले ग्रेड प्रभाव से उतरते हैं, तो हम एक लालची एल्गोरिथ्म के साथ आसानी से समस्या को हल कर सकते हैं। वह समाधान O (n log n) से बेहतर नहीं होगा।

मेडियन ऑफ़ मेडियंस से प्रेरित और यादृच्छिक न्यूनतम फैले हुए पेड़ के एल्गोरिदम, मुझे संदेह है कि हम अपनी यादृच्छिक समयबद्धता / प्रवाह समस्या को (यादृच्छिक रूप से) रैखिक समय में भी हल कर सकते हैं।

मैं खोज रहा हूँ:

• एक (संभावित यादृच्छिक) रैखिक समय एल्गोरिथ्म
• या वैकल्पिक रूप से एक तर्क है कि रैखिक समय संभव नहीं है

एक कदम पत्थर के रूप में:

• मैंने पहले ही साबित कर दिया है कि सिर्फ यह जानना कि कौन सी वस्तुएं उनकी समय सीमा से पहले की जा सकती हैं, रैखिक समय में पूर्ण अनुसूची का पुनर्निर्माण करने के लिए पर्याप्त है। (वह अंतर्दृष्टि दूसरे सूत्रीकरण पर आधारित है जहाँ मैं केवल प्रमाणपत्र के बारे में पूछ रहा हूँ।)
• एक सरल (अभिन्न!) रैखिक कार्यक्रम इस समस्या को मॉडल कर सकता है।
• इस कार्यक्रम के द्वंद्व का उपयोग करते हुए, कोई भी उम्मीदवार को इष्टतम समय के लिए रैखिक समय में प्रस्तावित समाधान की जांच कर सकता है, अगर किसी को दोहरे कार्यक्रम का समाधान भी दिया जाता है। (दोनों समाधान बिट्स की एक रैखिक संख्या में दर्शाए जा सकते हैं।)

आदर्श रूप से, मैं इस समस्या को एक मॉडल में हल करना चाहता हूं जो केवल ग्रेड प्रभावों के बीच तुलना का उपयोग करता है, और वहां संख्याओं को ग्रहण नहीं करता है।

इस समस्या के लिए मेरे पास दो दृष्टिकोण हैं --- एक समय सीमा और प्रभाव का उपयोग करते हुए treaps पर आधारित, दूसरा क्विकसेलेक्ट-जैसे यादृच्छिक धुरी तत्वों को चुनने और प्रभाव द्वारा आइटमों को विभाजित करने पर आधारित है। दोनों के पास सबसे खराब मामले हैं जो O (n लॉग एन) या बदतर प्रदर्शन को बल देते हैं, लेकिन मैं एक साधारण विशेष मामले का निर्माण करने में सक्षम नहीं हूं जो दोनों के प्रदर्शन को नीचा दिखाता है।

Answer 1

कुछ बातें मुझे अब तक पता चली हैं।

हम निम्नलिखित संबंधित समस्या को हल करने के लिए खुद को कम कर सकते हैं:

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 न केवल इष्टतमता के लिए एक प्रस्तावित कार्यक्रम की जांच करता है, यह आपको उन वस्तुओं की एक सूची भी देता है जो एक गैर-इष्टतम अनुसूची में सुधार कर सकते हैं।

Answer 2

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

Comments

मुझे यह बहुत ठोस तर्क नहीं लगता कि यह समस्या रैखिक समय में हल करने योग्य नहीं है।

— टॉम वैन डेर ज़ैंडन

न तो मैं करता हूं। पूरे बिंदु को क्रमिक प्रभाव से सॉर्टिंग से बचने के लिए है, क्योंकि आपको पूर्ण क्रमचय के बारे में जानकारी की आवश्यकता नहीं है .. (QuickSelect में समान विचार।)

— Matthias

@ शीतल-यू, स्पष्ट करने के लिए, मैं कुछ भी निष्पादित नहीं करना चाहता हूं --- मैं सिर्फ शेड्यूल का निर्माण करना चाहता हूं।

— मथियास