Próbuję zaimplementować możliwie efektywnie algorytm rozwiązujący pewien
problem sprowadzający się do gry o sumie stałej pomiędzy dwoma
przeciwnikami.

W pierwszym kroku zaimplementowałem algorytm min-max (w postaci negamax).

W moim problemie do danego stanu gry (transpozycji) można dojść czasami
na wiele różnych sposobów więc by przyśpieszyć działanie algorytmu
zastosowałem "memoryzację" czyli zapamiętuję już przeanalizowane stany
gry (transpozycje) i wykorzystuję taki wpis jeśli ponownie natrafię na
wcześniej przeanalizowaną transpozycję. Obliczenia znacząco
przyśpieszyły, wyniki zgodne, jak dotąd dobrze...

Obok, wzbogaciłem też algorytm negamax (bez memoryzacji) o alpha-beta
prunning. No i też OK: obliczenia przyśpieszyły, wyniki zgodne, jak
dotąd dobrze...

Dalej, chcę połączyć alpha-beta prunning z memoryzacją... Zaświtało mi w
głowie, że to będzie bardziej skomplikowane niż na początku by się mogło
wydawać... ale od czego Internet, poszukajmy jak zrobili to inni i
natrafiłem na artykuł Wikipedii:
https://en.wikipedia.org/wiki/Negamax#Negamax_with_a
lpha_beta_pruning_and_transposition_tables

Zaimplementowałem u siebie algorytm przedstawiony w Wikipedii i niestety
zacząłem otrzymywać wyniki niezgodne z trzema uprzednio przedstawionymi
metodami.
W dyskusji dotyczącej artykułu jedna z osób narzeka, że i u niej
algorytm z Wikipedii nie działa, inna osoba jednak kontruje, że algorytm
jest na pewno poprawny, a wina jest po stronie niewłaściwego
zaimplementowania tegoż algorytmu.
Spędziłem jeszcze trochę czasu na poszukiwaniach innych opisów
alpha-beta prunning with memorization, ale nic lepszego niż to co w
Wikipedii nie znalazłem.

Próbuję więc samodzielnie przemyśleć problem i w pełni go zrozumieć...
W algorytmie z Wiki w tablicy transpozycji dodatkowo zapisywana jest
flaga, która przyjmuje stany: UPPERBOUND, LOWERBOUND, EXACT.
Moim zdaniem to jednak za mało informacji by móc rozstrzygnąć czy można
taki wpis w przyszłości wykorzystać.
Moim zdaniem trzeba zapisać w tablicy transpozycji parametry alpha
(alphaOrig wg algorytmu Wiki) i beta przy jakich został obliczony wynik
gry dla danej transpozycji.

Zapamiętuję więc dla każdej transpozycji parametry alpha i beta (bardzo
niechętnie bo pożerają pamięć).
Gdy natrafię ponownie na daną transpozycję dokonuję sprawdzenia czy
alpha_current >= alpha_memorized oraz czy beta_current <= beta_memorized.
Z obliczonej uprzednio wartości korzystam tylko wtedy, gdy oba powyższe
warunki są spełnione. No i chyba działa... tj. wyniki zgodne oraz
otrzymałem najszybszą wersję algorytmu.

Pozostają jednak wątpliwości czy nie da się tu czasem czegoś ulepszyć:
np. gdy nie da się użyć wartości z tablicy transpozycji to być może da
się jakoś zmodyfikować parametr alpha lub beta by uzyskać lepszą
wydajność. Algorytm z Wiki ma coś takiego:

if ttEntry.Flag = EXACT
return ttEntry.Value
else if ttEntry.Flag = LOWERBOUND
? := max( ?, ttEntry.Value)
else if ttEntry.Flag = UPPERBOUND
? := min( ?, ttEntry.Value)
endif
if ? >= ?
return ttEntry.Value

Cały czas też się zastanawiam, czy faktycznie nie wystarczy wspomniana w
Wiki flaga, zamiast pełnej informacji alpha, beta.
Różne próby robione "na macanta" dają jednak niepoprawne wyniki...

Jak powinien wyglądać algorytm alpha beta prunning z memoryzacją?
Może jednak ten z Wiki jest dobry, a ja popełniam błąd w implementacji?

pzdr
mk