4-वे स्टॉप शेड्यूल करें

Question

कारों का एक गुच्छा आगे बढ़ने की प्रतीक्षा में 4-वे स्टॉप साइन पर पंक्तिबद्ध है। हर कोई इस बात को लेकर असमंजस में है कि आगे कौन जाए, कौन किस रास्ते से जा रहा है, आदि जाहिर तौर पर सबॉप्टीमल।

आपका काम एक इष्टतम फैशन में स्टॉप साइन पर ट्रैफ़िक को शेड्यूल करना है।

आपको चार अनुरोधों में से प्रत्येक के लिए बारी अनुरोधों के इनपुट 4 तार प्राप्त होते हैं। प्रत्येक अनुरोध या तो Lबाएं के लिए है, Sसीधे के लिए है, या Rदाएं के लिए है।

LLSLRLS
SSSRRSRLLR
LLRLSR
RRRLLLL

पहली पंक्ति चौराहे के उत्तर प्रवेश द्वार पर लाइनअप है। लाइन में पहली कार बाईं ओर मुड़ना चाहती है (अर्थात, पूर्व से बाहर निकलें)। बाद की पंक्तियाँ आने वाले पूर्व, दक्षिण और पश्चिम प्रवेश द्वार के लिए हैं। तो पश्चिम से आने वाली पहली कार दक्षिण से बाहर निकलने की इच्छा रखती है।

चरणों की एक श्रृंखला में ट्रैफ़िक चलता है। प्रत्येक चरण पर, आपको आगे बढ़ने के लिए कारों के सबसेट का चयन करना होगा। चुनी गई कारों को एक-दूसरे के साथ हस्तक्षेप नहीं करना चाहिए । यदि वे एक ही दिशा से बाहर निकलते हैं या यदि वे एक-दूसरे के रास्ते को पार करते हैं (मानक दाएं-हाथ ड्राइविंग नियम दिए गए हैं) तो दो कारें हस्तक्षेप करती हैं। तो दो विपरीत कारें जो सीधे जाने की इच्छा रखती हैं, दोनों एक ही कदम पर जा सकती हैं। तो हो सकता है 4 कारें सभी सही मोड़ना चाहें। दो विपरीत कारें दोनों एक साथ बाईं ओर मुड़ सकती हैं।

आपका काम न्यूनतम चरणों की श्रृंखला में चौराहे को शेड्यूल करना है। प्रत्येक चरण के लिए, आने वाली कारों की कम्पास दिशा (ओं) के साथ एक पंक्ति को आउटपुट करें। ऊपर के उदाहरण के लिए, न्यूनतम अनुसूची 14 चरण है। एक न्यूनतम अनुसूची है:

N    [L from North]
E    [S from East]
E    [S from East]
E    [S from East]
NESW [L from North, R from East, L from South, R from West]
NE   [S from North]
EW   [R from East]
NESW [L from North, R from East, L from South, R from West]
W    [L from West]
EW   [L from East, L from West]
NESW [R from North, L from East, R from South, L from West]
NES  [L from North, R from East, L from West]
NS   [S from North, S from South]
SW   [R from South, L from West]

आपका कार्यक्रम 1 मिनट से कम समय में प्रत्येक पंक्ति में 50 कारों को संभालने में सक्षम होना चाहिए। अनुसूची के 4 तार और आउटपुट का इनपुट आपकी भाषा के लिए किसी भी सुविधाजनक तरीके से हो सकता है।

सबसे छोटा कार्यक्रम जीतता है।

एक बड़ा उदाहरण:

RRLLSSRLSLLSSLRSLR
RLSLRLSLSSRLRLRRLLSSRLR
RLSLRLRRLSSLSLLRLSSL
LLLRRRSSRSLRSSSSLLRRRR

जिसके लिए न्यूनतम 38 राउंड की आवश्यकता होती है। एक संभव समाधान:

E
EW
E
ESW
S
NS
ES
NESW
NSW
ESW
ES
NSW
NS
NS
NW
EW
NSW
NS
EW
NES
EW
NSW
NE
E
NE
EW
E
E
EW
EW
EW
W
ESW
NSW
NSW
NS
NSW
NEW

Comments

क्या मैं इसके बजाय एक राउंडअबाउट स्थापित कर सकता हूं ?

