amoba

ora4.2/amoba.py

@@ -0,0 +1 @@
+from keres import *

ora4.2/keres.py

@@ -0,0 +1,125 @@
+import sys
+from seged import *
+
+
+class Feladat:
+
+    def __init__(self, kezdő, cél=None):
+        self.kezdő = kezdő;
+        self.cél = cél
+
+    def rákövetkező(self, állapot): #operator elofeltetel
+        raise NotImplementedError
+
+    def érték(self):
+        raise NotImplementedError
+
+    def célteszt(self, állapot):
+       return állapot == self.cél
+       #raise NotImplementedError
+
+    def útköltség(self, c, állapot1, lépés, állapot2):
+        return c + 1
+
+
+class Csúcs:
+
+    def __init__(self, állapot, szülő=None, lépés=None, útköltség=0):
+        self.állapot = állapot
+        self.szülő = szülő
+        self.lépés = lépés
+        self.útköltség = útköltség
+        if szülő:
+            self.mélység = szülő.mélység + 1
+        else:
+            self.mélység = 0
+
+    def __repr__(self):
+        return "<Csúcs: %s>" % (self.állapot, )
+
+        #return "%s" % (list(self.állapot),)
+
+    def út(self):
+        x, válasz = self, [self]
+        while x.szülő:
+            válasz.append(x.szülő)
+            x = x.szülő
+        return válasz
+
+    def megoldás(self):
+        utam = self.út()
+        utam.reverse()
+        return [csúcs.lépés for csúcs in utam[1:]]
+
+    def kiterjeszt(self, feladat):
+        for (művelet, következő) in feladat.rákövetkező(self.állapot):
+            if következő not in [csúcs.állapot for csúcs in self.út()]:
+                yield Csúcs(következő, self, művelet,
+                            feladat.útköltség(self.útköltség, self.állapot, művelet,
+                                              következő))
+
+
+def fakeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_fakeresés(feladat):
+    return fakeresés(feladat, Sor())
+
+
+def mélységi_fakeresés(feladat):
+    return fakeresés(feladat, Verem())
+
+
+
+def gráfkeresés(feladat, perem):
+    global meglátogatott_csúcsok
+    zárt = set()
+    perem.append(Csúcs(feladat.kezdő))
+    while perem:
+        meglátogatott_csúcsok += 1;
+        csúcs = perem.pop()
+        if feladat.célteszt(csúcs.állapot):
+            return csúcs
+        if csúcs.állapot not in zárt:
+            zárt.add(csúcs.állapot)
+            perem.extend(csúcs.kiterjeszt(feladat))
+    return None
+
+
+def szélességi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Sor())
+
+
+def mélységi_gráfkeresés(feladat):
+    return gráfkeresés(feladat, Verem())
+
+
+
+def best_first(feladat, f):
+    return gráfkeresés(feladat, RendezettLista(f))
+
+
+def a_csillag(feladat, h):
+    def f(n):
+        return n.útköltség + h(n)
+
+    return best_first(feladat, f)
+
+
+def csúcsok_statisztika():
+    global meglátogatott_csúcsok
+    tmp = meglátogatott_csúcsok
+    meglátogatott_csúcsok = 0
+    return tmp
+
+
+meglátogatott_csúcsok = 0;

ora4.2/seged.py

@@ -0,0 +1,68 @@
+
+import bisect
+import random
+import functools
+
+class Várólista:
+    def __init__(self):
+        pass
+    def extend(self, elemek):
+        for elem in elemek: self.append(elem)
+
+
+def Verem():
+    return []
+
+
+class Sor(Várólista):
+    def __init__(self):
+        self.A = []; self.kezd = 0
+    def append(self, elem):
+        self.A.append(elem)
+    def __len__(self):
+        return len(self.A) - self.kezd
+    def extend(self, elemek):
+        self.A.extend(elemek)
+        
+    def pop(self):
+        e = self.A[self.kezd]
+        self.kezd += 1
+        if self.kezd > 5 and self.kezd > len(self.A)/2:
+            self.A = self.A[self.kezd:]
+            self.kezd = 0
+        return e
+    
+
+
+class RLElem:
+    def __init__(self,érték,elem):
+        self.értékem = érték
+        self.elemem = elem
+    def __lt__(self,másik):
+        return self.értékem < másik.értékem
+    def érték(self):
+        return self.értékem
+    def elem(self):
+        return self.elemem
+
+class RendezettLista(Várólista):
+    def __init__(self, f):
+        self.A=[]
+        self.f=f
+    def append(self, elem):
+        pár = RLElem(self.f(elem),elem)
+        bisect.insort(self.A, pár)
+    def __len__(self):
+        return len(self.A)
+    def pop(self):
+            return self.A.pop(0).elem()
+
+
+def argmin(lista, fv):
+    legjobb = lista[0]; legjobb_érték = fv(legjobb)
+    for x in lista[1:]:
+        x_érték = fv(x)
+        if x_érték < legjobb_érték:
+            legjobb, legjobb_érték = x, x_érték
+    return legjobb
+