4 yönlü bir durak planlayın

Bir grup araba ilerlemek için bekleyen 4 yollu bir dur işareti dizilmiş. Herkes kimin bir sonraki gideceği, kimin hangi yöne gideceği, vb. İle karıştırılır.

İşiniz, dur işaretindeki trafiği en uygun şekilde planlamaktır.

Dört kardinal yönün her biri için birer tane olmak üzere girdi 4 dönüş talebi dizesi olarak alırsınız. Her istek ya Lsola, Sdüze ya da Rsağa yöneliktir.

LLSLRLS
SSSRRSRLLR
LLRLSR
RRRLLLL

İlk sıra, kavşağın Kuzey girişindeki dizilimdir. Sıradaki ilk araba sola dönmek istiyor (yani Doğu'dan çıkmak). Sonraki satırlar gelen Doğu, Güney ve Batı girişleri içindir. Yani Batı'dan gelen ilk araba Güney'den çıkmak istiyor.

Trafik bir dizi adımda hareket eder. Her adımda, ilerlemek için çizgilerinin başındaki arabaların bir alt kümesini seçmelisiniz. Seçilen arabalar birbirini engellememelidir . İki araba aynı yönden çıkarlarsa veya birbirlerinin yolunu geçmeleri gerekiyorsa müdahale ederler (standart sağdan direksiyon kuralları verilir). Bu nedenle, her ikisi de düz gitmek isteyen iki karşıt araba aynı adımda gidebilir. Yani 4 araba sağa dönmek istiyor olabilir. İki karşıt aracın ikisi de aynı anda sola dönebilir.

İşiniz kavşağı en az adımda planlamaktır. Her adım için, gelen araçların pusula yön (ler) ini içeren bir satır verin. Yukarıdaki örnek için, minimum program 14 adımdır. Minimum bir program:

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]

Programınız her satırda 1 dakikadan az 50 araç kullanabilmelidir. 4 dizginin girişi ve programın çıkışı dilinize uygun herhangi bir şekilde olabilir.

En kısa program kazanır.

Daha büyük bir örnek:

RRLLSSRLSLLSSLRSLR
RLSLRLSLSSRLRLRRLLSSRLR
RLSLRLRRLSSLSLLRLSSL
LLLRRRSSRSLRSSSSLLRRRR

minimum 38 mermi gerektirir. Olası bir çözüm:

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

Python, 1219 Bayt

Bu golf için çok fazla zaman / çaba harcamak yoktu, ama diğer cevaplar haşhaş başlarsa ben onu geliştirebilir. Kullandığım A * arama bir ile kabul sezgisel optimaliteye garanti. Sezginin de tutarlı olduğundan emin olmamıza rağmen (onaylamak için uğraşmamış olsam da) , yani O (dinamik programlama).

Program STDIN'den belirttiğiniz formatta dört satır okur ve sonucu STDOUT'a (belirttiğiniz formatta) yazdırır.

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

Örnek kullanım:

$ 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