— डिजिटल ट्रॉमा

आपने पहले उदाहरण के लिए न्यूनतम अनुसूची की गणना कैसे की? मुझे लगता है कि यह एक मान्य 13-चरणीय कार्यक्रम है: NSW, NSW, ESW, EW, EW, NES, NE, EW, NE, NEW, NS, ES, E

— ESultanik

@ सुल्तानिक: आपका 4 वां कदम, ईडब्ल्यू, पूर्व की ओर सीधे जा रहा है, पश्चिम की ओर बाएं। यह एक स्वीकृत कॉन्फ़िगरेशन नहीं है।

— कीथ रान्डेल

@Fatalize: मेरे पास एक प्रोग्राम है जो इसे गतिशील प्रोग्रामिंग का उपयोग करता है।

— कीथ रान्डेल

आह, इसके बारे में क्षमा करें। मेरे कार्यक्रम में एक बग था। मैं जल्द ही एक उत्तर पोस्ट करूँगा ...

— ESultanik

Answer 1

पायथन, 1219 बाइट्स

मैंने इसे गोल्फ के लिए प्रयास करने में बहुत अधिक समय / प्रयास नहीं किया, लेकिन अगर अन्य उत्तर शुरू हो जाते हैं तो मैं इसे सुधार सकता हूं। मैं एक * स्वीकार्य खोजी के साथ * खोज का उपयोग करता हूं , इष्टतमता की गारंटी देता हूं । मुझे पूरा यकीन है (हालाँकि मैंने पुष्टि करने की जहमत नहीं उठाई है) कि हेयुरिस्टिक भी सुसंगत है , जिसका अर्थ है कि यह ओ (गतिशील प्रोग्रामिंग) है।

कार्यक्रम आपके द्वारा निर्दिष्ट प्रारूप में एसटीडीआईएन से चार लाइनों में पढ़ता है, और परिणाम को STDOUT में प्रिंट करता है, आपके द्वारा निर्दिष्ट प्रारूप में भी।

from heapq import heappush,heappop
from itertools import combinations
N,E,S,W=range(4)
L="L"
R="R"
T="S"
d=[{L:E,R:W,T:S},{L:S,R:N,T:W},{L:W,R:E,T:N},{L:N,R:S,T:E}]
b=set([(N,S,W,E),(N,S,E,W),(S,N,W,E),(S,N,E,W),(E,W,N,E),(N,S,W,N),(S,N,E,S),(W,E,S,W)])
for x in list(b):b.add(x[2:]+x[:2])
def v(*a):return a[1]!=a[3] and a not in b
i=lambda:raw_input()+'\n'
i=map(lambda l:map(lambda e:("NESW"[l[0]],d[l[0]][e]), l[1]),enumerate((i()+i()+i()+i()).split()))
q=[]
heappush(q,(0,[],i))
while q:
    h,a,n=heappop(q)
    m=sum(map(bool,n))
    if m==0:
        print "\n".join(a)
        break
    for r in range(4,0,-1):
        f=False
        for c in combinations(range(4),r):
            l=True
            for i in c:
                if not n[i]:
                    l=False
                    break
            if not l:continue
            l=True
            for x,y in combinations(c,2):
                if not v(x,n[x][0][1],y,n[y][0][1]):
                    l = False
                    break
            if l==False:continue
            f=True
            e=list(n)
            for i in c:e[i]=e[i][1:]
            heappush(q,(m-r+min(map(len,e)),a+["".join([n[x][0][0] for x in c])],e))
        if f:break

उदाहरण का उपयोग:

$ time echo "RRLLSSRLSLLSSLRSLR\nRLSLRLSLSSRLRLRRLLSSRLR\nRLSLRLRRLSSLSLLRLSSL\nLLLRRRSSRSLRSSSSLLRRRR" | python 4way.py
NES
NEW
NSW
NS
NS
ESW
NS
NES
NEW
NS
NES
NSW
NS
NS
NSW
NW
NS
NS
NS
EW
ES
SW
EW
EW
SW
ES
EW
EW
EW
EW
E
EW
EW
EW
EW
EW
E
EW
echo   0.00s user 0.00s system 38% cpu 0.002 total
python 4way.py  0.02s user 0.01s system 90% cpu 0.030 total